Im develop branch laufen alle aktuellen Entwicklungen zusammen, z. B. wenn ein Entwickler meint, er habe sein feature fertig: es wird zurück in den develop branch gebracht. Vorher hat der Entwickler (weil wir ja gern TDD machen) sichergestellt, dass das feature eine ausreichende Unit Test Abdeckung hat. Für ihn persönlich sollte es also ausreichend sein auf diese zu achten. Eine persönliche CI für sein feature wäre sicherlich ein adminitrativer overkill: ist das feature klein wird es sicher schnell fertig, dafür extra einen neuen CI job aufsetzen und nach Beendigung der feature Entwicklung wieder löschen?! Ne!

Der release branch benötigt aus anderen Gründen keine CI: er unterliegt nur einer kurzen Zeit wirklicher Entwicklungsarbeit: während der Erstellung eines Release.

Wichtiger ist dann schon der master branch. Er enthält den Source Code der aktuell in der Produktion verwendet wird. Aber: gegen ihn werden auch hotfixes durchgeführt! Also Änderungen am Produktions Kode. Diese sollten frühzeitig mit CI abgedeckt werden, jeder hotfix branch sollte also einen eigenen CI job haben. Ist der hotfix gut und es werden keine Integrationsfehler (mit dem Produktions Kode) mehr festgestellt, dann ist der hotfix fertig in den master branch überzugehen (und in develop).

. Plazes has removed the “places” Atom feed and just puts a “activities” feed online. This is not what I expect to get provided by a location service. Thanks for all, need to have a look at fireeagle…

So find me at: http://identi.ca/goern

with a new wordpress release and a sign of life! I am here.

A moat server is a piece of software accessible via HTTP and delivery HTML, RDF/XML or JSON representations of the meaning of a tag. moat server by Alexandre Passant drives my installation. It leverages PHP, MySQL and ARC2 do to its job. One feature I do miss is something like a scutter to gather data I may have published earlier.

Update xmlgrddl could be a good thing to extract tags from every post… need to have a look

just do a

SELECT ?node ?maker_name
FORM <http://b4mad.net/RDF/goern/nodelist.rdf>
WHERE {
 ?node <http://www.w3.org/2000/01/rdf-schema#type> <http://jabber.org/protocol/pubsub#node> .
 ?node <http://xmlns.com/foaf/0.1/maker> ?maker .
 ?maker <http://xmlns.com/foaf/0.1/name> ?maker_name
}

and receive a list of xmpp-URIs and their maker/owner. Try this at my new ARC2 based sparql endpoint or via GET…

The weapon of choice for near real time information delivery is obviously XMPP. I will use publish-subscribe to provide information, by doing so any of my peers may or may not subscribe to a node onto which I publish information. And I will set up a hierarchy of nodes onto which I will publish different kinds of information. So here we go with the root node: home/b4mad.net/goern, this is mainly due to the fact that I use ejabberd2 to run my XMPP Server. There are a few subnodes:

• bookmark – for bookmarks that I send out, I need to figure out the format of published information
• micropublish – for twitter like things, that is basically Atom over XMPP
• media/stillimage – for a photostream…

As a good semantic web citizen I will note down what nodes exist at which URI and what they are used for. The first rough scratch is available.

For the moment there is a shell like Java application which accepts two commands: exit and purge, to exit the shell and purge off all items from the micropublish node. Any other words typed in the shell will be treated a an micropublish update and published as a Atom entry to my micropublish node.  The second application is a gateway to twitter.com: it is subscribed to my pubsub micropublish node and will pick up any atom entry and post it as a twitter update.

The next thing it write up is a process and format to publish my bookmarks and to have some nice GUI clients that can handle my updates… Or should it be integrated into WorkPress?!

• Flickr.com – is good for sharing photos, but their time has come. Most important the censorship issues mark the point to flag flickr as “need to migrate away from it”. By now it is still in my accounts file
• del.icio.us – good and thats it… keep it
• jaiku.com – is aggregating other services and trying to give a timeline of my online footsteps. This is a good services from the point of “declarative living”, but: delete account, because:
• noserub has been implemented at #B4mad.Net this is good, as I take back control of my data back from jaiku
• mugshut.org is kind of the same thing, never really used it…
• I will use twitter for this microblogging thingy…
• all this SIP and VoIP accounts need to be deleted: mobile phones are not replacable
• plazes.com is kind of good as a location/presence services. I need to figure out how to do that with geonames.org and noserub by myself!
• openbc.com or xing… what is the value add of this service?
• upcoming.com and calendar.google.com – upcoming supports venues and is more like “calendar sharing” google calendar is … do I really need this?

I will try to consolidate even more and provide one web view of all that and one xmpp infrastructure to deliver updates to interessted agents/persons.

So I will check back in half a year, anyway: thanks for the service and for investments made!

mugshot provides a wiki to discuss ideas for the mugshot API. Time to give them ideas…

Subscribe to my brain was brought up by Leigh Dodds in June 2005. His goal was to consolidate different (subscribable) source of information a user published. The key he used to join this sources was the user’ mailbox IRI sha1 checksum. So he sent on and did it the semantic web way and provided a webservice to fulfill the task and provide a OPML file that may be imported directly into a aggregator.

Red Hat”s solution is to provide a single web pages to replace the aggregator and no webservice but user configurable source to aggregate from. This is nice, from a web design point of view. But it is basically redundant. For a semantic web guy, most of the information mugshot requests (by forcing me to fill in my user profile) is available on the web and maintained anyways:

• Accounts at flickr, del.icio.us et al – I have this written down in a RDF/XML FOAF file, as may others do on the web. Advantage: that foaf file is gnupg signed by me, it is verifiable if that account do really belong to me. Any user may open up a account at mugshot or flickr and predent his is me. The only authorative source for that information is my FOAF file.
• Personal Information – like my blog url, my picture and the user name and passowrd I”d like to use is requested by mugshot. Again, most of this information is stored in my FOAF files. Username and authentication may be provided by OpenID and friends.

Next interessting architectural decission of mugshot was to poll data by retrieving it from the sources I manually configured in my user profile. Feels like stone age now we have Ping the Semantic Web.com (PTSW). mugshot aggregates feed, so doing it the right way(tm) would be to monitor PTSW for updates of this feeds. If they are not pinging PTSW make them ping, that would help a bigger community than just the mughot guys and girls.

And finaly, it’s just a me too project, I did it in 2006: haha :) There is no need to let others consolidate a single page about myself.

PS: and why the hack is my email address spammer readable on mugshot??

An old mail gave me a clue that this is related to the afs cache manager: This error is KTC_NOCM..

afsd is responsible for providing the cache manager, at least under Debian GNU/Linux. A closer look at /etc/openafs/afs.conf.client revealed that AFS_CLIENT was set to false, which means: dont start afsd on startup.
Setting that to true and restart openafs-client solved the problem.

Another thing I have discovered while reading thru the updates is GeoPress a WordPress plugin that enables WordPress”s RSS feed and pages to include geo information per post.

It is a browser extension (for Fireofx only by now) which inspects web pages for links to Semantic Web metadata and informs the user about their presence by showing an icon in browser’s status bar.

Originally developed to detect presence of SIOC metadata it has been extended to cover other types of data. Currently it supports SIOC, FOAF and DOAP metadata.
The current version of Semantic Radar also pings the Semantic Web Ping Service when metadata is detected. This allows a community based discovery of the semantic web data and a notification of a central ping service.

UPDATE: Fred also has a post on Semantic Radar…

So how may a export of the URL having pinged in the last 2 hours look like?

<rdf:RDF xmlns="http://purl.org/net/scutter/"
 xmlns:dc="http://purl.org/dc/elements/1.1/"
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:scutter="http://purl.org/net/scutter/">

 <rdf:Description>
  <rdf:type rdf:resource="http://purl.org/net/scutter/Representation"/>
  <localCopy>cache/b4mad.net/datenbrei/index.php_sioc_type=post_sioc_id=300</localCopy>
  <source rdf:resource="http://b4mad.net/datenbrei/index.php?sioc_type=post&sioc_id=300"/>
  <origin rdf:resource="http://ping.semanticweb.org/ping/http://b4mad.net/datenbrei/index.php?sioc_type=site"/>
  <fetch rdf:parseType="Resource">
   <rdf:type rdf:resource="http://purl.org/net/scutter/Fetch"/>
   <dc:date rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">2006-08-06T14:35:11+0200</dc:date>
   <contentType>application/rdf+xml</contentType>
   <rawTripleCount>68</rawTripleCount>
   <status>200</status>
  </fetch>
  <fetch rdf:parseType="Resource">
   <rdf:type rdf:resource="http://purl.org/net/scutter/Fetch"/>
   <dc:date rdf:datatype="http://www.w3.org/2001/XMLSchema#dateTime">2006-08-05T19:23:16+0200</dc:date>
   <contentType>application/rdf+xml</contentType>
   <rawTripleCount>68</rawTripleCount>
   <status>200</status>
  </fetch>
 </rdf:Description>
</rdf:RDF>

And what does it all mean? The export above says:

http://b4mad.net/datenbrei/index.php?sioc_type=post&sioc_id=300 has been fetched two times: on 2006-08-06 and on 2006-08-05 always giving 68 statements and HTTP return code 200. A local copy has been stored to cache/b4mad.net/datenbrei/index.php_sioc_type=post_sioc_id=300. The crawler knew about the ping because of its origin.

Another valuable extension would be a RSS feed having all fetched items in it.

Currently enabled datasets:

• apassant.net – Alex’s Joseki
• sparql.captsolo.net – CaptSolo’s Joseki
• b4eg.mine.nu – B:\datenbrei development Joseki

Try this!

After a few discussions with CaptSolo and with some help from EliasT I have tweaked my WordPress to include the needed RDFa. Looking at the source of this page you will see something like:

<div class="primary" about="http://B4mad.Net/datenbrei/archives/2006/06/05/sioc-live-query/" role="sioc:Post">
 <span style="display:none">
  <link rel="rdfs:seeAlso" href="http://b4mad.net/datenbrei/index.php?sioc_type=post&sioc_id=308" about="http://B4mad.Net/datenbrei/archives/2006/06/05/sioc-live-query/">
  <meta property="dc:format">application/rdf+xml</meta>
 </link>
</span>
</div>

To enabled correct parsing and XML Namespace assignment by a RDFa parser the <html> element must contain namespace declarations for rdf, rdfs, dc and sioc.

Using some RDFa extractor service on any page on B:\datenbrei will give you a RDF file containing a rdfs:seeAlso (of type application/rdf+xml) which points to the RDF generated by the WordPress SIOC plugin for the corresponding page.

Next step: write a short XSLT to enable GRDDLing the same rdfs:seeAlso out of the post’s page.

Also erstmal Mail lesen und die heutigen Termine ausdrucken und dann das Update nochmal starten, bis gleich vielleicht…

SIOC plugin has been update to the current version, links from rss1:Channel to sioc:site and rss1:item to sioc:Post have been added to the RDF feed.

I like to reuse, so that’s the first policy.
The second policy is, that I dont want to deal with the email archives, but will use RSS or Atom representation of the archive as the source of information.

How to understand the information provided by mailing list archives in a SIOC context?

First of all, the mailing list archive is obviously a sioc:Forum (archive itself represented by a RSS or Atom feed) with sioc:Posts (individual mails, RSS/Atom items). The sender of the mail is a sioc:User, which is the sioc:has_creator of the sioc:Post. The website hosting the mailing list archive is defined as the sioc:Site, the initialy mentioned sioc:Forum sioc:has_host this sioc:Site. Got it?

As a test subject I took the SIOC-dev mailing list at Google Groups, development is supported by RDFReactor.

Results of my work can be found 1. as Java code and 2. as the resultung SIOC data.

Comments and any other feedback is welcome!

Planet RDF provides a foafroll, a RDF/XML representation of the feeds which get aggregated and their authors. This is a good starting point and actually a pretty complete description of the RDF community (at least of the blogging RDF community).

Taking a look at foafroll we find foaf:Agents and there blogs. This provided data will be convertet into SIOC Users in the first step.

<foaf:Agent rdf:nodeID="id2245901"> 
 <foaf:name>FOAF Project</foaf:name> 
 <foaf:weblog> 
  <foaf:Document rdf:about="http://rdfweb.org/"> 
   <dc:title>FOAF Project</dc:title> 
   <rdfs:seeAlso> 
    <rss:channel rdf:about="http://rdfweb.org/index.rdf"> 
     <foaf:maker rdf:nodeID="id2245901"/> 
     <foaf:topic rdf:resource="http://www.w3.org/2001/sw/"/> 
     <foaf:topic rdf:resource="http://www.w3.org/RDF/"/> 
    </rss:channel> 
   </rdfs:seeAlso> 
  </foaf:Document> 
 </foaf:weblog> 
 <foaf:interest rdf:resource="http://www.w3.org/2001/sw/"/> 
 <foaf:interest rdf:resource="http://www.w3.org/RDF/"/> 
</foaf:Agent>

I would like to propose a mapping like this:

 <sioc:User rdf:nodeID="sioc-id2245901">
  <sioc:name>FOAF Project</sioc:name>
  <sioc:link rdf:resource="http://rdfweb.org/" />
 </sioc:User>
 <foaf:Agent rdf:nodeID="id2245901"> 
  <foaf:holdsAccount rdf:nodeID="sioc-id2245901" />
 </foaf:Agent>

Next step is to set up a sioc:Usergroup containing all members (foaf:Agents) of the foafroll:

 <sioc:Usergroup rdf:ID="authors">
  <sioc:name>Authors at PlanetRDF.com</sioc:name>
  <sioc:has_member rdf:nodeID="sioc-id2245901" />
 </sioc:Usergroup>

Interpreting sioc:Site as “This is a Community” and not as “This is one Site of others of a Community” one must interpret Planet RDF as a Forum of the community/Site:

<sioc:Forum rdf:nodeID="f-1">
 <sioc:name>PlanetRDF.com, part of the RDF Community</sioc:name>
 <sioc:link rdf:resource="http://planetrdf.com/"/>
 <rdfs:seeAlso rdf:resource="http://planetrdf.com/index.rdf" />
</sioc:Forum>

<sioc:Site rdf:about="http://planetrdf.com/">
 <sioc:name>The RDF Community</sioc:name>
 <sioc:description>Planet of the RDF Community</sioc:description>
 <sioc:link rdf:resource="http://planetrdf.com/"/>
 <sioc:host_of rdf:nodeID="f-1"/>
 <sioc:has_group rdf:resource="#authors"/>
</sioc:Site>

Note: Maybe it would make some sense to rename sioc:Site to sioc:Community? See also a SIOC-dev posting (or was it a chat with CaptSolo??).

I have not done some Jena-based code up until now. Before releasing it I would like to have some comments on the idea, maybe some improvements need to be incorporated…

A complete example of a SIOC-from-foafroll (handcrafted) and some coffee is available too.

Loading the PlanetRDF ICS file into Apple’s iCal gives me a neat amount of new calendar entries, all in the past: iCal as RSS aggregator!

So, what is it good for? Maybe for easy reminders: using a category “reminders” (or whatever it’s name may be) and posting to that with post dates in the future, picking up that category’s RSS feed (post wouldn’t show up there by default) and convert it to an ICS file which is read in by a calendaring application. This is a way to have something like “group reminders”

Any other ideas?

After installing and activating the plugin it simply works as expected… Noting more to say: SIOC rocks!

Attention.XML is an open standard, built on open source that helps keeping track of what you’ve read, what you’re spending time on, and what you should be paying attention to.

So feel free to have a look on what I had a look on: goern’s feeds. Another step forward in the area of declarative living!

To transfer the attention data generated by endo I am trying to set up an Ontology as imagined by Attention RDF and a GRDDL transformation.

So the first step (this night) was to write down an Ontology that implements the Attention.XML Minimal Feed Sync Profile. Here are the first files as RDF/XML and N3.

So here are the first interessting candidates I would like to subscribe to:

• dagoneye
• stracciatella

And by the way: Norman Walsh, Leigh Dodds, Geoffrey Bilder and I have easy brain subscription URLs!

  <foaf:firstname>Christoph</foaf:name>
  <foaf:surname xml:lang="de">Görn</foaf:surname>
  <foaf:surname>Goern</foaf:surname>

Using the SPARQL query that

Show me all people along with their names (if found), unique IDs (if found), and calendar URLs (if found) in my current RDF dataset.

results in:

1 ( ?who = http ://B4mad.Net/FOAF/goern.rdf#goern ) ( ?name = "Christoph Goern" )
   ( ?id = "0a9d600329b781dcdd710bf97c8ad16c44cf8dc9" ) ( ?cal = http ://b4mad.net/addressbook/geburtstage.rdf )
2 ( ?who = http ://B4mad.Net/FOAF/goern.rdf#goern> ) ( ?name = "Christoph Goern" )
   ( ?id = "0a9d600329b781dcdd710bf97c8ad16c44cf8dc9" ) ( ?cal = http ://b4mad.net/FOAF/goern-reisen.rdf )
3 ( ?who = http ://B4mad.Net/FOAF/goern.rdf#goern ) ( ?name = "Christoph Görn"@de )
   ( ?id = "0a9d600329b781dcdd710bf97c8ad16c44cf8dc9" ) ( ?cal = http ://b4mad.net/addressbook/geburtstage.rdf )
4 ( ?who = http ://B4mad.Net/FOAF/goern.rdf#goern ) ( ?name = "Christoph Görn"@de )
   ( ?id = "0a9d600329b781dcdd710bf97c8ad16c44cf8dc9" ) ( ?cal = http ://b4mad.net/FOAF/goern-reisen.rdf )

Too many of myself! Note to self: fix my body count.

To do so, the SPARQL query should filter out any foaf:name that has a unset xml:lang:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX ical: <http://www.w3.org/2002/12/cal/icaltzd#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?who ?name ?id ?cal 
WHERE {
  ?who rdf:type foaf:Person .
  OPTIONAL { ?who foaf:name ?name }
  OPTIONAL { ?who rdfs:label ?name }
  OPTIONAL {
    { ?who foaf:mbox ?id } 
      UNION 
    { ?who foaf:mbox_sha1sum ?id } 
  }
  OPTIONAL {
    ?who rdfs:seeAlso ?cal .
     ?cal rdf:type ical:Vcalendar 
  } .
  FILTER ( langMatches( lang(?name), "" ) )
} ORDER BY ?name

Die neu erkannten Daten müssen natürlich auch sofort in eine für Maschinen lesbare Form gewandelt werden, also habe ich mir nochmal angeschaut wie man Öffnungszeiten am bessten darstellt im Semantic Web. Der Opening Hours Use Case des ESW Wiki gibt hier einige Hinweise:

Es handelt sich offensichtlich um ein Restaurant, also sollte man dies auch dokumentieren, es empfiehlt sich das Chef Moz dining guide RDF Element Set

<Restaurant rdf:ID="DE/NRW/BN/frittebud-0">
   <dc:title>Frittebud</dc:title>
   <Address>Franzstr. 43</Address>
   <Zip>53111</Zip>
   <City>Bonn</City>
   <Country>Germany</Country>
</Restaurant>

Diese Repräsentation ist natürlich nicht kompatibel mit dem vCard Format, aber dazu später mehr… Die nächste sinnvolle Information ist die geographische Position der Frittebud und, wenn wir schon dabei sind auch die Aussage, dass das Bla direkt um die Ecke ist. Beide Aussagen kann man mittels des WGS84 basierten Geo Vocabulars bzw. des GeoOnion Vocabulars treffen:

<Restaurant rdf:ID="DE/NRW/BN/bla-0">
   <dc:title>Das Bla</dc:title>
   <Zip>53111</Zip>
   <City>Bonn</City>
   <Country>Germany</Country>
</Restaurant>
<Restaurant rdf:ID="DE/NRW/BN/frittebud-0">
  <go:within_3_power_3_metres> <!-- 3^3=27 -->
    <rdfs:seeAlso rdf:resource="DE/NRW/BN/bla-0" /> 
  </go:within_3_power_3_metres>
</Restaurant>

TODO: Dokumentation der Öffnungszeiten!

Weitere Informationen findet man auch in der kompletten RDF/XML Datei.

Und jetzt: macht alle mit!! Ein erster sinnvoller Schritt wäre es, wenn sich möglichst viele Menschen in meinem Umfeld auch einen del.icio.us account anlegen und ihre bookmarks dort ablegen. Um del.icio.us möglichst effizient einzusetzen gibt es eine wundevolle Firefox extension… einfach mal installieren und anfangen die bookmarks zu sammeln und möglichst auch zu taggen. Und es gibt natürlich auch eine extension für die Suchfunktion des Firefox.

Eine weitere wichtige Funktion von del.icio.us ist die Möglichkeit andere del.icio.us user auf eine grade von mir hinzugefügte bookmark zu informieren indem ich die URL mit for:<username> tagge, also for:goern. Die so getaggten bookmarks landen dann bei mir in der Inbox, diese kann ich wieder sehr einfach als RSS feed oder mittels Menü der Firefox extension einsehen.

… Aufruf zur Aktion: 1) del.icio.us account anlegen und 2) eure del.icio.us Seite mit for:goern taggen so das sie in meiner Inbox landet!

Was man davon hat? Ich tagge bookmarks von denen ich denke das sie für euch interessant sein könnten so, dass sie in eurer Inbox landen… und dann in eurem feed Aggregator und in eurem Kopf.

Weitere Informationen:

• A Guide To Declarative Living
• On Attestation, Transparency, Microsoft Internal Choices and the Future of Market Research
• On Declarative Living and the Virtual Coffee Table

Eine der Erfahrunge: man sollte seinen Benutzern nicht einen riesigen Datenbereich zur Verfügung stellen, da dies einige Nachteile hat:

• lock times – sollte das eine grosse Volumen in den Status locked kommen, so sind im Wesentlichen alle Daten locked. Sind die Daten in mehrere kleinere Volumes unterteil, so sind weniger grosse Bereiche betroffen.
• availability – Die schreibende Verfügbarkeit der Datenbereiche verringert sich, siehe oben.
• storage management – Es ist einfacher kleine Datenbereiche auf andere Server oder andere Partitionen zu migrieren.

Verbindet man diese Argumente mit der Tatsache, dass ein AFS Verzeichnis nicht durch MacOSX Spotlight indizierbar und durchsuchbar ist, so wird eine wohldurchdachte Verzeichnisstruktur immer wichtiger. Man sollte nicht alle Daten in ein Verzeichniss "abkippen"

Abweichend werden jetzt die Authentisierungs Mechanismen von MacOSX angepasst, sodass der Benutzer direkt beim Anmelden mittels LoginWindow seine Kerberos tickets und AFS tokens bekommt.

Voraussetzung

Es darf kein automatisches Anmelden erfolgen, im Idealfall meldet sich der Benutzer durch die Eingabe seines Benutzernames und Kennworts an, es ist also in den Systemeinstellungen, Benutzer, Anmelde-Opt.[ionen]: “Anmeldefenster zeigt an” auf “Name und Kennwort” zu setzen.

Kerberos Konfiguration

In der Datein /etc/authorization ist die Kerberos5 Authentisierung anzuschalten, dies wird mittels des Mechanismus krb5authnoverify gemacht. In den einzelnen Sektionen muss jeweils ein <string>authinternal</string> durch ein <string>builtin:krb5authnoverify,privileged</string> ersetzt werden. Diese Ersetzung muss an mehreren Stellen geschehen. Nachdem diese Änderungen durchgeführt sind, wird beim nächsten Anmelden auch ein gültiges Kerberos ticket geholt.

aklog Kerberos Plugin

Es ist Nicholas Riley’s aklog Kerberos Plugin zu installieren. Dieses ist dafür verantwortlich, dass nach der erfolgreichen Kerberos Authentisierung auch ein AFS token geholt wird.

Quellen

• How to Enable Mac OS X Kerberos Authentication at Login
• MacOSX with reliable AFS homedirs?
• Nicholas Riley’s aklog plugin

Als erstes wird für den Arbeitsplatzrechner ein neuer principal angelegt, mittels kadmin kann man als Kerberos Administrator durch addprinc -randkey host/workstation.example.com@EXAMPLE.COM den neuen principal anlegen und auch gleich in die /etc/krb5.keytab des Arbeitsplatz exportieren: ktadd -k /etc/krb5.keytab host/workstation.example.com@EXAMPLE.COM. Damit wäre die Kommunikation zwischen Kerberos client und server ermöglicht.

Damit der Benutzer bei der Anmeldung automatisch ein ticket (Kerberos) und ein token (AFS) erhält, ist libpam-krb5 und libpam-openafs-session zu installieren. Die Konfiguration der beiden PAM Module wird in /etc/pam.d/common-{auth|accounts|session} durchgeführt. In den entspr. Dateien sind folgende Zeilen anzuhängen:

auth      sufficient      pam_krb5.so try_first_pass forwardable ignore_root
account   sufficient      pam_krb5.so ignore_root
session   optional        pam_krb5.so ignore_root
session   optional        pam_openafs_session.so ignore_root

Jetzt sollte nach dem Anmelden z.B. via ssh sowohl ein Kerberos ticket (welches durch das beim ssh login angegebene Passwort oder durch ein einzugebendes Password authorisiert wird) und daran folgend für die Sitzung ein AFS ticket ausgestellt.

Diese Anleitung beschreibt kurz die Installation und Konfiguration eines Kerberos Servers und eines OpenAFS Server unter Debian GNU/Linux. In der ganzen Anleitung werden als Beispiele die Domain example.com und das IP-Netz 10.0.0.0/24 verwendet.

Voraussetzungen

Es werden neue Pakete auf dem Debian GNU/Linux System installiert, diese müssen bereitgestellt werden. Desweiteren muss das Netzwerk zu einem Client funktionsfähig sein.

Der Kerberos und OpenAFS Server wird im Beispiel auf dem gleichen System installiert: 10.0.0.11.

DNS

Damit Kerberos und OpenAFS optimal funktionieren sind einige DNS Einträge in der Zone example.com zu machen:

kerberos                IN      A       10.0.0.11
afs                     IN      A       10.0.0.11
_kerberos               IN      TXT     "EXAMPLE.COM"
_kerberos-master._udp   IN      SRV     0 0 88 kerberos
_kerberos-adm._tcp      IN      SRV     0 0 749 kerberos
_kpasswd._udp           IN      SRV     0 0 464 Kerberos
_kerberos._udp          IN      SRV     0 0 88 kerberos
EXAMPLE.COM.            IN      AFSDB   1 afs.example.com.

In allen Dokumentationen wird immer wieder darauf hingewiesen, dass es wichtig ist auf die Gross-/Kleinschreibung zu achten: das Kerberos realm wird immer komplett gross geschrieben und die AFS cell immer komplett klein. Zur vereinfachung geht diese Anleitung davon aus, dass die realm und die cell den gleichen Namen tragen.

Kerberos Installation

Die Installation der Kerberos Software geht recht schnell, apt-get install krb5-kdc krb5-admin-server krb5-clients ; krb5_newrealm. Die Fragen die apt-get muss man beantworten. Die Konfiguration von Kerberos findet vor allem in /etc/krb5.conf statt. Hier ist wichtig, dass default_realm und EXAMPLE.COM in der Sektion <realms> richtig konfiguriert ist.
Als nächstes wird ein principal (also ein Account) für einen Benutzer angelegt, dieser wird administrative Rechte erhalten und später den OpenAFS server verwalten.

kadmin.local -q "addprinc user@EXAMPLE.COM"
kadmin.local -q "addprinc user/admin@EXAMPLE.COM"

user/admin@EXAMPLE.COM muss jetzt in /etc/krb5kdc/kadm5.acl der Eintrag user/admin@EXAMPLE.COM * sorgt dafür das dieser principal vollen Zugriff auf die Kerberos Datenbank erhält.

Mittels kinit user/admin und dem richtigen Passwort sollte man die entsprechenden Ticket vom Kerberos Server bekommen (verifizierbar mittels klist).

OpenAFS Installation

apt-get install openafs-dbserver openafs-krb5 openafs-client installiert die OpenAFS Basis, hierbei ist darauf zu achten, dass openafs-client nicht nacht der Installation des Paketes oder nach dem booten gestartet wird. Die Antworten auf die Fragen von apt-get sollten klar sein. Zur Verifikation der Installation sollte in /etc/openafs/CellServDB der Zellenname mit der IP-Adress 10.0.0.11 enthalten sein. /etc/openafs/ThisCall sollte den Zellennamen enthalten.

OpenAFS Kernel Modules

Die Kernel Module für OpenAFS müssen wahrscheinlich auf dem Server kompiliert werden, am schnellsten geht es mit:

apt-get install module-assistant
module-assistant prepare openafs-modules
module-assistant auto-build openafs-modules

Kerberos: AFS principal anlegen

Für die Administration von OpenAFS wird ein separater principal angelegt. Hierzu wird kadmin.local genutzt und folgende Befehle

addprinc -randkey -e des-cbc-crc:v4 afs
ktadd -k /tmp/afs.keytab -e des-cbc-crc:v4 afs

Dieser principal wird mit asetkey add <kvno> /tmp/afs.keytab afs in die OpenAFS Konfiguration übernommen und im Keyfile abgelegt. kvno ist die kvno die von kadmin.local ausgegeben wurde.

Anlegen der root.cell

Als nächstes muss eine root.cell angelegt werden, hierzu nutzt OpenAFS initial die Partition /vicepa, dies muss eine Partition sein. Der Schnellstart wäre eine mittels loop gemountete Datei:

dd if=/dev/zero of=/var/lib/openafs/vicepa bs=1024k count=64
mke2fs /var/lib/openafs/vicepa
mkdir /vicepa
mount -oloop /var/lib/openafs/vicepa /vicepa

Den Eintrag in /etc/fstab zum automatischen mounten während des booten sollte man nicht vergessen!

Das Skript afs-newcell führt die entsprechende Konfiguration zum anlegen einer neuen Zell durch. kinit user/admin; aklog holt vom Kerberos mit adminitrativen Rechten ausgestattete Tickets und überträgt sie in ein entsprechendes OpenAFS Token. Dies muss mittels tokens sichtbar sein. afs-rootcell legt die root.cell auf dem Server an. Idealerweise bootet man den server jetzt neu – Muss aber nicht.

Einen Benutzer anlegen

Nachdem der Server läuft wird in diesem Abschnitt beschrieben wie ein neuer Benutzer und ein Datenbereich für diesen angelegt.

Benutzer anlegen

Mit kadmin.local fügt man einen neuen principal in die Kerberos Datenbank an: add benutzer, danach wird dieser Benutzer auch im OpenAFS angelegt:
pts createuser benutzer -id 501

Datenbereich

Auf dem OpenAFS Server wird jetzt ein volume für den Benutzer angelegt, ihm werden alle Rechte auf diesen Datenbereich zugesichert und die quota auf 0 (unbegrenzt) gesetzt:

vos create afs /vicepa user.benutzer -maxquota 0
cd /afs/.example.com/user 
fs mkm benutzer user.benutzer 
chown benutzer benutzer 
fs sa benutzer benutzer all  
fs sa benutzer system:authuser l 
vos release user 
fs checkvolumes 

MacOSX Client

Nach der Installation des OpenAFS for MacOS 10 Client ist für diesen die CellServDB und ThisCell in /var/db/openafs/etc anzupassen. In der CellServDB muss mindestens

example.com  # example
10.0.0.11      # afs.example.com

enthalten sein. Nach den # folgt kein Kommentar, sondern genutzte Daten!

zusätzliche Authentisierung

Zusätzlich zur Authentisierung unter MacOS muss man auf dem Client mittels des Terminals auch ein Kerberos Ticket und ein OpenAFS Token vom Server erfragen:

kinit benutzer
aklog
tokens

tokens listet dabei nur die AFS tokens auf.

Jetzt sollte man vollen schreib/lese-Zugriff auf /afs/example.com/daten/benutzer auf dem MacOS client haben.

Quellen

• DFN Cert OpenAFS
• Bayour LDAPv3 Howto
• OpenAFS for MacOS 10
• Mac OS X Kerberos Extras

1. Konzept der leicht migrierbaren Volumes
2. client für MacOSX verfügbar wie auch für GNU/Linux
3. Einsatz in grossen Installationen
4. client side caching

Diesen Punkten steht allerdings ein gewisser administrativer Aufwand entgegen: es ist eine Kerberos5 Umgebung notwendig. Weiterer Schwachpunkt ist momentan auch, dass weder AFS noch NFS oder CIFS Volumen vom MacOSX client in der Spotlight Datenbank indiziert werden können. Weiterhin kommt dazu, dass auf OpenAFS 1.4 volumes keine Dateine grösser als 2GB gespeichert werden können.

weitere Info: Kerberos5 und OpenAFS on GNU/Debian howto

TODO: Backup Konzept für den fileserver.

Also die erste zu klärende Frage: wie stelle ich einen unendlich erweiterbaren, kontinuierlichen und in der Zukunft lesbaren Datenspeicher bereit? Dieser Speicher sollte im Idealfall auch kontinuierlich indizierbar sein.

1. CD/DVD –
2. Festplatten – Firewire, USB, CIFS
3. Bänder –

Ein zweiter wichtiger Aspekt ist die durch die verschiedenen Medien bereitstellbare Grösse des Datenspeichers. Betrachtet man z. B. die Grösse von Fotos, so hat sich deren Grösse von meiner ersten digital Kamera (Canon PowerShot A40, 1600×1200 Pixel um die 620KB als JPEG) zu der momentan aktuellen (Canon EOS 350D, 3456×2304, um die 2000KB als JPEG) um den Fakto 3,225 erhöht, in ca. 2 Jahren…

unfinished

Irving Wladawsky-Berger: IBM’s Linux Initiative:

By the summer of 1999 Linux was picking up steam in the marketplace.

Hmm, would be nice the head how our top tech heads errrm… Vice President of Technical Strategy and Innovation sees the distribution of the success of Linux within IBM is. IBM Global Services is not leading the Linux business, from my point of view Linux and Open-Source is a key service enabler. IBM managed the make it a Hardware play and is putting all it’s Software ontop Linux. Most of the time the hardware brand is in the lead in projects I do, may be a Germany-only observation.

ikvmc commons-logging.jar log4j-1.2.12.jar  -out:log4j.dll -target:library
ikvmc stax-api-1.0.jar wstx-asl-2.8.jar xercesImpl.jar xml-apis.jar \
 resolver.jar -out:xml.dll -target:library
ikvmc antlr-2.7.5.jar arq.jar concurrent.jar icu4j_3_4.jar \
jakarta-oro-2.0.8.jar jena.jar -reference:xml.dll -reference:log4j.dll \
 -out:arq.dll -target:library

A short test if the Jena classes are working was derived from an example of the Jena documentatio and worked out just fine… replacing import with using and omitting the trailing .* gave quick working results.

The hard part starts if it comes to persistent Jena Models. I am using MySQL, so I ikvmced the Java MySQL 3.2alpha driver and used the following code segment as learned from the docs:

  System.Activator.CreateInstance("mysql32alpha", 
     "com.mysql.jdbc.Driver");

  IDBConnection idbcon = new  DBConnection("jdbc:mysql://db-server-2/jena23", 
     "jdbc", "password", "MySQL");

mysql32alpha is the name of the assembly where the class com.mysql.jdbc.Driver is to be found. Compiling the code went well, running it resulted in Exception: Failure to instantiate DB Driver:MySQL java.lang.NullPointerException. So, I droppt the ikvm developers a line… awaiting an answer. Hang on for updates

UPDATE 1: With the devine intervention of “reinstall and configure your tool chain” I did that, currently running:

goern@node-236:~/src/mono/ARQ-1.2$ ikvm -version
CLR version: 1.1.4322.2032 (32 bit)
System: 1.0.5000.0
IKVM.Runtime: 0.22.0.0
IKVM.GNU.Classpath: 0.22.0.0
ikvm: 0.22.0.0
mscorlib: 1.0.5000.0
GNU Classpath version: 0.19
goern@node-236:~/src/mono/ARQ-1.2$ mono --version
Mono JIT compiler version 1.1.13.1, (C) 2002-2005 Novell, Inc and Contributors. www.mono-project.com
        TLS:           __thread
        GC:            Included Boehm (with typed GC)
        SIGSEGV      : normal

Redoing the build process I got the ARQ and MySql .dlls and my binary, compiled just fine and runs fine. JDBC Connection is opned up, Jena Model gets opened and all the content dumped to Console. Having all the good tools in place two point araise:

1. Determining the Language you use is hard! C# just looks like Java to me at the moment:

using System;
using com.hp.hpl.jena.rdf.model;
using com.hp.hpl.jena.db;

public class hodge {
   public static void Main() {
           IDBConnection idbcon = null;
           ModelMaker maker = null;
           Model model = null;

           System.Activator.CreateInstance("mysql32alpha",
            "com.mysql.jdbc.Driver");

           idbcon = new  DBConnection("jdbc:mysql://server/jena23", 
            "user", "pass", "MySQL");
           if (idbcon == null)
                   Console.WriteLine("no IDBConnection");

           try {
                   maker = ModelFactory.createModelRDBMaker(idbcon);
                   model = maker.openModel("pim");
           } catch (Exception e) {
                   Console.WriteLine("Exception: " + e.Message);
           }

           Console.WriteLine(model); // model.write(System.out);
   }
}

2. C# and Mono world seems to be open for Jena.

PS: I have attached a distribution that contains a nant build file for the tasks above and the source code, just configure at top of build.build.

PPS: I have not tested this under some MS Windows.

Very true, droping RSS1.0 support is no option!!

Technorati Tags: B4mad, datenbrei, wordpress

The GUI is pretty simple, you may get or set the current position of a user. The username (and if available) the passowrd may be set in the Preferences dialog. It you get the current position of a user the landmark combobox is updated with the landmarks of the user. That’s it, not much but a start.

next step: find foaf file location of user and display his menow status :)

What about an application that shows hiking or biking tracks on a map, with media annotation like photos/videos or sound per waypoint or per a region. The trancks themself may be edited online using a web application or a standalone client which reads in GPS data from some device. After the user finished editing the track a publish subscribe mechanism (xmpp?) is used to notify the aggregator that a new track is available for a user, maybe only available for the user’s client application or in a server centric storage – depends on user’s decision. If the user uses the standalone (local) client he may configure a access control system based on some web of trust or some friend of friend of friend relation.

If some foreign web user selects a track of a user to be shown it is either stored on the server or only available via the user’s local client (which may be offline hmm.) Note: I want to put in SPARQL/XMPP here!! Maybe only the access control system resists on the user’s local client and is queried by the server based web application, with a default of “access” or “no access”.

This needs work, just blogged to get it writen down…

First step was to put the right data in Apple‘s AddressBook, I added fields for my mother, father and partner and also a field for my birthday. The postal address is in my card anyway. Getting the data out of AddressBook.app wasn’t that easy, but I was able to base my work on some python script by Richard Newman, the result was ab-new.py

The command line ab-new.py -a -n http://b4mad.net/addressbook/people.rdf\# >people.rdf extracts all persons that are part of the FOAF AddressBook group and writes out foaf:Person objects. Redland’s rapper validates them.

Now on to some thinking… cwm http://b4mad.net/2005/12/18/iCalRules.n3 --rdf people.rdf --think will deduct some more relations between persons, given that Father, Partner or Mother relations are given in AddressBook iCallRules.n3 will add some more statements to the output.

This is it, now on to some daemon that act according to the data: birthday reminder!

PS: This has been a Token given to me by my employer to log onto it’s VPN.

The .jar contains the full source but no documentation jet…

TODO: write documentation.

– Thanks to EtnaRosso for the discussion

I will implement the web service using a JBoss Application Server and a variant of J2EE technologies. TODO: figure out the url of the web services…

UPDATE 20051024: First steps have been successful completed: There is a Servlet that returns all trustsRegarding statement for a given foaf:mbox_sha1sum.

captsolos second thing to do is: Use PiggyBank! But I’m a MacOSX and Safari user?! What now?

Next thing on my list is to read the link list of John Breslin regarding ISWC 2005.

What SIOC is?
SIOC (Semantically Interlinked Online Communities) is an ontology for describing discussion forums and posts on topic threads in online community sites. This includes but is not limited to: blogs, bulletin boards, mailing lists, newsgroups, etc.

What Piggy Bank is?
Piggy Bank is an extension to the Firefox Web browser that turns it into a “Semantic Web browser”, letting you make use of existing information on the Web in more useful and flexible ways.

The archive of witw.scpt also contains widw.py and supporting files, just set your username and password in witw.scpt and go…

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX foafx: <http://b4mad.net/ns/foafx/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
SELECT ?sha1sum ?id ?url
WHERE {
     ?account a foafx:PreferredOnlineAccount .
     ?account foaf:accountName ?id . 
     ?account foaf:accountServiceHomepage ?url . 
     ?person foaf:holdsAccount ?account .
     ?person foaf:mbox_sha1sum ?sha1sum .
     ?person foaf:nick ?nick .
     FILTER ( str(?url) = "http://www.jabber.org/network/"^^xsd:string
      && str(?nick) = "[GNU]"^^xsd:string )
}

UPDATE: I have done some more work on extending FOAF, this work can be found at my FOAFX homepage. Feel free to comment on this!

Accessing WITW via HTTP, onlineAccount and depiction information from the Jena Model has been seperated into so called Data Access Objects (DAO) which return Value Objects (VO) containing the actual data.

XMPP communication starts retrieving information and sends back the content of Value Objects to (at the moment) a Multi User Chat (MUC) at #b4mad@conference.jabber.ccc.de

That’s it… source code for this can be found… happy for any feedback! Thanks to ldodds and AndyS for the support. The jabber id of the bot is gnu-0000-000-a@b4mad.info

UPDATE 2005-10-07: I you want to enable your FOAF File to contain the required information for the WITW service add something like

  <foaf:holdsAccount>
    <foaf:OnlineAccount>
     <rdf:type rdf:resource="http://xmlns.com/foaf/0.1/OnlineAccount" />
     <foaf:accountServiceHomepage rdf:resource="http://norman.walsh.name/2005/02/witw/is/"/>
     <foaf:accountName>goern</foaf:accountName>
    </foaf:OnlineAccount>
   </foaf:holdsAccount>

to your foaf:Person .

Right after implementing some Calendar related features I am going to extend it the query the #B4maps data store and retreive some mtb tracks… let’s see what’s happening

The result of my investigation is a cool script for Safari and a Greasemonkey user script which integrates a google map right below any photo in flickr. Using this google map I may add geotags right to the photo displayed. For each tour I did I also add a tag like “phwn-2″ to each photo which was taken on that tour. A little bit of prosa for each tour is done over at #B7erge, each post will have the same tag as the photos…

Next things to do:

• get a rdf feed of flickr photos having a specific tag, incl. geo tags in this rdf feed
• mash up this rdf feed with #B4maps

UPDATE:
task number one is done. I have implemented a web service that delivers a RSS 1.0 feed of the photos taken, tagged and geotagged by me and a friend. try it! first access may take a while as local flickr caches get updated…

related images:

PS: or should I just attach a Nokia 770 to the lower right of my bath’s mirror?!

In the past two weeks I hacked a little Google Maps application called #B4maps which shows some tracks driven lately. Tracks and the Images used to annotate some waypoints are stored in some semi-good XML file…

Today I also finished some XML/XSLT stuff to represent the tracks in an general semantic way using the Locative Packets approach. With some help from #swig I figured out how to preserve the order of the Packets… a bunch of packets is worth nothing without an ordering!

So what we got? An application to show and edit tracks on a map: #B4maps (see its features), a webservice to represent this tracks using RDF, a nice query (which help from Dave Beckett) to figure out the waypoints:


PREFIX geo: <http ://www.w3.org/2003/01/geo/wgs84_pos#>
PREFIX rdf: <http ://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX dc: <http ://purl.org/dc/elements/1.1/>
PREFIX l: <http ://locative.net/2004/packet/loc#>
PREFIX m: <http ://purl.org/dc/dcmitype/>

SELECT ?lat, ?long, ?img
WHERE { ?seq a rdf:Seq .
?seq ?prop ?x ?x geo:lat ?lat . ?x geo:long ?long . OPTIONAL { ?x l:media ?img } }
ORDER by ?prop


And a nice reuse of an existing web service to query rdf data.

My next step will be to move the #B4maps internal storage away from my legacy xml flat file stuff to a RDF backed storage and to experiment with the Redland PHP binding on my webhosters server.