<script src='jquery-1.3.2.js'></script>
<script>
  var jQuery132 = jQuery.noConflict();
</script>
<script src='jquery-1.4.2.js'></script>
<script>
  var jQuery142 = jQuery.noConflict();
</script>

Man muss allerdings darauf achten, dass die jeweiligen Objekte direkt nach dem Einbinden der jeweiligen jQuery-Version erstellt werden, damit diese sich gegenseitig nicht überschreiben. So wird nämlich die Klasse jQuery mit Version 1.3.2 in Zeile 5 durch die neuere Version ersetzt. Das Objekt jQuery132 muss also bereits davor zugewiesen werden. Danach ist per Zugriff auf entweder jQuery132 oder jQuery142 die jeweilige jQuery-Version genau wie das “$” anzusprechen.

Seit Kurzem haben wir nun ja eine Mailingliste für interessierte Leser und Diskussionen rund um Webdevelopment, Serververwaltung, Netzwerke, Linux oder gar Elektrotechnik eingerichtet – alles was bei einer eierlegenden Wollmilchsau wie das GI Project eben so Gesprächsstoff bietet.
Es bot sich also an, aktuelle Artikel auf eben jener Mailingliste anzukündigen, beispielsweise als Alternative zu RSS. Zunächst entstand daraus eine kurz zusammengehackte Funktion, die bei jedem Veröffentlichen eines Blog-Artikels eine Mail versandt hat. Allerdings stolperte ich dann zufällig über Nils Langner pushWP-Plugin und durchstöberte kurzerhand einmal dessen Vorgehensweise und Funktionalität. Von vielen Dingen habe ich mir dann einfach das Prinzip kopiert, jedoch bin ich schon bald auf einige Unstimmigheiten gestoßen, die mir so nicht gefielen.

Zitat von phphatesme.com:

Das Teil kann bis jetzt eigentlich gar nichts, außer bei einem neuen Artikel einen Tweet abzusetzen.

Die Idee ist, dass ich alle Ideen, die ich so zum pushen des Blogs habe in dieses Plugin packe. Als nächstes wird wohl das “vor einem Jahr” Feature einfließen. Da werde ich euch aber natürlich noch informieren. Unsere Wordpress Erweiterung kann man also als Ergänzung zu den ganzen SEO Plugins sehen.

Im Prinzip veröffentlicht das Plugin einen neuen Artikel einfach über Twitter. Meiner Meinung nach nicht sehr viel anders, als das was ich brauchte. Allerdings hätte ich das Ganze für eMails doch etwas umschreiben müssen und die Art und Weise, wie ein AddOn in pushWP hinzugefügt wurde, war mir nicht ganz ersichtlich. PushWP besteht aus einer Basis-Plugin-Datei, wie sie Wordpress vorschreibt (wp-content/plugins/pushWP/pushWP.php) und einigen zusätzlichen Dateien, wobei beispielsweise in config_page.tpl.php die HTML-Ausgabe des Plugins im AdminCenter steht und ein Unterordner pushWP/AddOn existiert. Das “twitter-AddOn” ist aber nicht vollständig in diesem Verzeichnis gekapselt, sondern besitzt seltsamerweise auch in der Basis-Plugin-Datei einige Zeilen Code. Das war mir dann doch zu verworren, um es anständig erweitern zu können.

Es entstand ein neues Plugin postShare mit folgenden Dateien:

• postShare.php – die Basis-Plugin-Datei
• PostShare.php – enthält die Klasse PostShare
• PostShareAddon.php – enthält die abstrakte Klasse PostShareAddon
• config.tpl.php – enthält den HTML-Code zur Anzeige der Einstellungen im Admin-Panel
• addons/ – enthält AddOns

Die Basis-Datei initialisiert das PostShare-Objekt des momentanen Requests. Zudem werden hier Requests (POST) aus dem AdminCenter an das PostShare-Objekt deligiert, beispielsweise um Einstellungen zu ändern oder AddOns zu aktivieren / deaktivieren. Darüber hinaus wird die Wordpress-Funktion transition_post_status gehooked und dadurch eine Funktion aufgerufen, die dem PostShare-Objekt mitteilt, dass es einen neuen Artikel zum verteilen gibt.
Das PostShare-Objekt verwaltet sozusagen all seine Plugins, bietet Möglichkeiten verschiedene Aktionen zu loggen und erstellt zu Beginn entsprechende benötigte Tabellen ö.ä. . Wie man sieht, ist das Plugin durch eigene Tabellen bereits wesentlich aufwändiger gestaltet als pushWP, allerdings entsprechend einfach zu erweitern.

Wie sieht nun ein solches AddOn aus?
Ganz einfach! Ein AddOn ist eine Datei im Verzeichnis postShare/addons/ und enthält eine gleichnamige Klasse, die von PostShareAddon vererbt wird. Dabei müssen lediglich noch drei Methoden vervollständigt werden: install(), share($data) und getName(). Wird das AddOn aktiviert, wird seine share-Methode immer bei einer Veröffentlichung eines neuen Artikels aufgerufen. Das Array $data enthält bereits fertig aus dem Post extrahierte Daten:

	$data = array(
		'title' => $title,
		'content' => $content,
		'content_parted' => $content_parted,
		'link' => $link,
		'author' => $author
	);

Damit sollte der Großteil aller Informationen, die geshared werden sollen, abgedeckt sein. Das Post-Objekt habe ich bewusst nicht an die AddOns weitergereicht, damit man nicht jedes mal mühsam die einzelnen Informationen extrahieren muss (bis ich darauf kam, wie man $author extrahiert, hat es schon ganz schön gedauert!).
Das PostShareEmail-AddOn sieht dann beispielsweise so aus:

<?php
/**
 * @package postShare
 * @author Julian Stier
 * @version 0.2
 */
class PostShareEmail extends PostShareAddon {
	public function share($data){
		$from = $this->getOption('from');
		$to = $this->getOption('to');
		$title = $this->getOption('title');
		$message = $this->getOption('message');
 
 
		$message = str_replace('%title', $data['title'], $message);
 
		$message = str_replace('%content', $data['content'], $message);
 
		$message = str_replace('%less', $data['content_parted'], $message);
 
		$message = str_replace('%link', $data['link'], $message);
 
		$message = str_replace('%author', $data['author'], $message);
 
 
		$title = str_replace('%title', $data['title'], $title);
 
		$title = str_replace('%content', $data['content'], $title);
 
		$title = str_replace('%less', $data['content_parted'], $title);
 
		$title = str_replace('%link', $data['link'], $title);
 
		$title = str_replace('%author', $data['author'], $title);
 
		$header = 'From: ' . $from . "\r\n\\";
		wp_mail($to, $title, $message, $header);
		$this->log('EmailAddon shared '.$data['title'].' to "'.$to.'".');
	}
 
	public function install(){
		$this->setOption('from', '');
		$this->setOption('title', '');
		$this->setOption('to', '');
		$this->setOption('message', '');
 
		$this->log('EmailAddon options resetted (<em>from</em>, <em>title</em>, <em>to</em>, <em>message</em>).');
	}
 
	public function getName(){
		return 'PostShareEmail';
	}
}
 
?>

An einigen Stellen mit Sicherheit noch verbesserungswürdig, aber im Großen und Ganzen eigentlich sehr übersichtlich. Man muss lediglich beachten, in der Methode install() alle später verwendeten Variablen (die konsistent bleiben sollen) zu initialisieren und möglichst Fehlermeldungen im Plugin selbst zu unterdrücken – über die Log-Methode kann man entsprechende Fehler sicher ins Admin-Interface reichen.

postShare Einstellungen im Admin-Center

Download postShare 0.3

Schon vor ein paar Jahren war ich begeistert von dem AVR-basierten Webserver-Projekt von Ulrich Radig (http://www.ulrichradig.de/), bin jedoch mangels kompatibler Netzwerkkarte und Elektronikkenntinissen leider nie dazu gekommen, einen Nachbau zu wagen. Vor ein paar Wochen lief mir dann durch Zufall ein Bausatz von Pollin in den Browser.. Das AVR-Net-IO-Board, für 20€ als Bausatz verkauft, ist eine reltiv ausgereifte und günstige, einfach aufbaubare Version der in den letzten Jahren immer weiter entwickelten AVR-basierten Netzwerk-Projekte und dank aktiver Community eine perfekte Basis für eigene Gehversuche im Bereich embedded networking.

Hardware

Geliefert werden von Pollin eine Tüte “Vogelfutter”, drei ICs, eine professionell gefertigte zweiseitige Platine, sowie eine relativ ausführliche Aufbauanleitung. Wer ein bisschen Ahnung von Elektronik und schon ab und zu mal was gelötet hat, schlägt sich in dem mehrseitigen Dokument die Bestückungstabelle mit den Bauteilwerten auf und lötet das Board in nicht ganz 30min professionell zusammen. (Wer die Anleitung aufmerksam durchliest wird vielleicht nicht den selben Fehler machen wie ich und beachten, dass die Klemmleisten anreihbar sind! Meine wurden daher leider etwas scheps).
Sehr schön ist die auf der Platine integrierte Spannungsversorgung. ein paar Dioden sorgen dafür, dass das Board sowohl mit Gleich- als auch Wechselspannung betriebn werden kann und bieten gleichzeitig einen Verpolschutz, ein LM7805 sowie ein weiterer Festspannungsregler machen aus Eingangsspannungen zwischen 9V und 24V immer saubere 5V und 3V für die Schaltung. Zum Betrieb solcher Schaltungen setze ich hauptsächlich ein lüfterloses, altes PC-Netzteil ein. Dieses liefert mir stabile 12V bzw 5V. Damit könnte man sich im Prinzip den LM7805 und die Gleichrichterschaltung auf dem Board sparen, da ich aber später im Produktivbetrieb mit dem Board evtl. auf ein billiges AC-Steckernetzteil umsteigen werde habe ich beschlossen an die 2pol-Kontaktleiste die 12V-Schiene des PC-Netzteils anzuklemmen. Dabei wird der 5V-Spannungswandler bedenklich warm. Ich hab’ ihm kurzerhand einen kleinen Kühlkörper aus der Bastelkiste spendiert und ihn so auf moderate 50°C im Dauerbetrieb herunter bekommen.

Die eigentliche Arbeit auf dem Board leistet ein mit einem externen Quarz auf 16MHz getakteter ATMega32, auf den Pollin eine Demo-Firmware geflasht hat, die mit dem mitgelieferten Windows-Programm einfache Pinabfragen und Ausgangsschaltungen ermöglicht. Der ATMega wird dabei unterstützt von einem Microchip ENC28J60 Ethernet-Controller, der die Übertrager der Netzwerkbuchse speist. Der dritte IC auf dem Board ist ein MAX232-Nachbau, der die Pegelwandlung für die integrierte RS232-Schnittstelle erledigt.

Verbindung mit der Außenwelt bekommt das Board über Ethernet, RS232, einen Wannenstecker für einen ISP (Standardbelegung 10-pol) und einigen auf Klemmen, einen weiteren Wannenstecker und einen SUB-D 25 Male – Stecker, auf die die für eigene Schaltungen verfügbaren I/O-Pins des AVR zugänglich sind. Für den SUB-D Stecker hat Pollin übrigens auch eine “Adapterplatine” für wenig € im Programm, mit der sich die Pins eines SUB-D 25 Steckers auf Klemmleisten herausführen lassen. So kann man die Adapter in verschiedene Projekte integrieren und das AVR-NetIO flexibel für verschiedene Anwendungen einsetzen.

Der erste Eindruck der Hardware ist überraschend. Man hält eine kompakte Platine (ca. 7×12 cm) in der Hand, die über zahlreiche Anschlussmöglichkeiten und Erweiterungspotential verfügt und zudem durch die Standardanschlüsse auch recht schnell von einem Projekt ins andere übernommen werden kann. Für den Preis keine schlechte Investition!

Software

Wie ich oben ja bereits erwähnt habe, hat Pollin im Auslieferungszustand auf dem ATMega eine eigene Firmware gespeichert, die über eine voreingestellte IP-Adresse verfügt und sich über den RS232-Port mittels weniger simpler Befehle mit einem PC und einem Terminalprogramm recht schnell konfigurieren lässt.
Mit GETIP lässt man sich die aktuelle IP-Adresse anzeigen, SETIP ändert diese. Um auszutesten, was mit dem Board so alles machbar sein könnte, empfiehlt es sich, einmal einen Blick in die mitgelieferte Software zu werfen. Leider läuft diese ausschließlich auf Windows (Mit dem .NET 2.0 – Framework). Also die virtuelle Maschine mit dem alten XP herausgekramt und die Software installiert (wozu braucht so ein simples Tool eine Installation mit setup.exe und Trallala?). Nach Eingabe der korrekten IP-Adresse des NetIO-Boards, kann man dann im Programmfenster die Zustände der I/O-Pins betrachten und setzen. Die Werte der 4 nach außengeführten ADC-Eingänge werden direkt in Volt (mit vielen Nachkommastellen) angezeigt, über eine (ausdrücklich als BETA gekennzeichnete) Teilfunktion des Programms kann man ein optional an das Board angeschlossenes Display mit Daten beschicken.
Viele werden auf diese weise bereits eine Menge mit dem Board anfangen können. So könnte man z.B. verschiedene 230V-Verbraucher (Beispielsweise einen selten genutzten Fileserver im Keller oder die Weihnachtsbeleuchtung im Garten) über Relais an den Digitalausgängen des AVR via Netzwerk von jedem Windowsrechner aus schalten und sich aktuelle Temperaturwerte oder Versorgugsspannungen anzeigen lassen.

Doch der geübte Bastler will mehr ! … So ist es z.B. durchaus unbefriedigend, dass man das Net-IO-Board nicht ohne viel eigene Software zu entwickeln von Linuxrechnern und eigener Software aus ansteuern kann. auch eine Zugangsbeschränkung wäre sinnvoll, um z.B. die Rolläden im Wochenendhaus via Internet steuern zu können, ohne dass fremde dazwischenfunken.

Hier kommt die Software Ethersex (http://www.ethersex.de) ins Spiel. Die Weiterentwicklung von Etherrape (http://www.lochraster.org/etherrape/) ist eine Open-Source Firmware für den AVR-Mikrocontroller und bietet zahlreiche interessante Features für verschiedene AVR-basierte Webserverprojekte wie z.B. eben auch das AVR-NET-IO. Dazu gehören z.B. IPv6 Unterstützung, ein integrierter Webserver, Unterstützung des DALLAS 1-wire Busses, ein Eindrahtbus (Masse und Datenleitung), an den sich zahlreiche ICs wie Temperatursensoren, digitale I/O-Chips oder RTCs anschließen und über den Bus mit Energie versorgen lassen, außerdem SD-Card Unterstützung, das eigene ECMD – Protokoll, mit dem man via Netzwerk oder RS232 eine Art Terminal auf dem AVR nutzen kann, um u.a. Pinzustände abzufragen und zu setzen oder Sensordaten abzufragen und Implementierung einiger andere Netzwerkdienste.

Wer noch keine Erfahrung hat im Programmieren und Kompilieren von AVR-Software, für den empfiehlt sich der Firmware Builder, mit dem man sich in wenigen, einfachen Schritten ein fertig konfiguriertes und kompiliertes Image für seine Hardwareplattform herunterladen kann.
Wer an umfangreichern Funktionen und eigenen Softwareergänzungen interessiert ist, oder wer eine Hardware-Plattform besitzt, die der Firmware Builder nicht unterstützt, der besorgt sich den aktuellen Quelltext und baut sich sein eigenes Image. Auf einem Linux-System (die wenigen Verirrten, die noch keines nutzen, besorgen sich eine Live-CD oder installieren auf ihrem Windows-System die cygwin-Umgebung mit den entsprechenden Programmen) benötigt man für die AVR-Entwicklung allgemein ein paar Pakete aus den Universe-Quellen und speziell für die Ethersex-Entwicklung noch ein paar kleine Zusätze. Mit der folgenden (Ubuntu-)Paketauswahl sollte man arbeiten können:

krisi@asterix:~$ sudo apt-get install gcc-avr avr-libc avrdude dialog gawk m4 libncurses5-dev

Auf neueren Ubuntu-Systemen (ich verwenden momentan noch 8.10 Intrepid Ibex) oder auf anderen Linux-Distributionen können die Pakete evtl. anders benannt sein. Am besten schaut man sich dazu mal die Kompiliervoraussetzungen im Ethersex-Wiki an.

In der bash wechselt man nun in das (entpackte!) Quelltext-Verzeichnis und startet mit

krisi@asterix:~$ make menuconfig

das (halb-grafische) Konfigurationsscript. Hier kann man dann relativ simpel seine Hardwareplattform einstellen (es gibt natürlich bereits vorgefertigte Einstellungssätze für AVR-NET-IO) und nach Herzenslust Funktionen auswählen. Wenn man den im AVR-NET-IO standardmäßig verbauten ATMega32 verwendet, kann es sein dass man irgendwann ein zu großes Hexfile erhält, das nicht mehr in den Flash des Controllers passt. In diesem Falle empfehle ich, den ATMega32 durch einen ATMega644 mit doppelt so viel Flash und gleicher Pinbelegung zu ersetzen.
Nachdem man sich seine Konfiguration zusammengebastelt hat, kompiliert man Ethersex mit einem einfachen

krisi@asterix:~$ make

im Quelltextordner. Nach kurzer Zeit dürfte das Flashimage fertig und als ethersex.hex im Quelltextverzeichns abgelegt sein.
Mit dem Kommandozeilentool avrdude wird nun das Hexfile in den Controller geschrieben:

krisi@asterix:~$ avrdude -p m32 -c stk200 -U flash:w:ethersex.hex

Wenn soweit alles funktioniert hat, ist der Ethersex-Server jetzt übers Netzwerk erreichbar. Je nach persönlicher Konfiguration kann man das Board nun im lokalen Netzwerk und mittels Port-Forwarding im heimischen Router auch darüber hinaus als energiesparende Schaltzentrale verwenden.

1-wire Temperatursensoren

Durch die Unterstützung der in Bastlerkreisen beliebten 1-wire Sensoren (z.B. DS18S20) kann das AVR-NET-IO beispielsweise auch zur Temperaturüberwachung eingesetzt werden. Die Sensoren kommen in einem TO-92 Gehäuse daher, sind als von außen nicht von üblichen Transistoren zu unterscheiden. Genial ist die Tatsache, dass sich große Mengen der Sensoren parallel an eine Zweidrahtleitung anschließen und dann über das 1-wire-Protokoll komplett softwaregesteuert digital auslesen lassen. Die ICs können sich aus der Datenleitung mit Energie versorgen (=Parasitäre Stromversorgung) und durch die Wandlung der Temperaturwerte in digitale Informationen direkt im Sensor und die digitale Datenübertragung fallen aufwändige analoge Schaltungen zum auswerten von Widerstandswerten (wie bei PT100-Sensoren) gänzlich weg. einziger Schaltungsaufwand auf der Controlelrseite: Ein 4.7k-Widerstand zwischen +5V und der Datenleitung, um die Energieversorgung über den Datenbus sicherzustellen. Über die ECMD-Schnittstelle des AVR-NET-IO kann man sich alle am Bus angeschlossenen Chips anzeigen lassen, einen Messvorgang einleiten und anschließend die Messwerte abfragen:

krisi@asterix:~$ nc 192.168.3.128 2701
1w list
10adc6f90106006c
1054d1f9010600a5
 
1w convert
Ok
 
1w get 1054d1f9010600a5
23.6
 
1w get 10adc6f90106006c
21.9

Wie man sieht liefern die Sensoren das Ergebnis direkt als Dezimalzahl mit einer Nachkommastelle in °C aus. Einfacher kann man’s eigentlich kaum machen.

Mit simpelster Software lässt sich der 1-wire Bus dann übers Netzwerk nutzen. Mit dem Netzwerktool netcat kann man sich auf den ECMD-Server des Boards auf Port 2701 verbinden und so mit dem Gerät kommunzieren.
Das geht natürlich auch automatisiert! Zum Beispiel mit einem kleinen PHP-Sript, das einen TCP-Socket aufbaut, und darauf Befehle schreibt und die Antworten ließt und auswertet:

function request($request) {
    $rs = fsockopen('192.168.3.128', 2701);
    if (!$rs) {
        $response  = "Kann Verbindung nicht aufbauen!";
        die();
    }
    else {
        $response ="";
        $request = "!" . $request . "\r\n";
        fputs($rs, 'auth '.'root'.' '.'geheim'."\r\n");
        fputs($rs, $request);
 
        while (!feof($rs)) {
            $response .= fgets($rs, 128);
        }
        fclose($rs);
    }
    return $response;
}
 
request('1w convert');
 
echo "aktuelle Temperatur: ".request('1w get 1054d1f9010600a5');

Um die Stabilität der Hard- und Software zu testen habe ich einen 24h-”Langzeittest” aufgebaut: Ein Cronjob auf dem gi-project.de – Server hat einmal in der Minute eine Messung auf dem AVR bei mir Zuhause ausgelöst und dabei die Temperaturwerte von drei DS18S20 (Raumtemperatur, Heizkörpertemperatur und Außentemperatur) in eine MySQL-Tabelle geschrieben. Das Experiment ist gelungen, das Board hat meinen “Langzeittest” voll und ganz bestanden. Zwar war die Geschwindigkeit, mit der die Messungen erfolgten und ausgewertet wurden mit Zeiten im zweistelligen Sekundenbereich alles andere als schnell, aber für einfache Mess- und Regelzwecke ist das durchaus ausreichend.

Denkbare Projekte für das NET-IO Board mit Ethersex-Software wären z.B.

• LAN-Steckdosenleiste
• Heizungsüberwachung oder -steuerung (in Arbeit)
• Hausautomation
• Wetterstation
• Roboter
• Webserver für Homepage (in Verbindung mit SD-Karte)
• Beleuchtungssteuerung
• …

Prinzipiell hängt das alles nur von der eigenen Phantasie ab!

Ich hoffe, ich konnte euch mit diesem Artikel ein bisschen für Das Thema Mikrocontroller und embedded systems interessieren und werde bei positiven Rückmeldungen ab und zu gerne weitere Artikel zu dem Gebiet und laufenden Projekten schreiben.

Herzlichen Dank an dieser Stelle auch an das Ethersex-Projekt und all seine Mitwirkenden!

Wer neu einsteigen möchte in das Thema Mikrocontroller und AVR, dem sei das AVR-Tutorial von www.mikrocontroller.net wärmstens empfohlen!
Immer wieder interessantes zum Thema Hardware- und Softwareentwicklung, auch für Einsteiger gut aufbereitet, bietet das Roboternetz-Wiki von roboternetz.de.

Kristian

Wohin mit den Bildern und wie lade ich sie am besten auf den Rechner, ohne gleich irgendwelche Handy-Dateien zu beschädigen (pures Ausschneiden der Bilder aus dem USB-Massenspeicher war mir doch zu simpel)? Software-CD gesucht und gleich geprüft, ob die PC Suite unter Linux läuft, aber wie befürchtet: sie tut es nicht. Gut, man kann Sony Ericsson kein Vorwurf machen, immerhin wäre es sehr aufwändig die gesamte Software nochmal Linux-kompatibel zu schreiben (sie ist ja so schon nicht mal mit allen Windows-Versionen kompatibel).

Also habe ich die Software doch tatsächlich erstmal mit Wine gestartet. Wie man es so kommen sieht, funktioniert das selbstverständlich auch nicht. Dafür ist die Anwendung zu speziell und benötigt vermutlich diverse Windows-Bibliotheken (v.a. grafische), die Wine völlig überladen würden. Ein Virtual OS möchte ich aber weiterhin vermeiden, also wurde erstmal Google zu Rate gezogen und siehe da: In einem englischsprachigen Forum bin ich auf Wammu gestoßen, einer Handy-Manager (Kontakte, Adressen, Termine, Nachrichten, ..).

Nach einigen Blicken in die Screenshot-Sektion, habe ich mir kurzerhand Wammu installiert: sudo aptitude install wammu. Den Ubuntu-Repositories sei dank – so einfach sind Installationen unter Windows bei Weitem nicht.

Wammu

Beim Start von Wammu (user@PC:~$ wammu&), folgt schon die Konfigurationsaufforderung für’s Handy. Der Konfigurations-Manager führt einen bequem Schritt für Schritt durch die einzelnen Punkte. Eine automatische Erkennung ist möglich, aber mit Hilfe von genaueren Angaben kann man die Schritte besser nachvollziehen. Ich wähle also eine “Geführte Konfiguration” aus und gebe danach meinen Verbindungstyp “USB-Kabel” an.

Auswahl des Konfigurationsstil.

Auswahl des Verbindungstyps

Auswahl des Handytyps

Auswahl des Geräteports

Verbindungsaufbau

Adressbuch

Die Anmeldung geht ganz einfach:
Schickt eine E-Mail an

news-subscribe at gi-project.de

Der Rest erklärt sich von selbst.

Kristian

Ich liebe solche Listen ^^

Da Julian mich die letzten Wochen immer mehr damit genervt hat, dass er PHP5.3 auf dem Server haben wollte, das aber mit dem bisher hier verwendeten Debian Etch nicht ohne weiteres möglich war und zudem seit ein paar Tagen keine offiziellen Updates mehr für Etch verfügbar sind, haben wir uns heute Nacht mal dran gemacht den vServer auf Debian Lenny umzusatteln. Leider sitzen wir auf einem shared-kernel System und müssen daher mit dem Vorlieb nehmen was uns unser Hoster zur Verfügung stellt.

Wir haben beschlossen den veralteten Kernel vorerst also zu ignorieren und uns an den Rest der Distribution zu wagen. Und ich muss sagen — Es ging erstaunlich reibungslos über die Bühne! Nachdem wir uns versichert hatten, dass die Backup-Strategie (nächtliche Kopien der wichtigen System- und Datenordner auf meinen Homeserver) in den letzten Tagen lückenlos abgelaufen war, konnte es losgehn:

Zunächst werden in der /etc/apt/sources.list alle “etch”s durch “lenny”s ersetzt … Dann geht der Spaß mit einem ganz normalen Update über die Bühne:

root@gi-project.de:~# apt-get update; apt-get upgrade; apt-get dist-upgrade

Nach gut 20 Minuten und ein paar zickenden und um Aufmerksamkeit ringenden Paketen kam dann das dabei raus:

root@gi-project.de:~# cat /etc/debian_version
5.0.4

Da PHP5.3 leider noch nicht in den (allgemein nicht immer so aktuellen) Debian-Paketquellen steckt, haben wir uns das Paket von dotdeb.org besorgt und als Update eingespielt:

root@gi-project.de:~# echo "deb http://php53.dotdeb.org stable all" >> /etc/apt/sources.list
root@gi-project.de:~# apt-get update; apt-get dist-upgrade

Noch schnell ein reboot, um auch wirklich ganz sicher zu gehen, dass unser kleines Upgrade-Abenteuer sich beim nächsten Server-Ausfall nicht rächt …. und tadaa .. unser frisch gebackenes Debian lenny mit uralt-kernel läuft wie geschmiert. Entgegen allen Erwartungen vertragen sich auch alle Foren, Blogs und Webseiten, die auf gi-project.de laufen prächtig mit PHP5.3 … bisher zumindest

Vielen Dank an all diejenigen, die Debian und das Paketsystem so einfach gemacht haben!

Grüße aus dem Admin-Keller
Kristian

Repositories

Die Idee der Repositories habe ich mir grundsätzlich von flow3.typo3.org abgeschaut. Im Punkt 5.3 werden Repositories erklärt. Dabei geht es um die Repräsentation einer Menge von Objekten bzw. nicht irgendeiner Menge, sondern eigentlich der gesamten Menge. Beispielsweise existiert eine Model-Klasse “User”, die einen Benutzer mit all seinen Eigenschaften repräsentiert. Nun möchte man aber auch neue Benutzer anlegen. Zwar kann man dazu einfach ein neues Objekt anlegen, aber dieses implementiert eigentlich keine Methode, um sich selbst zu speichern – im Falle einer Datenbank. Das ist die Aufgabe eines User-Repositories. Über das User-Repository erhält man eigentlich erst Zugriff auf bestehende User-Objekte. Über die User-Objekte kann man wiederum die Attribute ändern.

Singleton-Einsatz

In meiner Vorgehensweise stellt ein User-Objekt also genau einen User dar. Das ist ein Element einer Menge – mathematisch betrachtet. Darüber steht das User-Repository, das die Menge an sich repräsentiert. Legt man einen neuen Benutzer an, instanziert man ein neues User-Objekt und fügt es der Menge hinzu. Nun ist es aber so, dass ich keinerlei gleichartige Mengen mehr haben möchte in meiner Anwendung. Das heißt, es soll per Definition nur ein User-Repository geben, das im Falle einer Datenbank eben die gesamte Benutzer-Tabelle als Ganzes repräsentiert und Lösch- oder Erstell-Operationen durchführt. Das User-Objekt dagegen führt nur Update- oder Select-Operationen aus.
Das Problem bei einem Repository als gewöhnliche Klasse ist, dass es mehrfach instanzierbar wäre. Daher habe ich zunächst statisch gearbeitet. Dann kam aber ein neues Problem hinzu: Ich möchte möglichst lazy-loading unterstützen, d.h. möglichst erst dann Daten aus der Datenbank lesen, wenn es wirklich nötig (also gefragt) ist. Daher speichere ich die Daten in akkurater Art und Weise in der Klasse, sobald ich sie einmal geladen habe und gebe diese beim nächsten Nachfragen wieder zurück. Dazu habe ich ein SplObjectStorage verwendet, um über User-Objekte iterieren zu können. Lustigerweise kann man dieses Attribut der Klasse aber nicht beim Deklarieren initialisieren. Demnach bräuchte ich einen Konstruktor. Im statischen Kontext kann man dies nur umgehen, indem man eine Initialisierung-Methode schreibt, die bei jedem statischen Methodenaufruf geprüft wird, ob sie schon einmal aufgerufen wurde.
Beispiel:

<?php
class UserRepository {
	private $initialized = FALSE;
	private $users;
 
	static public initialize(){
		if(!self::$initialized){
			self::$users = new SplObjectStorage()
			//do something
		}
	}
 
	static public foo(){
		self::initialize()
		//do something
	}
}
?>

Es muss also bei jeder beliebigen statischen Methode ein Aufruf von initialize() durchgeführt werden, um self::$users zu initialisieren. Ein heftiger Umstand, den ich so nicht hinnehmen wollte. Also fällt der statische Kontext weg, wenn ich schließlich einen Konstruktor haben möchte. Was tun? Einerseits soll das (Repository)Model von überall erreichbar und einmalig sein, andererseits möchte ich non-static context und einen Konstruktor.
Eine minimalst abgeänderte Version eines Singletons macht es möglich:

<?php
 
abstract class Singleton {
	static private $instance = null;
 
	final private function __construct(){}
	final private function __clone(){}
 
	final static public function getInstance(){
		if (null === self::$instance) {
			self::$instance = new self;
			self::$instance->initialize();
		}
		return self::$instance;
	}
 
	private function initialize(){}
}
 
?>

Beim Vererben dieser abstrakten Klasse wird sichergestellt, dass die Child-class ein Singleton ist und über die Möglichkeit verfügt, eine initialisierende Methode zu besitzen (initialize()).
Alle weiteren Methoden sind nun einfach ohne entsprechendes static-Schlüsselwort anzulegen und Zugriff auf die Klasse erhält man von überall mittels

$userRepository = UserRepository::getInstance();
$userRepository->doSomething();

Wer andere (oder bessere!) Ideen hat, der ist eingeladen jederzeit einen Kommentar zu hinterlassen.