Zunächst zwei Klassen, eine davon definieren wir als abstract class:

<?php
    class AnotherRealObject {
    
        public function __call($method, $args) {
            return 'AnotherRealObject->'.$method.'()'; 
        }
    
    }

    abstract class SomeAbstractClassWithConcreteMethods {

        private $anotherObject;
    
        abstract public function abstractMethod();
    
       public function concreteMethodToSetObject($o) {
            $this->anotherObject = $o;
        }

        public function concreteMethod() {
            return $this->anotherObject->aMethod();
        }
    
    }        
?>   

Soweit nichts aufregendes. AnotherRealObject enthält lediglich eine Methode, die bei einem beliebigen Methoden-Aufruf einen String zurückgibt, der angibt welche Methode auf dem Objekt aufgerufen wurde. Mal kurz in einer interaktiven PHP-Shell getestet sieht das ganze so aus:

    php > $stub = new AnotherRealObject();
    php > echo $stub->blubb();
    AnotherRealObject->blubb()
    php > echo $stub->someMethodWithAnArbitraryName();
    AnotherRealObject->someMethodWithAnArbitraryName()  

Die zweite Klasse ist abstract definiert. Das hat für diesen Beitrag keinen besonderen Grund, ich wollte in meinen Tests einfach nur ausschließen, dass das Problem darauf zurückzuführen ist. Die Klasse hat zwei konkrete Methoden. Eine zum Setzen der Abhängigkeit $anotherObject und eine weitere, die auf diesem Objekt eine Methode aufruft und deren Rückgabewert zurückgibt.

Ein phpUnit Test um die abstrakte Klasse zu testen könnte wie folgt aussehen:

    class phpUnitBugTest extends PHPUnit_Framework_TestCase {

        private $uut;
        private $stub;

        public function setUp() {

            $this->uut = $this->getMockForAbstractClass('SomeAbstractClassWithConcreteMethods');

            $this->stub = $this->getMock('AnotherRealObject');
            $this->stub->expects( $this->any() )
                          ->method('aMethod')
                       ->will ( $this->returnValue('StubOfAnotherRealObject->aMethod()') );

            $this->uut->concreteMethodToSetObject($this->stub);
        }


        public function testBug() {
            $this->assertEquals('StubOfAnotherRealObject->aMethod()', $this->uut->concreteMethod());
        }


    }

Mit der durch phpUnit bereitgestellten Methode getMockForAbstractClass() instanzieren wir eine Instanz der abstrakten Klasse (das Testobjekt). Außerdem instanzieren wir ein Stub von AnotherRealObject und legen fest, dass beim Aufruf der Methode aMethod auf diesem Stub der String StubOfAnotherRealObject->aMethod() zurückgegeben wird. Anschließend wird das Stub noch in die Instanz der abstrakten Klasse injected.

Soweit so gut – fehlt der eigentliche Test. Was sollte passieren, wenn auf dem TestObjekt die Methode concreteMethod() aufgerufen wird? Nun ja, die Methode ruft auf dem Feld $anotherObject die Methode aMethod auf. Dem Feld $anotherObject ist unser Stub zugewiesen und dem Stub haben wir gesagt, dass es beim Aufruf von anotherMethod den String StubOfAnotherRealObject->aMethod() zurückgeben soll. Dementsprechend sollte ein aufruf von concreteMethod() genau diesen String zurückliefern.

Leider spielt phpUnit hier nicht mit. Der Test schlägt fehl:

    There was 1 failure:

    1) phpUnitBugTest::testBug
    Failed asserting that two strings are equal.
    --- Expected
    +++ Actual
    @@ @@
    -StubOfAnotherRealObject->aMethod()
    +

    dev/phpUnitBugTest.php:45   

Wie man sieht gibt es gar keinen Rückgabewert. Aber warum ist das so? PhpUnit erstellt nur Method-Stubs für Methoden, die es tatsächlich in der Klasse gibt. Die Methode aMethod gibt es aber nicht wirklich, also erstellt phpUnit auch kein Stub dafür. Es gibt allerdings eine einfache Lösung für das Problem – auch wenn ich sie nicht besonders schön finde: Man sagt phpUnit einfach explizit, dass es einen Stub für die Methode aMethod erstellen soll. Dies geschieht beim erzeugen des Stubs:

    $this->stub = $this->getMock('AnotherRealObject', array('aMethod'));

Mit dieser Änderung läuft der Test durch. Aber Vorsicht: PhpUnit erstellt jetzt nur Stubs, die durch den Parameter festgelegt wurden. D.h. es müssen alle Methoden in diesem Array übergeben werden, für die Subs angelegt werden sollen – egal ob diese in der eigentlichen Klassen existieren oder nicht. Und genau dies ist auch der Grund, warum ich diese Lösung nicht schön finde.

Wenn man mit Mockito ein Objekt mockt, stellt das Framework automatisch stubs für equals() und hashCode() bereit. Deshalb läuft folgender JUnit Test ohne Fehler durch:

@Test
public void testMockito() {

    BigDecimal o1 = mock(BigDecimal.class);
    BigDecimal o2 = mock(BigDecimal.class);

    assertEquals(false, o1.equals(o2));
}

Da Mockito sich also um equals() und hashCode() kümmert kann man ge’mockte Objekte auch einfach mit einer Map benutzen. Dazu zum Beispiel folgender Test:

@Test
public void testMockitoWithHashMap() {

    BigDecimal o1 = mock(BigDecimal.class);
    BigDecimal o2 = mock(BigDecimal.class);

    Map<BigDecimal, String> map = new HashMap<BigDecimal, String>();
    map.put(o1, "erster Mock");

    assertEquals(true, map.containsKey(o1));
    assertEquals(false, map.containsKey(o2));   
}

Läuft. Super. Aber Vorsicht. Der gleiche Test mit einer TreeMap schlägt fehl:

@Test
public void testMockitoWithTreeMap() {

    BigDecimal o1 = mock(BigDecimal.class);
    BigDecimal o2 = mock(BigDecimal.class);

    Map<BigDecimal, String> map = new TreeMap<BigDecimal, String>();
    map.put(o1, "erster Mock");

    assertEquals(true, map.containsKey(o1));
    assertEquals(false, map.containsKey(o2));   
}

So sieht die Fehlermeldung dazu aus:

java.lang.AssertionError: expected:<false> but was:<true>
    [...]
    at [...].testMockitoWithTreeMap(Test.java:92)
    [...]

Erfahrene Java Entwickler wissen natürlich sofort was hier los ist. Für alle anderen dürfte es nach einem Blick in die API von TreeMap klar werden:

Note that the ordering maintained by a sorted map (whether or not an explicit comparator is provided) must be consistent with equals if this sorted map is to correctly implement the Map interface. (See Comparable or Comparator for a precise definition of consistent with equals.) This is so because the Map interface is defined in terms of the equals operation, but a map performs all key comparisons using its compareTo (or compare) method, so two keys that are deemed equal by this method are, from the standpoint of the sorted map, equal. The behavior of a sorted map is well-defined even if its ordering is inconsistent with equals; it just fails to obey the general contract of the Map interface.

Was bedeutet dies für das Mocking mit Mockito? Beim Aufruf von map.containsKey(o2) im letzten Test oben, wird intern irgendwann o2.compareTo(o1) aufgerufen. Im Interface java.lang.Comparable ist die Methode wie folgt definiert:

int compareTo(T o)

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Da Mockito versucht sinnvolle Rückgabewerte zu erzeugen, wird der Aufruf von o2.compareTo(o1) “0″ zurückgeben. 0 bedeutet aber in diesem Fall das o1 und o2 gleich sind. Deshalb liefert der Aufruf von map.containsKey(o2) auch ein true.

Ein kleiner Test dazu:

@Test
public void testMockitoWithTreeMapAndVerifyCompareToCall() {

    BigDecimal o1 = mock(BigDecimal.class);
    BigDecimal o2 = mock(BigDecimal.class);

    Map<BigDecimal, String> map = new TreeMap<BigDecimal, String>();
    map.put(o1, "erster Mock");

    assertEquals(true, map.containsKey(o1));

    verify(o2, times(0)).compareTo(o1);
    map.containsKey(o2);
    verify(o2, times(1)).compareTo(o1);
}

Mit diesem Wissen können wir den Test von weiter oben umschreiben, so dass auch dieser durchläuft:

@Test
public void testMockitoWithTreeMap() {

    BigDecimal o1 = mock(BigDecimal.class);
    BigDecimal o2 = mock(BigDecimal.class);

    when(o2.compareTo(o1)).thenReturn(1); // NEU

    Map<BigDecimal, String> map = new TreeMap<BigDecimal, String>();
    map.put(o1, "erster Mock");

    assertEquals(true, map.containsKey(o1));
    assertEquals(false, map.containsKey(o2));   
} 

Mit nur einer neuen Zeile läuft der Test von vorhin nun korrekt durch. Der Aufruf von o2.compareTo(o1) liefert nun 1, was bedeutet das o2 “größer” ist als o1 und somit nach o1 in der TreeMap eingeordnet wird.

Fazit

Für erfahrene Java Entwickler ist dieser Post mit Sicherheit nichts Neues und so wie ich das Problem hier beschrieben habe, ist der Fehler auch sofort ersichtlich. Wenn man allerdings eine Klasse testet die intern eine TreeMap benutzt, nach außen aber nur das Map Interface sichtbar macht, ist ein solcher Fehler nicht gleich ersichtlich und vielleicht verwirrend.

Neben der Erkenntnis über die Implementierungs-Unterschiede zwischen HashMap und TreeMap hat mir dieses Problem heute mal wieder gezeigt, wie wichtig und sinnvoll Testing ist. Durch das Schreiben dieses einen Tests habe ich ein neues Detail der Java API kennengelernt, mich näher mit Mocktio beschäftigt und gleich zwei Probleme in meinen eigenen Klassen gefunden und beseitigen können. So muss das sein!

Zunächst erstmal alle Tools herunterladen, installieren und konfigurieren. Ich habe mir die SpringSource Tool Suite heruntergeladen. Da ist alles dabei, sowohl Spring Roo, als auch Maven und ein Spring Source Server zum lokalen Testen der Anwendungen. Nach dem Entpacken habe ich alles nach ~/Applications/ kopiert (Achtung, das ist kein Standard-Ordner unter OSX – den habe ich mir für lokale Anwendungen angelegt). Damit man Roo und Maven einfacher benutzen kann, muss das ganze noch in den Pfad aufgenommen werden. Dazu linke ich die Skripte einfach nach /usr/bin:

    sudo ln -s /Users/dennis/Applications/roo-1.1.0/bin/roo.sh /usr/bin/roo
    sudo ln -s /Users/dennis/Applications/maven-2.2.1.RELEASE/bin/mvn /usr/bin/mvn

Achtung, die Pfade könnten bei dir etwas anders sein! Nicht einfach copy/pasten.

Im Anschluss habe ich erstmal die SpringSource Tool Suite (STS) gestartet und im Willkommens-Bildschirm über “Install Extension” den Support für GWT installiert. Danach möchte STS einmal neu gestartet werden und dann kanns auch schon losgehen. Natürlich kann man jetzt einfach die IDE benutzen und das erste Spring Roo Projekt erstellen, aber ich wollte die Roo Konsole testen – über die IDE kann das ja jeder

Also wieder zurück auf die Konsole, ein neues Verzeichnis im Workspace anlegen und die roo-Shell aufrufen:

    cd ~/springroo
    mkdir testApp
    cd testApp
    roo

In der roo-Shell habe ich folgende Befehle ausgeführt:

    project --topLevelPackage io.dennis.roo.amawish
    persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY 
    entity --class ~.domain.Item
    field string --fieldName label
    entity --class ~.domain.Account
    field string --fieldName email
    field set --fieldName items --element ~.domain.Item
    gwt setup
    perform eclipse
    perform clean

Die Befehle kannst du auch als roo-Script herunterladen und ausführen. Das Skript einfach in das testApp Verzeichnis kopieren und dann in der roo-Shell folgenden Befehl ausführen:

    script --file setup.roo

Wenn das Skript durchgelaufen ist (kann einen Moment dauern) kann man das Projekt am schnellsten über Maven starten. Dazu die roo-Shell verlassen (Command: quit) und Maven seine Arbeit machen lassen:

    mvn gwt:run

Jetzt kann man das Projekt im Browser aufrufen. Bei mir sieht das ganze so aus:

Das ging schnell oder? Wenn man jetzt an dem Projekt weiterarbeiten möchte kann man es ganz einfach in STS importieren (“File” > “Import” > “Existing Projects into Workspace”).

Nach einer kurzen Google Recherche musste ich feststellen, dass im Netz auch kein brauchbarer PHP Getter/Setter Generator aufzutreiben ist. Also, nicht lange rumdümpeln, schreibe ich mir halt schnell selbst einen – sowieso die Gelegenheit sich mal die PHP Reflection API anzuschauen. Hier das Ergebnis nach 10 Minuten Arbeit:

#!/usr/bin/php
<?php

    if (!is_file($argv[2])) 
        die('Use this way: '.$argv[0].' <class_name> <path_to_your_class`s_php_file>'."\n");

    require_once($argv[2]);

    $class = new $argv[1]();
    $reflection = new ReflectionClass($argv[1]);
    $fields = $reflection->getProperties(
        ReflectionProperty::IS_PRIVATE
        | ReflectionProperty::IS_PROTECTED
    );

    foreach ($fields AS $f) {

        // getter
        echo 'public function get'.ucfirst($f->getName()).'() {'."\n";
        echo "\t".'return $this->'.$f->getName().';'."\n";
        echo '}'."\n";
        // setter
        echo 'public function set'.ucfirst($f->getName()).'($val) {'."\n";
        echo "\t".'$this->'.$f->getName().' = $val;'."\n";
        echo '}'."\n\n";

    }
    echo 'Generated Getter and Setter for '.count($fields).' fields'."\n\n";
?>   

Das ganze ist ein PHP-Konsolenscript. Als Parameter den Namen eurer Klasse und den Pfad zur PHP Datei mitgeben in der die Klasse deklariert ist. Als Ausgabe erhält man die Getter- und Setter-Methoden für alle Felder, die als private oder protected deklariert sind. Vielleicht hat ja noch jemand anders Verwendung dafür – mir hats eine Menge Zeit gespart

Und weil ich gerade nicht mehr zu erzählen habe, ein kleines Video das ich sehr cool fand (via @seb):

Folgendes Szenario: Ich habe Zuhause einen Mac an dem ich mein iPhone und meinen iPod synchronisiere. Mit anderen Worten: meine komplette Musik befindet sich auf meiner Festplatte Zuhause. Was aber nun wenn ich unterwegs (in der Uni, auf der Arbeit) Musik hören möchte? Bisher habe ich aus diesem Grund meine iTunes Bibliothek regelmäßig über rsync auf mein MacBook kopiert.

Hat aber den Nachteil, dass iPod und iPhone beim Anschließen ans MacBook einen kompletten Sync machen (und das dauert). iTunes auf dem MacBook kennt die Geräte und hält sie für seine eigenen. Da die Bibliothek auf dem MacBook aber in der Regel älter ist als die auf dem Mac Zuhause, wird eben der komplette Sync durchgeführt. Doch dem nicht genug – sobald die Geräte wieder am Mac Zuhause hängen, geht das ganze von vorne los, nur in die andere Richtung

Deshalb die Idee: Wenn ich doch eh mein iPhone + iPod dabei habe, warum nicht die Musik auf dem Gerät über das MacBook hören. Damit dies funktioniert, muss man in iTunes für den iPod die “Manuelle Verwaltung von Musik und Bildern aktivieren”.

Und schon kann man sein iOS Gerät als tragbare Musik-Bibliothek für OSX benutzen.

Auf Client Seite ist unser Netzwerk bunt gemischt. Mit MacOSX, Linux und Windows sind alle nennenswerten Betriebsysteme vertreten. Nun möchten alle natürlich, dass der Router morgens anspringt sobald der eigene Rechner eine Internetverbindung benötigt. Dazu habe ich den Router so konfiguriert, dass er auf Wake-On-Lan Pakete reagiert.

Für MacOSX und Linux habe ich ein kleines Python Script gebastelt, dass ein MagicPaket sendet und so den Router aufweckt (der merkwürdig aussehende String in der letzten Zeile des Skriptes ist die Mac-Adresse des zu weckenden Rechners).

    #!/usr/bin/env python
    import socket
    s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.sendto('\xff'*6+'\x01\x40\x24\x2b\x12\xf7'*16, ('192.168.2.2', 80))

Unter Linux das Skript einfach per Autostart ausführen. Unter MacOSX könnte man das Skript einfach zu den Login-Items hinzufügen, um es bei jedem Anmelden auszuführen.

Allerdings habe ich unter MacOSX einen etwas anderen Usecase. Ich schalte den Rechner praktisch nie aus, sondern versetze ihn nur in den SleepModus. Deshalb muss ich das Skript immer dann ausführen, wenn der Rechner aus dem SleepModus wieder aufwacht. Dazu nutze ich das kleine Tool SleepWatcher. SleepWatcher kann Skripte beim Aufwachen und Schlafengehen von MacOSX ausführen.

Bleibt die Windows-Dose. Auch hier hat der Usecase eine kleine Besonderheit, denn das WOL-Paket muss über WLAN gesendet werden das erst einige Sekunden nach dem Login verfügbar ist. Außerdem muss der Windows-Rechner nach dem Starten des Routers dazu gebracht werden sich vom DHCP Server eine neue IP zu holen.

Zum Senden des MagicPackets habe ich das kleine Tool MC-WOL heruntergeladen. Dabei handelt es sich um ein Kommandozeilenprogramm, dass als Parameter einfach nur die MacAdresse des zu weckenden Rechners bekommt. Das ganze habe ich in eine Batch-Datei verpackt:

ping localhost -n 15 > NULL
c:\mc-wol.exe 01:40:24:2b:12:f7
ping localhost -n 60 > NULL
ipconfig /renew

Die beiden Ping Befehle sind ein kleiner Hack. Windows Batch Dateien kennen keinen “sleep”-Befehl. Ein Ping dauert jedoch genau eine Sekunde. Wenn man nun 15mal ins leere Pingt, hat man effektiv einen Sleep von 15 Sekunden. Die ersten 15s warten sind zum aktivieren der WLAN-Verbindung, dann sendet die Batch das MagicPaket, wartet wiederum 60s (bis der Router hochgefahren ist) und holt sich dannach eine neue IP.

Von dieser Batch Datei einfach noch eine Verknüpfung erstellen und in den Autostart Ordner verschieben. Der Verknüpfung kann man nun noch sagen, dass sie minimiert starten soll und den Benutzer so nicht stört (geht über die Eigenschaften der Verknüpfung).

Ich habe vor einigen Wochen Textmate für mich entdeckt. Das ist wirklich eines der besten Tools für den Mac, ich weiß nicht wie ich die ganze Zeit ohne diesen genialen Editor ausgekommen bin.

Die wohl größte Stärke von Textmate ist seine Anpassbarkeit und die Möglichkeit die Funktionen des Editors über die so genannten Bundles fast beliebig zu erweitern. Zum Beispiel gibt es für Textmate auch ein Blogging-Bundle, mit dem ich gerade diesen Blog-Eintrag schreibe. Das Bundle unterstützt sogar das Hochladen von Bildern direkt über Textmate. Dazu ziehe ich das Bild vom Finder einfach in den Texteditor an die passende Stelle, vergebe einen Titel und den Rest übernimmt Textmate.

Einziger Wermutstropfen: Die Bilder werden von Textmate nur hochgeladen, es werden leider nicht automatisch Thumbnails erstellt. Aber Moment, ich habe doch gerade Textmate dafür gelobt wie flexibel es ist, also einfach selbst eine Lösung dafür basteln.

Ein Weg wäre das Blogging Bundle zu ändern und diese Funkion nachzurüsten, allerdings implementiert Textmate die Metablog API um mit möglichst vielen Blogplattformen kompatibel zu sein und ein Eingriff an dieser Stelle würde damit wohl brechen.

Deshalb habe ich einen anderen Ansatz gewählt. Zunächst habe ich mir im Blogging Bundle von Textmate ein neues Command angelegt (Bundles > Bundle Editor > Show Bundle Editor). Dieses Command wende ich auf eingefügte Bilder an. Es ist ein kleines Ruby-Script, welches den Code für das eingefügte Bild umformatiert und einen Link auf ein PHP Script erzeugt. Diesem PHP Script übergebe ich über einen Parameter die URL des Original Bildes (der komplette Code hierfür wird automatisch durch das Command erzeugt). Das PHP Script schaut nun auf dem Server ob für das Bild schon ein Thumbnail existiert. Falls ja, gibt das Script einfach das Thumbnail aus. Falls nein, erzeugt das Script ein Thumbnail in passender Größe und gibt dieses anschließend aus. D.h. der gesamte Ablauf zum Einfügen des Bildes inklusive Thumbnail sieht folgendermaßen aus:

1. Bild vom Finder in Textmate ziehen
2. Command aufrufen (STRG+Q bei mir)
3. Fertig!

Diese Methode hat auch ein paar Nachteile, aber hier erstmal der Code für das Command (die anderen Einstellungen für das Command bitte aus dem Screenshot entnehmen):

#!/usr/bin/ruby

txt = STDIN.read
md = /\!\[([\w\s]*)\]\((http:[\/\.\w-]*)/.match(txt)
if (md != nil)
    puts "[![#{md[1]}](http://blog.kips-world.de/thumb.php?file=#{md[2]})](#{md[2]})"
end

Achtung: Ich benutze Markdown zum schreiben von Blogposts. Das Script funktioniert in dieser Form nur mit Markdown, nicht mit HTML!

Und hier noch der Quellcode des PHP Scripts auf dem Server:

    $path = dirname(__FILE__).'/wp-content/uploads';

    $f = $_GET['file'];
    $name = basename($f);
    $dir = dirname($f);
    preg_match('/.*\/([a-zA-Z0-9]*)\/([a-zA-Z0-9]*)/', $dir, $s);
    $p = $path.'/'.$s[1].'/'.$s[2];

    preg_match('/(.*)\.([a-zA-Z]{2,3})/', $name, $res);
    
    $thumb = $res[1].'_thumb.'.$res[2];
    $_thumb = $p.'/'.$thumb;

    if (!file_exists($_thumb)) {
        
        copy($p.'/'.$name, $_thumb);
        // this needs imagemagick!
        shell_exec('/usr/bin/convert '.$_thumb.' -thumbnail \'600\' '.$_thumb);     
    }
    header('Last-Modified: '.date('r'));
    header('Content-Type: image/'.strtolower($res[2]));
    readfile($_thumb);

Jetzt zu den Nachteilen. Ich erstelle bei dieser Methode die Thumbnails an WordPress vorbei. D.h. WordPress weiß nichts über diese Thumbnails und man kann sie deshalb auch nicht über WordPress verwalten. Wenn man jedoch etwas mehr Mühe in das Script zur Generierung der Thumbs steckt bin ich mir sicher, dass man das erreichen kann (einfach die entsprechenden Funktionen von WP zur Erstellung von Thumbs hijacken).

Vorteile hat diese Methode aber auch. Sollte man mal das Layout seines Blogs ändern (und deshalb vllt. eine andere Thumbnail-Größe benötigen), muss man nur das Thumbnail Script entsprechen anpassen und alle Thumbnails auf dem Server löschen. Sobald jemand auf die Thumbnails zugreift werden sie dann automatisch neu erstellt – in der richtigen Größe.

Hier noch ein paar nützliche Textmate Ressourcen:

• Developer Cheat Sheet mit den wichtigsten Tastatur-Shortcuts
• Offizielle Textmate Screencasts (sehr Informativ!)

(werde im Laufe der Zeit noch ein paar mehr hinzufügen)

Nachdem ich vor ein paar Tagen ein Update meiner Ubuntu-VM auf 10.04 gemacht hatte konnte ich mich nicht mehr einloggen. Das Problem: Im Login-Screen von GDM funktionierte keine Tastatur mehr. Maus kein Problem, aber ohne Tastatur kann man halt schlecht ein Passwort eingeben.

Das Problem ist ein falscher Eintrag in der Datei /etc/default/console-setup. Nach der Ubuntu 10.04 Installation findet man dort unter anderem folgende Einträge:

XKBMODEL=”SKIP”
XKBLAYOUT=”us”
XKBVARIANT=”U.S. English”
XKBOPTIONS=”"

Die Einträge müssen wie folgt angepasst werden damit die Tastatur unter VMWare(Fusion) wieder läuft:

XKBMODEL=”pc105″
XKBLAYOUT=”us”
XKBVARIANT=”"
XKBOPTIONS=”"

Bleibt die Frage – wie an die Datei herankommen wenn man sich nicht einloggen kann? Zu diesem Problem gibt es zwei Lösungen:

1. Möglichkeit: Beim Booten in Grub den Konsolen-Login auswählen – dort funktioniert die Tastatur einwandfrei.

2. Möglichkeit: Das on-screen Keyboard zum einloggen benutzen. Dazu klickt man im Login-Screen auf das Symbol für die “Universal Access Preferences” (im Standard 10.04 Theme das kleine Männchen mit dem Kreis drumherum) und aktiviert im Folgedialog die Option “Use on-screen keyboard”. Leider kann es nun durch einen anderen Bug passieren, dass das Keyboard zwar kurz zu sehen ist aber sofort wieder verschwindet. In diesem Fall die VM einfach einmal neubooten, dann sollte das Keyboard sichtbar sein.

Nach dem einloggen die oben genannte Datei ändern und neustarten – dann sollte alles wieder wie gewohnt funktionieren. Ich hatte übrigens noch einen weiteren Bug beim Booten. Bei mir erschien der LoginManager für 1-2 Sekunden, dannach wurde der Bildschirm aber wieder schwarz. Hier hilft es beim Booten einfach mal “F2″ zu drücken und damit die Bootkonsole zu aktivieren.

Nach ein bisschen Recherche im Web habe ich mich für das Paket VS Linux L 4.0 von HostEurope entschieden. Eine Alternative wäre noch der vServer Pro X4 von Server4You gewesen. Letzterer ist bei vergleichbarer Leistung deutlich billiger, allerdings verbinde ich mit Server4You nur negative Nachrichten aus deren Anfangszeiten. Mag sein, dass sie mittlerweile dazugelernt haben, das negative Bild hat sich bei mir aber zu sehr eingebrannt. Meine Domains werde ich weiter über den DomainRobot von Hetzner verwalten, da gibt es für mich keine Alternative.

Demnächst steht also ein Umzug aller Dienste und Daten an. Nun habe ich mir überlegt, wenn ich schon alles umziehen und neumachen muss, dann kann ich das auch richtig machen. Deshalb werde ich im gleichen Schritt auch von MySQL auf LDAP als Datenbackend umsteigen. Natürlich ist ein LDAP Server für einen so kleinen Server mit rund 10 Domains und 20 Email-Konten etwas oversized, aber es ist die sauberste Lösung und ausprobieren wollte ich das schon länger mal. Ich habe mir für den neuen Server folgende Struktur überlegt:

Postfix als MTA mit Amavis, Spamassassin und PolicyD als Content Filter – so bleibt das Email-Postfach sauber! Zum Senden/Relayen von Mails ist natürlich eine Authentifizierung erforderlich. Dazu wird Postfix über Cyrus-SASL an den LDAP angebunden. Darüberhinaus benutzt Postfix den LDAP um Domain/Mailbox Lookups zu machen (also sicherzustellen, dass die Emailadressen an die Mails gesendet werden sollen auch auf dem Server existieren).

Dovecot habe ich seit etwas mehr als einem Jahr im produktiven Einsatz und bin damit sehr zufrieden. Dovecot unterstützt eine direkte Anbindung an LDAP (zur Authentifizierung). Sowohl Postfix als auch Dovecot werden für MUAs nur per SSL/TLS erreichbar sein. Als Webmail Applikation bleibe ich bei RoundCube – ich find den Web2.0 Style von RoundCube einfach hübscher als SquirrelMail.

Auch den Apache möchte ich an das LDAP Backend anbinden. Sowohl zur Verwaltung von (Sub-)Domains als auch zur Authentifizierung beim SVN und WebDAV Dienst (ob das überhaupt möglich ist weiß ich aber noch nicht).

Zu guter letzt möchte ich meinen Router hier Zuhause als BackupMX konfigurieren. Falls der vServer einmal ausfällt soll unser heimische Router die Mails entgegennehmen. Dazu muss er natürlich auf die Domaindaten zugreifen können. Deshalb muss auf dem Router ein LDAP-Replica-Server laufen der alle Daten vorhält. Auch müssen hier alle Antispam und Antiviren Maßnahmen installiert sein, denn Spammer benutzen gerne den BackupMX um ihren Müll abzuladen. Inwieweit dies umsetzbar ist muss ich ebenfalls noch ausprobieren.

Ich stelle das ganze Vorhaben hier deshalb so ausführlich vor, weil ich mir vorgenommen habe zu allen Diensten und Konfigurationen hier im Blog Tutorials zu veröffentlichen. Falls ich diesem Vorsatz nachkommem kann ensteht hier nicht nur eine Dokumentation für mich selbst, sondern hoffentlich auch ein nützliches Nachschlagewerk für andere.