Welches T-Shirt ich absahnen moechte? Dieses.

Ein paar Worte zu CustomGarment:

• Ab 3 Artikeln gibt es keine Versandkosten mehr!
• Die Farbauswahl ist groesser als bei der Konkurrenz!
• Es gibt Qualitaetsshirts (z.B. Fruit of the Loom)!
• Man kann mit PayPal zahlen (ja, das kann man laengst noch nicht ueberall)!
• Es gibt sogar Baby-Kleidung (Laetzchen, Shirts, …)!

@CustomGarment: Danke!

Und wieso sind die toll? Ehm. 3Dsupply nutzt Twitter? … Vielleicht deswegen. 3Dsupply schreibt sogar die Konkurrenz ueber Twitter an und unterhaelt sich freundlich? Ja, vielleicht auch deswegen. Aber hauptsaechlich wohl wegen den ganzen Aktionen, von denen ich meist immer erst dann etwas mitbekomme, wenn die Deadline schon abgelaufen ist. Naja, diesmal war ich schnell, denn die Nachricht, dass jetzt wieder eine Aktion stattfindet, habe ich um 10:15:52 Uhr heute bei Twitter empfangen.

Natuerlich will jetzt auch jeder wissen, welches Shirt ich mir ausgesucht habe. Und hier ist es:

Und nur um sicherzugehen, dass ihr auch auf Dauer wisst, wie cool 3Dsupply ist, verlinke ich sie sogar in meiner Sidebar.

Zu guter Letzt: Wieso dieses Shirt? Weil ich ein Mensch bin, der sich gerne mit gesellschaftskritischen Shirts schmueckt.

Und hier ist es: de.visusnet.eloc_1.0.0.0.jar und sieht ungefaehr so aus:

Installation

1. Herunterladen.
2. In path/to/eclipse/plugins schieben.
3. Eclipse mit dem Argument -clean neustarten, damit der Plugin-Cache neugeladen wird.

Hinweise

• Es funktioniert nur mit Eclipse, nicht mit Eclipse-Derivaten (z.B. Zend Studio), da diese einen eigenen Project-Explorer verwenden, dessen ID, die innerhalb der Equinox Service Registry verwendet wird, nicht publiziert wurde und der Zugriff daher nicht moeglich ist.
• -clean sollte nicht in die eclipse.ini (dauerhaft) geschrieben werden, da Eclipse dann jedesmal laenger zum Starten braucht.
• Der Quellcode befindet sich im Archiv.

Das hat doch ganz bestimmt nichts mit einer Ablenkung von der Kunduz-Affaere zu tun? Und das hat doch auch ganz bestimmt nichts damit zu tun, dass wir bald Waffen brauchen, um uns gegen die anderen EU Laender durchsetzen zu koennen, weil Deutschland auf Kosten aller anderen lebt?

Das geht nicht mehr lange gut. Und der Hochverraeter Karl-Theodor Maria Nikolaus Johann Jacob Philipp Franz Joseph Sylvester Freiherr von und zu Guttenberg gehoert weggesperrt, nebst Westerwelle und dem Rest der wohl schlechtesten Regierung seit ‘49 (verglichen damit war Kohl der reine Segen).

Achja… Worauf ich noch hinaus wollte: Damit solche Verbrecher enttarnt werden koennen, versucht WikiLeaks seit mehreren Jahren erfolgreich eine Plattform zu bieten, auf der Whistleblower anonym Skandale und Verbrechen publizieren lassen koennen ohne politisch, wirtschaftlich, gesellschaftlich oder auf andere Weise verfolgt zu werden. Dieser Plattform haben wir es u.A. zu verdanken, dass wir Details ueber die Foltermethoden von Guantanamo, Zensursperrlisten einiger Laender und den Kunduz-Feldjaeger-Report zu Gesicht bekommen haben.

Leider kostet der Betrieb von WikiLeaks sehr viel Geld, da nur so die Sicherheit der Whistleblower sichergestellt werden kann. Also wenn ihr ein paar Euronen uebrig habt: Spendet!. Wenn ihr euch bei Spenden denkt, dass ihr davon ja nichts habt, dann kauft euch ein WikiLeaks T-Shirt bei getDigital.de, denn 5 EUR pro Shirt gehen an WikiLeaks.

WikiLeaks T-Shirt von getDigital.de

Um nun festzustellen, ob die Person (bzw. eine Applikation, stellvertretend fuer eine Person), die die Anfrage sendet auch wirklich die Person ist, fuer die sie sich ausgibt (Identifikation) und um gleichzeitig festzustellen, ob die Anfrage nicht manipuliert wurde (Authentifikation), gibt es zum einen das freie OAuth Protokoll, was aber relativ kompliziert zu implementieren ist, und zum anderen gibt es aehnliche Ansaetze, wie zum Beispiel das Flickr Auth Protokoll. Beide Protokolle bieten ausserdem die Moeglichkeit externen Programmen (Clients) den Zugriff auf das System (Service Provider) zu authorisieren.

Sofern letzteres nicht noetig ist, reicht jedoch ein abgespecktes Protokoll, das dem Flickr Protokoll sehr nah kommt. Hierbei faellt der Aufwand der sicheren Schluesseluebertragung weg. Und so einfach kann es gehen:

• Der Service Provider generiert einen oeffentlichen Schluessel (API Key) und einen privaten Schluessel (Secret). Ich habe fuer den oeffentlichen Schluessel die SHA1 Pruefsumme verschiedener Variablen und fuer den privaten Schluessel die MD5 Pruefsumme von Variablen, Zufallszahlen und Timestamps genutzt.
• Der Client wird mit beiden Keys ausgestattet. Wie gesagt: Der unwiretapped Schluesselaustausch muss anders sichergestellt werden. Bei meinem System kann der Benutzer die Keys einsehen, wenn er sich zuvor mit seinen Zugangsdaten eingeloggt hat. Das ist auch gaengige Praxis.
• Bei einer Anfragegenerierung werden die Variablen inkl. oeffentlichem Schluessel (die Bezeichner, nicht die Werte!) alphabetisch sortiert und dann mit ihrem Wert konkateniert. Dann werden die Key-Value-Strings konkateniert und der private Schluessel wird vorangestellt. Das Ganze wird jetzt gehasht (e.g. MD5). Nun werden alle Variablen und die zusaetzlich generierte signature-Variable uebertragen.
• Der Service Provider empfaengt alle Variablen, nimmt davon den oeffentlichen Schluessel und sucht in seiner Datenbank nach dem dazu passenden privaten Schluessel. Jetzt kann der Service Provider das selbe Spiel spielen, das der Client schon durchgemacht hat: Variablen sortieren, Key-Value-Strings bauen, konkatenieren, den privaten Schluessel voranstellen und hashen. Der Vergleich der uebermittelten Signatur und der generierten Signatur erlaubt die Authentifizierung des Zugriffs.

Beispiel

Der API Key ist fd40e3589bbb58ec358122c5cd32fcc6481707bb, das Geheimnis ist 162c9d446beb754b804b904772ff87b6. Die Variablen sind (Bezeichner = Wert):

• method = deleteEntries
• rangeFrom = 99
• rangeTo = 101

Die Anfrage wird nun wie folgt Client-seitig generiert:
Sortieren:

apiKey vor method vor rangeFrom vor rangeTo

Konkatenieren:

apiKeyfd40e3589bbb58ec358122c5cd32fcc6481707bbmethoddeleteEntriesrangeFrom99rangeTo101

Private Key voranstellen:

162c9d446beb754b804b904772ff87b6apiKeyfd40e3589bbb58ec358122c5cd32fcc6481707bbmethoddeleteEntriesrangeFrom99rangeTo101

Hashen:

9ad5100448f0549472b0e70722aa06bb

Variablen fuer die Anfrage zusammensetzen:

http://example.com/rest/?apiKey=fd40e3589bbb58ec358122c5cd32fcc6481707bb&method=deleteEntries&rangeFrom=99&rangeTo=101&signature=9ad5100448f0549472b0e70722aa06bb

Das wird nun ausgefuehrt und auf der Service Provider Seite geht es dann so weiter:
API Key auslesen:

fd40e3589bbb58ec358122c5cd32fcc6481707bb

In der Datenbank nach dem passenden privaten Schluessel suchen:

162c9d446beb754b804b904772ff87b6

Sortieren, Konkatenieren, Private Key voranstellen, Hashen (s.o.):

9ad5100448f0549472b0e70722aa06bb

Ergebnisse vergleichen:

9ad5100448f0549472b0e70722aa06bb = 9ad5100448f0549472b0e70722aa06bb

That’s it. Ist sehr einfach zu implementieren und ist dafuer extrem sicher.

Also zur Zeit bastel ich an einem Projekt, das aus einigen Social Networks Daten beziehen und diese auf Public Displays anzeigen soll. Da nur-Text etwas oede ist, habe ich mich also an die Flickr API gesetzt. Eigentlich bietet das Zend Framework dafuer die Klasse Zend_Service_Flickr an, aber leider ist die nicht dafuer ausgelegt Applikationen mit Flickr zu verbinden, sondern lediglich fuer eine direkte Benutzerauthentifizierung via Benutzername/Passwort.

Mein erster Ansatz war also erstmal in die API von Flickr zu schauen, denn die bietet ein OAuth aehnliches Verfahren zur Anwendungsauthentifizierung an. Der Trick war nun Zend_Service_Flickr damit zu verheiraten. Und so geht’s:

Als erstes registriert man eine Anwendung bei Flickr und richtet eine Callback URL ein. In meinem Fall wird damit die callbackAction meines FlickrControllers getriggert. Ich brauchte also einen FlickrController…

class FlickrController extends Zend_Controller_Action
{
    public function indexAction() { }
    public function authenticateAction() { }
    public function callbackAction() { }
}

Die Authentifizierung laeuft so ab:

1. Der Benutzer oeffnet die index-Seite. Dort ist ein Link zur authenticate-Seite, wenn alles nicht schon gelaufen ist.
2. Die authenticate-Action prueft zunaechst, ob die Anwendung bereits mit Flickr verknuepft ist. Wenn ja, dann wird zur index-Seite weitergeleitet. Wenn nein, dann wird eine Authentication Request URL gebaut und dorthin wird weitergeleitet.
3. Auf der Flickr-Seite muss der Benutzer der Anwendung nun den Zugriff erlauben. Ist das geschehen, wird der Benutzer von Flickr direkt zur callback-Seite geleitet. Flickr haengt dabei noch eine Variable mit dem Namen frob an.
4. Die callback-Action sendet daraufhin eine Anfrage an Flickr, die u.A. auch die frob-Variable enthaelt. Ausserdem wird eine Signatur angehangen.
5. Flickr antwortet mit einem Token, der dann gespeichert wird und fuer zukuenftige Calls verwendet wird.

So, bevor ich alle mit Erklaerungen langweile: Jetzt kommt Code!

class SenScreen_Service_Flickr extends Zend_Service_Flickr
{
    protected $_secret;
    protected $_perms;
    protected $_token;
 
    const PATH_AUTH = '/services/auth/';
    const PATH_REST = '/services/rest/';
 
    public function __construct(array $options = null)
    {
        parent::__construct(null);
 
        $this->setOptions($options);
    }
 
    public function setOptions(array $options = null)
    {
        if ($options == null) {
            return;
        }
 
        $validOptions = array('api_key', 'secret', 'perms', 'token');
 
        $this->_compareOptions($options, $validOptions);
 
        if (isset($options['api_key'])) {
            $this->apiKey = $options['api_key'];
        }
        if (isset($options['secret'])) {
            $this->_secret = $options['secret'];
        }
        if (isset($options['perms'])) {
            $this->_perms = $options['perms'];
        } else {
            $this->_perms = 'read';
        }
        if (isset($options['token']) && $options['token'] instanceof SenScreen_Service_Flickr_AuthToken) {
            $this->_token = $options['token'];
        }
    }
 
    public function setApiKey($apiKey)
    {
        $this->apiKey = $apiKey;
        return $this;
    }
 
    public function getApiKey()
    {
        return $this->apiKey;
    }
 
    public function setSecret($secret)
    {
        $this->_secret = $secret;
        return $this;
    }
 
    public function getSecret($secret)
    {
        return $this->_secret;
    }
 
    public function setPerms($perms)
    {
        $this->_perms = $perms;
        return $this;
    }
 
    public function getPerms()
    {
        return $this->_perms;
    }
 
    public function setToken($token)
    {
        $this->_token = $token;
        return $this;
    }
 
    public function getAuthToken()
    {
        return $this->_token;
    }
 
    public function getApiSignature(array $params)
    {
        $plainSignature = $this->_secret;
        ksort($params);
        foreach ($params as $key => $value) {
            $plainSignature .= $key . $value;
        }
        return md5($plainSignature);
    }
 
    private function _getSignedUrl($path, array $params)
    {
        $url = self::URI_BASE . $path . '?';
        $urlParams = array();
        foreach ($params as $key => $value) {
            $urlParams[] = $key . '=' . $value;
        }
        $url .= implode('&', $urlParams);
        $url .= '&api_sig=' . $this->getApiSignature($params);
        return $url;
    }
 
    public function redirect()
    {
        $params = array(
            'api_key' => $this->apiKey,
            'perms'   => $this->_perms
        );
        $redirectUrl = $this->_getSignedUrl(self::PATH_AUTH, $params);
        header('Location: ' . $redirectUrl);
        exit(1);
    }
 
    public function getFrob()
    {
        return $_GET['frob'];
    }
 
    public function requestToken()
    {
        $params = array(
            'method'  => 'flickr.auth.getToken',
            'api_key' => $this->apiKey,
            'frob'      => $this->getFrob(),
            'perms'      => $this->_perms
        );
 
        $httpClient = new Zend_Http_Client($this->_getSignedUrl(self::PATH_REST, $params));
        $httpClient->resetParameters();
        $httpClient->setParameterGet($params);
        $httpClient->setHeaders(array(
            'Accept-encoding' => ''
        ));
        return $this->_parseToken($httpClient->request('GET'));
    }
 
    private function _parseToken(Zend_Http_Response $response)
    {
        $xmlElement = new SimpleXMLElement($response->getBody());
        return new SenScreen_Service_Flickr_AuthToken(
            (string) $xmlElement->auth->token,
            (string) $xmlElement->auth->user['username'],
            (string) $xmlElement->auth->user['fullname']
        );
    }
 
    public function isRestrictedMethod($method)
    {
        $restrictedMethods = array(
            'flickr.photos.getContactsPhotos'
        );
 
        return in_array($method, $restrictedMethods);
    }
 
    private function _execute($method, $defaultOptions, $options)
    {
        $options = $this->_prepareOptions($method, $options, $defaultOptions);
 
        $restClient = $this->getRestClient();
        $restClient->getHttpClient()->resetParameters();
        $response = $restClient->restGet('/services/rest/', $options);
 
        if ($response->isError()) {
            throw new Zend_Service_Exception('An error occurred sending request. Status code: '
                                           . $response->getStatus());
        }
 
        $dom = new DOMDocument();
        $dom->loadXML($response->getBody());
 
        self::_checkErrors($dom);
 
        return new Zend_Service_Flickr_ResultSet($dom, $this);
    }
 
    public function getContactsPhotos(array $options = array())
    {
        static $method = 'flickr.photos.getContactsPhotos';
        static $defaultOptions = array(
            'count'           => 100,
            'just_friends' => 0,
            'single_photo' => 0,
            'include_self' => 0,
            'extras'       => 'license, date_upload, date_taken, owner_name, icon_server, original_format, last_update.'
        );
        return $this->_execute($method, $defaultOptions, $options);
    }
 
    public function getRecent()
    {
        static $method = 'flickr.photos.getRecent';
        static $defaultOptions = array(
            'per_page' => 10,
            'page'     => 1,
            'extras'   => 'license, date_upload, date_taken, owner_name, icon_server, original_format, last_update.'
        );
        return $this->_execute($method, $defaultOptions);
    }
}

Diese Klasse erweitert Zend_Service_Flickr, sodass diese auch mit Authentifizierung umgehen kann. Als naechstes muss der Zend_Http_Client ausgetauscht (bzw. erweitert) werden, sodass auch er mit Signaturen und dem Kram umgehen kann:

class SenScreen_Service_Flickr_Http_Client extends Zend_Http_Client
{
    protected $_flickr;
 
    public function __construct()
    {
        parent::__construct();
 
        $this->setHeaders(array('Accept-Encoding' => ''));
    }
 
    public function setFlickr(SenScreen_Service_Flickr $flickr)
    {
        $this->_flickr = $flickr;
    }
 
    public function request($method = null)
    {
        if ($this->_flickr->isRestrictedMethod($this->paramsGet['method'])) {
            $this->paramsGet['auth_token'] = $this->_flickr->getAuthToken()->getToken();
 
            $this->paramsGet = array_merge($this->paramsGet, array(
                'api_sig' => $this->_flickr->getApiSignature($this->paramsGet)
            ));
        }
        return parent::request($method);
    }
}

Als naechstes Brauchen wir noch eine Klasse, die unser Token aufbewahrt und serialisierbar in der DB ablegbar ist:

class SenScreen_Service_Flickr_AuthToken
{
    private $_token;
    private $_username;
    private $_fullname;
 
    public function __construct($token, $username, $fullname)
    {
        $this->_token    = $token;
        $this->_username = $username;
        $this->_fullname = $fullname;
    }
 
    public function getToken()
    {
        return $this->_token;
    }
 
    public function getUsername()
    {
        return $this->_username;
    }
 
    public function getFullname()
    {
        return $this->_fullname;
    }
}

Und dann koennen wir endlich den Controller fuellen und jetzt kommen auch mal Kommentare in den Code, damit ich nicht mehr so viel quarken muss:

class FlickrController extends Zend_Controller_Action
{
    protected $_config = array(
        'api_key' => 'myapplicationkey',
        'secret'  => 'mysecret'
    );
 
    protected $_flickr;
 
    public function init()
    {
        $this->_flickr = new SenScreen_Service_Flickr();
        $httpClient = new SenScreen_Service_Flickr_Http_Client();
        $httpClient->setFlickr($this->_flickr);
        Zend_Rest_Client::setHttpClient($httpClient);
    }
 
    public function indexAction()
    {
        $userId = Zend_Auth::getInstance()->getIdentity()->id;
        /**
         * Check whether the current user has an access
         * token for Flickr.
         */
        $userSettingModel = new Model_UserSetting();
        if ($userSettingModel->get($userId, 'flickr_token')) {
            /**
             * Get the access token.
             */
            $access_token = unserialize($userSettingModel->getValue());
 
            /**
             * Configure the Flickr instance.
             */
            $this->_flickr->setOptions(array_merge(
                $this->_config,
                array('token' => $access_token)
            ));
 
            $this->view->contactPhotos = $this->_flickr->getContactsPhotos(array('include_self' => 1, 'extras' => ''));
 
            $this->view->showAuthenticationButton = false;
        } else {
            $this->view->showAuthenticationButton = true;
        }
    }
 
    public function authenticateAction()
    {
        $userId = Zend_Auth::getInstance()->getIdentity()->id;
 
        /**
         * Check whether the current user has an access
         * token for Flickr.
         */
        $userSettingModel = new Model_UserSetting();
        if ($userSettingModel->get($userId, 'flickr_token')) {
            /**
             * Get the access token.
             */
            $this->_helper->redirector('index');
        } else {
            /**
             * The user is not authenticated with Flickr.
             * Request Flickr auth frob and redirect to
             * Flickr's authentication page.
             */
            $this->_flickr->setOptions($this->_config);
            $this->_flickr->redirect();
        }
    }
 
    public function callbackAction()
    {
        $userId = Zend_Auth::getInstance()->getIdentity()->id;
 
        $this->_flickr->setOptions($this->_config);
 
        /**
         * Check whether a frob is present for this user.
         */
        if ($this->_flickr->getFrob()) {
            /**
             * A frob is present. Request a token and
             * save it in the database.
             */
            $token = $this->_flickr->requestToken();
            $userSettingModel = new Model_UserSetting();
            $userSettingModel->setUserId($userId)
                             ->setKey('flickr_token')
                             ->setValue(serialize($token))
                             ->save();
 
            /**
             * Everything is done, redirect to the index
             * page.
             */
            $this->_helper->redirector('index', 'flickr');
        } else {
            /**
             * The callback has been called without having
             * a request token. Redirect to the index page.
             */
            $this->_helper->redirector('index', 'flickr');
        }
    }
}

Sollte soweit selbsterklaerend sein. Viel Spass damit.

Update:
Wie ihr vielleicht bemerkt habt, nutze ich das Abstract Data Mapper Design Pattern.

Best Practice

Zur Best Practise hat sich mittlerweile die auch von Zend Studio automatisch generierbare Model-View-Controller-Struktur gemausert. Dazu wird zunaechst eine Verzeichnisstruktur in folgender oder aehnlicher Weise mit einigen Standarddateien genutzt:

application
    configs
        application.ini
    controller
        ErrorController.php
        IndexController.php
    models
    views
        scripts
            error
                error.phtml
            index
                index.phtml
    Bootstrap.php
public
    index.php

Hierbei wird der Webserver so konfiguriert, dass die Domain auf das public-Verzeichnis zeigt. Dadurch wird vor allem die Sicherheit der Applikation erhoeht, da der Zugriff auf die einzelnen Dateien nicht mehr moeglich ist. Die Datei application.ini enthaelt die wichtigsten Informationen, die fuer das Deployment benoetigt werden. Das controller-Verzeichnis enthaelt alle Controller und das models-Verzeichnis enthaelt analog die Modellabstraktionen. Jeder Controller besitzt mindestens eine Action in Form einer Methode, mit der Namenskonvention actionnameAction. Zu jedem Controller gibt es im views-Unterverzeichnis scripts ein Verzeichnis, in dem fuer jede Action eine Datei mit der Namenskonvention actionname.phtml vorliegt. Diese Dateien definieren die an den Client zurueckzusendenen Darstellungsinformationen.

Soweit so gut. Wenn Projekte wachsen wird man irgendwann anfangen das Gesamtsystem in kleine Haeppchen zu zerhacken. Divide and Conquer – Teile und herrsche. Wir (angehenden) Software Systems Engineers nennen sowas auch gerne Modularisierung. Das Zend Framework ist fuer diesen Fall natuerlich auch gewappnet und ermoeglicht es Module zu definieren, wobei jedes Modul eine Verzeichnisstruktur aufweist, die identisch zum application-Verzeichnis ist. Es muessen natuerlich nicht alle Verzeichnisse existieren, aber Minimum ist in den meisten Faellen controller, models und views. Fuer jedes Modul gibt es ein Verzeichnis im Verzeichnis modules und das ganze sieht dann in etwa so aus:

application
    configs
        application.ini
    modules
        default
            controller
                ErrorController.php
                IndexController.php
            models
            views
                scripts
                    error
                        error.phtml
                    index
                        index.phtml
            Bootstrap.php
        foobarmodule
            controller
                ErrorController.php
                IndexController.php
            models
            views
                scripts
                    error
                        error.phtml
                    index
                        index.phtml
            Bootstrap.php
    Bootstrap.php
public
    index.php

Hierbei hat default eine spezielle Rolle, denn es wird von Zend als Standard verwendet, sofern kein anderes Modul explizit angegeben wurde.

Models

Wie oben bereits mehrfach erwaehnt kann jedes Modul Models besitzen. Und hierbei gehen die Geister auseinander. Lange Zeit wurde im Quick Start Tutorial vom Zend Framework darauf gepocht, dass man die Klasse Zend_Db_Table_Abstract erweitert. Diese abstrakte Klasse ermoeglicht es sehr einfach eine Datenbanktabellenabstraktion zu erstellen, indem man einfach von ihr erbt und lediglich den Tabellennamen angibt, auf der operiert werden soll. Da selbst das einigen Menschen wohl zu viel Schreibarbeit war, wurde in frueheren Versionen des Zend Frameworks Inflection benutzt (hier steht ein bisschen dazu und hier ganz unten auch). Das funktioniert wie folgt: Man erweitert Zend_Db_Table (nicht die abstrakte Klasse!) und benennt sie nach einem bestimmten Schema (meist Default_Model_DatenbankTabellenName, je nach Autoloader-Konfiguration mit oder ohne Default_-Prefix). Der Name der Klasse wird dann zum Namen der zugehoerigen Tabelle transformiert (hier waere es datenbank_tabellen_name).

Ich sehe in diesem Ansatz jedoch einen Widerspruch zum Begriff Datenbankabstraktion. Man abstrahiert, um vor allem Komplexitaet zu verringern. Zusaetzlich – und nicht zu vernachlaessigen – abstrahiert man aber auch, um eine Entkopplung von tieferliegender Implementierung zu hoeheren Komponenten zu erreichen. Stellt man nun eine direkte Abhaengigkeit zwischen dem Klassennamen und den Tabellennamen her, so ist man gezwungen jede Namensaenderung der Datenbanktabelle auf alle Verwendungen des Models anzuwenden. Epic fail!

Ich habe bereits gesagt, dass dies so alles mal in der offiziellen Dokumentation vom Zend Framework stand bzw. noch steht. Dem gewiefte Leser mag nun aufgefallen, dass ich im vorherigen Absatz erwaehnt habe, dass jede Verwendung des Models anzupassen waere, wenn Inflection genutzt wird und sich der Tabellenname in der Datenbank aendert. Wenn es jedoch nur eine einzige Verwendung gibt: Who cares? Aber hier geht es weiter: Die Dokumentation geht an vielen Stellen davon aus, dass man direkt auf Instanzen von Zend_Db_Table oder Instanzen von Unterklassen von Zend_Db_Table_Abstract arbeitet. Das hat natuerlich zur Folge, dass lose Kopplung zum Fremdwort wird.

Is-A vs. Has-A

Plump unterscheidet man haeufig (unter anderem) zwischen einer Ist- (Is-A) und einer Hat-Beziehung (Has-A) zwischen Entitaeten. Was hat das nun mit Models zu tun? Die Weiterfuehrung des Gedankens nicht direkt auf Datenbankabstraktionen zu arbeiten hat zur Folge, dass man Datenbankabstraktionen zu Modelabstraktionen abstrahiert. Beispiel: Es gibt eine Benutzerverwaltungssystem, also gibt es eine Tabelle von Benutzern in der Datenbank (users). Dafuer gibt es nun eine Tabellenabstraktion. Diese Klasse heisse nun Default_Model_Users. Wenn wir nun fuer einzelne Datensaetze, also fuer einzelne Benutzer auch eine Abstraktion verwenden, so gibt es die Wahl zwischen den beiden Beziehungsarten. Fuer eine Ist-Beziehung haetten wir in diesem Beispiel eine Klasse Default_Model_User und wir wuerden Instanzen davon erhalten, wenn wir ueber Default_Model_Users (mit Oberklasse Zend_Db_Table_Row_Abstract) bestimmte Datensaetze auswaehlen. Da man nun die Datenbank wegabstrahieren moechte hat man zunaechst Gateways eingefuehrt.

Gateways besitzen eine Instanz von Zend_Db_Table (bzw. eine Instanz einer Unterklasse von Zend_Db_Table_Abstract), auf der Operationen ausgefuehrt werden, um einzelne Datensaetze zu erhalten. Diese Datensaetze sollen nun nicht in der Form einer Unterklasse von Zend_Db_Table_Row (bzw. Zend_Db_Table_Row_Abstract) vorliegen, da wir ja die Datenbank verschleiern moechten. Haeufige Herangehensweise dabei ist es, fuer jedes Feld einer Tabelle ein Feld in einem Objekt zu generieren. Wir sind endlich bei der Hat-Beziehung angelangt.

Mehr Informationen zu den Beziehungsarten in diesem Kontext (viel besser erklaert, als ich es in aller Kuerze machen koennte) findet ihr bei Rob Allen’s Dev Notes: On models in a Zend Framework application.

Service Layer

Hab ich schonmal erwaehnt, dass ich Zwiebeln jeder Art sehr gerne esse? Nicht? Ist auch nicht wichtig. Wichtig ist jedoch, dass wir es in der Software Entwicklung haeufig mit Zwiebeln zu tun haben. Heisst soviel wie: Wir bauen etwas um etwas anderes herum, um u.A. (1) ein gewuenschtes Abstraktionsniveau zu erhalten, (2) lose gekoppelte Systeme schreiben zu koennen und (3) damit wir auf Aenderungen besser reagieren koennen. Es gibt natuerlich auch die Gefahr, dass diese Zwiebelmethode angewendet wird, weil das Wissen ueber die Komponente nicht ausreichend ist oder weil man mit der Komponente nicht zufrieden ist. Dann wird das ganze schnell zu dem Anti-Pattern, das natuerlich auch Onion heisst.

Wenn wir mit Persistenzschichten arbeiten, wollen wir haeufig eine Schnittstelle fuer verschiedene Persistenzsysteme. Wir wollen also zum Beispiel ohne grossen Aufwand ein auf CSV oder XML basiertes Persistenzsystem auf eine Datenbank umaendern. Das ist einfach, wenn wir in unserer Business Logic auf Repraesentationen von den eigentlich betrachteten Objekten arbeiten und nicht direkt auf den Persistenzsystemen. Gateways ermoeglichen das bereits im Ansatz, jedoch besteht noch immer eine direkte Verbindung zwischen den Feldern eine Tabelle in einer Datenbank und den Attributen eines Business Logic Objects.

Und jetzt kommt der Clue: Statt Bottom-Up zunaechst an die Implementierung der Datenbankanbindung zu denken, besinnen wir uns zunaechst daran, dass wir ja auf bestimmten fiktiven oder realen Objekten wie z.B. einem Benutzer arbeiten moechten. Top-Down: Wir definieren uns als erstes die Objekte als Schnittstellen, um zu gewaehrleisen, dass alle Operationen existieren, die wir benoetigen. Da wir Attribute nicht in Schnittstellen definieren koennen, nutzen wir Getter und Setter. Alternativ koennen wir auch mit abstrakten Klassen arbeiten, dann ist es auch moeglich Attribute vorzugeben, es ist jedoch schwieriger sicherzustellen, dass die Attribute auch allen Vorbedingungen, Nachbedingungen und Invarianten des Systems folgen bzw. ueberhaupt genutzt werden. Vorteil von abstrakten Klassen ist jedoch, dass wir Standardimplementierungen vorgeben koennen.

Nachdem wir alle Objekte zumindest strukturell spezifiziert haben, koennen wir nun beginnen sie zu implementieren. Da ich jetzt schon viel zu viel geschrieben habe ohne ein Beispiel zu nennen kommt erstmal eins, bei dem ich mich auf die grundlegenden Dinge beschraenke:

class Default_Model_User
{
    protected $_id;
    protected $_name;
 
    public function getId()
    {
        return $this->_id;
    }
 
    public function setId($id)
    {
        $this->_id = (int) $id;
        return $this;
    }
 
    public function getName()
    {
        return $this->_name;
    }
 
    public function setName($name)
    {
        $this->_name = (string) $name;
        return $this;
    }
}

Weiter geht’s: Jetzt wo wir alle Schnittstellen definiert haben, auf denen wir unabhaengig von der Persistenzschicht arbeiten moechten, faellt auf: Wir haben einen Schicht gebaut, die uns zugleich als Service dienst, daher auch Service Layer genannt.

Komponentendiagramm

Data Mapper Pattern

Top Down: Vom Model zu den Daten, oder: Von Modelspezifikation zur Anbindung an die Persistenzschicht. Es ist nun moeglich auf Repraesentationen von unseren Business Logic Objects zu arbeiten. Allerdings kommen die Daten bisher anscheinend aus dem Nirvana. Die Idee ist nun, einen Mapper zu konstruieren, der die Daten auf das Model projizieren kann und der das Model auf die Daten projizieren kann. Wenn wir nun unser echtes Objekt, mit der Datenentsprechung und einem Mapper als Strukturmuster definieren, dann erhalten wir das Data Mapper Pattern, das dank Matthew Weier O’Phinney nun auch im Quick Start Tutorial von Zend verwendet wird (er hat da laut dieser Quelle Diskussionen mit dem Autor des Tutorials gefuehrt).

Wenn ihr mehr Informationen zum Data Mapper Pattern haben moechtet, schaut auch mal das Webinar Play-Doh: Modelling Your Objects von Matthew Weier O’Phinney an oder lest euch die Slides dazu durch.

Ich bau mal an dem Beispiel weiter und hoffentlich wird dann auch klar, wie der Mapper funktioniert:

class Default_Model_DbTable_User extends Zend_Db_Table_Abstract
{
    protected $_name = 'users';
}
 
class Default_Model_Mapper_User
{
    protected $_dbTable;
 
    public function setDbTable($dbTable)
    {
        if (is_string($dbTable)) {
            $dbTable = new $dbTable();
        }
        if (!$dbTable instanceof Zend_Db_Table_Abstract) {
            throw new Exception('Invalid table data gateway provided');
        }
        $this->_dbTable = $dbTable;
        return $this;
    }
 
    public function getDbTable()
    {
        if (null === $this->_dbTable) {
            $this->setDbTable('Default_Model_DbTable_User');
        }
        return $this->_dbTable;
    }
 
    public function save(Default_Model_User $user)
    {
        $data = array(
            'name' => $user->getName()
        );
 
        if (null === ($id = $user->getId())) {
            $this->getDbTable()->insert($data);
        } else {
            $this->getDbTable()->update($data, array('id = ?' => $id));
        }
    }
 
    public function delete($where)
    {
        return $this->getDbTable()->delete($where);
    }
 
    public function find($id, $user)
    {
        $result = $this->getDbTable()->find($id);
        if (0 == count($result)) {
            return;
        }
        $row = $result->current();
        $user->setId($row->id)
             ->setName($row->name);
    }
 
    public function fetchAll()
    {
        $resultSet = $this->getDbTable()->fetchAll();
        $entries   = array();
        foreach ($resultSet as $row) {
            $entry = new Default_Model_User();
            $entry->setId($row->id)
                  ->setName($row->name)
                  ->setMapper($this);
            $entries[] = $entry;
        }
        return $entries;
    }
 
    public function getAdapter()
    {
        return $this->getDbTable()->getAdapter();
    }
}

Und am User muessen wir auch noch etwas aendern, sodass es wie folgt aussieht:

class Default_Model_User
{
    protected $_id;
    protected $_name;
    protected $_mapper;
 
    public function __construct(array $options = null)
    {
        if (is_array($options)) {
            $this->setOptions($options);
        }
    }
 
    public function __set($name, $value)
    {
        $method = 'set' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Invalid model property');
        }
        $this->$method($value);
    }
 
    public function __get($name)
    {
        $method = 'get' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Invalid model property');
        }
        return $this->$method();
    }
 
    public function setOptions(array $options)
    {
        $methods = get_class_methods($this);
        foreach ($options as $key => $value) {
            $method = 'set' . ucfirst($key);
            if (in_array($method, $methods)) {
                $this->$method($value);
            }
        }
        return $this;
    }
 
    public function setMapper($mapper)
    {
        if (is_string($mapper)) {
            $mapper = new $mapper();
        }
        if (!$mapper instanceof Default_Model_Mapper_Abstract) {
            throw new Exception('Invalid data mapper provided');
        }
        $this->_mapper = $mapper;
        return $this;
    }
 
    public function getMapper()
    {
        if (null === $this->_mapper) {
            $this->setMapper($this->_mapperClass);
        }
        return $this->_mapper;
    }
 
    public function getAdapter()
    {
        return $this->getMapper()->getAdapter();
    }
 
    public function save()
    {
        return $this->getMapper()->save($this);
    }
 
    public function delete($where)
    {
        return $this->getMapper()->delete($where);
    }
 
    public function find($id)
    {
        $this->getMapper()->find($id, $this);
        return $this;
    }
 
    public function fetchAll()
    {
        return $this->getMapper()->fetchAll();
    }
 
    public function getId()
    {
        return $this->_id;
    }
 
    public function setId($id)
    {
        $this->_id = (int) $id;
        return $this;
    }
 
    public function getName()
    {
        return $this->_name;
    }
 
    public function setName($name)
    {
        $this->_name = (string) $name;
        return $this;
    }
}

Endlich! Wir haben das Data Mapper Pattern komplett. Hier mal ein Usage Example:

/* somewhere in your controller */
 
$user = new Default_Model_User();
$users = $user->fetchAll();
 
foreach ($users as $u) {
    if ($u->getName() == 'unknown') {
        $u->setName('unbekannter Nutzername')
          ->save();
    }
}

Pretty easy, huh? Aber stopp! Im Titel steht doch noch irgendwas von Abstract. Was soll denn der Quark? …

Reusability: Abstract Data Mapper Pattern

Wenn wir das Data Mapper Pattern jetzt mehrfach verwenden, stellen wir sehr sehr schnell fest, dass wir unglaublich viel Code doppelt und dreifach haben. Jetzt kommt mein Ansatz: Wir packen alles bekannte in abstrakte Oberklassen und erben davon, setzen die benoetigten Meta-Informationen fuer das Pattern und sind fertig. Ohne grosse Umschweife (just kidding, das war ja jetzt wohl genug Umschweife):

class Default_Model_DbTable_User extends Zend_Db_Table_Abstract
{
    protected $_name = 'users';
}
 
abstract class Default_Model_Abstract
{
    protected $_mapper;
    protected $_mapperClass;
 
    public function __construct(array $options = null)
    {
        if (is_array($options)) {
            $this->setOptions($options);
        }
    }
 
    public function __set($name, $value)
    {
        $method = 'set' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Invalid model property');
        }
        $this->$method($value);
    }
 
    public function __get($name)
    {
        $method = 'get' . $name;
        if (('mapper' == $name) || !method_exists($this, $method)) {
            throw new Exception('Invalid model property');
        }
        return $this->$method();
    }
 
    public function __call($method, array $arguments)
    {
        if (!method_exists($this->_mapper, $method)) {
            throw new Exception('Inaccessible method called');
        }
        return call_user_func_array(array($this->_mapper, $method), $arguments);
    }
 
    public function setOptions(array $options)
    {
        $methods = get_class_methods($this);
        foreach ($options as $key => $value) {
            $method = 'set' . ucfirst($key);
            if (in_array($method, $methods)) {
                $this->$method($value);
            }
        }
        return $this;
    }
 
    public function setMapper($mapper)
    {
        if (is_string($mapper)) {
            $mapper = new $mapper();
        }
        if (!$mapper instanceof Default_Model_Mapper_Abstract) {
            throw new Exception('Invalid data mapper provided');
        }
        $this->_mapper = $mapper;
        return $this;
    }
 
    public function getMapper()
    {
        if (null === $this->_mapper) {
            $this->setMapper($this->_mapperClass);
        }
        return $this->_mapper;
    }
 
    public function getAdapter()
    {
        return $this->getMapper()->getAdapter();
    }
 
    public function save()
    {
        return $this->getMapper()->save($this);
    }
 
    public function delete($where)
    {
        return $this->getMapper()->delete($where);
    }
 
    public function find($id)
    {
        $this->getMapper()->find($id, $this);
        return $this;
    }
 
    public function fetchAll()
    {
        return $this->getMapper()->fetchAll();
    }
}
 
class Default_Model_User extends Default_Model_Abstract
{
    protected $_mapperClass = 'Default_Model_Mapper_User';
 
    protected $_id;
    protected $_name;
 
    public function getId()
    {
        return $this->_id;
    }
 
    public function setId($id)
    {
        $this->_id = (int) $id;
        return $this;
    }
 
    public function getName()
    {
        return $this->_name;
    }
 
    public function setName($name)
    {
        $this->_name = (string) $name;
        return $this;
    }
}
 
abstract class Default_Model_Mapper_Abstract
{
    protected $_dbTable;
    protected $_dbTableClass;
 
    public function setDbTable($dbTable)
    {
        if (is_string($dbTable)) {
            $dbTable = new $dbTable();
        }
        if (!$dbTable instanceof Zend_Db_Table_Abstract) {
            throw new Exception('Invalid table data gateway provided');
        }
        $this->_dbTable = $dbTable;
        return $this;
    }
 
    public function getDbTable()
    {
        if (null === $this->_dbTable) {
            $this->setDbTable($this->_dbTableClass);
        }
        return $this->_dbTable;
    }
 
    public function getAdapter()
    {
        return $this->getDbTable()->getAdapter();
    }
 
    abstract public function save($entry);
 
    abstract public function delete($where);
 
    abstract function find($id, $entry);
 
    abstract public function fetchAll();
}
 
class Default_Model_Mapper_User extends Default_Model_Mapper_Abstract
{
    protected $_dbTableClass = 'Default_Model_DbTable_User';
 
    public function save($user)
    {
        $data = array(
            'name' => $user->getUsername()
        );
 
        if (null === ($id = $user->getId())) {
            return $this->getDbTable()->insert($data);
        } else {
            $this->getDbTable()->update($data, array('id = ?' => $id));
            return $id;
        }
    }
 
    public function delete($where)
    {
        return $this->getDbTable()->delete($where);
    }
 
    function find($id, $user)
    {
        $result = $this->getDbTable()->find($id);
        if (0 == count($result)) {
            return false;
        }
        $row = $result->current();
        $user->setId($row->id)
             ->setName($row->name);
       return true;
    }
 
    public function fetchAll()
    {
        $resultSet = $this->getDbTable()->fetchAll();
        $entries   = array();
        foreach ($resultSet as $row) {
            $entry = new Default_Model_User();
            $entry->setId($row->id)
                  ->setName($row->name)
                  ->setMapper($this);
            $entries[] = $entry;
        }
        return $entries;
    }
}

Das Pattern nenn ich jetzt einfach mal wie oben genannt und schenke es der Welt.

Update

Ich habe mal ein Demo-Projekt fuer Zend Studio zusammengebaut. In etwa so sollte es aussehen (Modulstruktur und kleine Anpassungen inklusive): AbstractDataMapperPatternDemo-1.2.zip.

Wir haben also zunaechst den Tisch abgetastet und einen kleinen Teller vorgefunden, neben dem links, rechts und dahinter das Besteck traditionell angeordnet war. Die Kellnerin hat uns dann erklaert, dass in der Mitte des Tisches eine Schuessel mit Dip und Brot liegt. Ich habe natuerlich als erstes in den Dip gelangt. Spaeter hat sich herausgestellt, dass es Ajoli war. Erschmeckt haben wir es nicht. Wir haben auf eine Cocktailsauce oder Tzatziki getippt.

Nachdem wir das Brot vertilgt hatten, kam auch schon unsere Vorspeise: Eine Suppe, die wir schnell als Kartoffelsuppe identifiziert hatten. Dazu brachte man uns direkt die Getraenke, die man uns dann in die Hand gegeben hat. Neben unserem Tisch befand sich eine Saeule, an der wir die Glaeser positioniert haben, damit wir sie jederzeit wiederfinden und die Gefahr senken, die Glaeser umzuwerfen.

Eine Weile nachdem wir nun auch endlich die Vorspeise geloeffelt hatten, wurde der Tisch dann abgeraeumt und die Hauptspeise wurde gereicht. Und das war der Zeitpunkt, ab dem bei mir die Sauerei anfing. Ich wollte als erstes herausfinden, was ueberhaupt auf meinem Teller liegt, denn man bekommt weder gesagt was es ist, noch wo es ist. Auf meiner Seite links auf dem Teller lagen kleine Knoedel, deren Geschmack auf Gnocchi hinwies. Ueber den ganzen Teller verteilt lag Brokkoli mit irgendeiner Sauce und erst spaeter haben wir einen grossen Klumpen entdeckt, der gegenueber von den Gnocchi lag. Den Klumpen konnten wir nicht identifizieren, aber es koennte alles von Reis bis Kuskus in Frikadellenform, paniert und frittiert, gewesen sein. Da der Geschmack nicht so meins war, habe ich den Klumpen dann heimlich auf den Teller meiner Freundin befoerdert.

Meine Finger und die Serviette, die ich mir in den Kragen gestopft hatte, waren bis dahin schon total eingesaut. Das Essen war aber reichlich und wir haben es beide nicht aufgegessen. Eine gefuehlte halbe Stunde spaeter kam die Kellnerin wieder und hat die Teller abgeraeumt und uns neue Getraenke gebracht. Kurze Zeit spaeter kam dann auch der Nachtisch: Panna cotta mit einer alkoholhaltigen Sauce.

Alles in Allem war das Essen sehr lecker. Es ist aber sehr krass ohne etwas zu sehen zu essen. Die Hauptspeise konnte ich nur mit den Fingern essen, da ich sonst nichts aufs Besteck bekommen haette, die Nachspeise musste ich mit dem Dessertloeffel essen, aber das hat auch nicht wirklich geklappt. Meistens war der Loeffel leer, zu voll oder alles fiel schon zuvor auf den Tisch. Was mich gestoert hat war, dass es sehr laut wurde, als eine etwas groessere Gruppe in die Dunkelkammer gebracht wurde.

Irgendwann beim Dessert rief dann ein Kellner dazu auf, einem 8 Jahre alt gewordenem Maedchen ein Staendchen zu singen. Ich hatte da aber den Mund voll, da ich es endlich geschafft hatte ein riesiges Stueck Panna cotta mit dem Loeffel von der schifffoermigen Schuessel zu meinem Mund zu befoerdern.

Der Preis ist sehr hoch, aber es ist die Erfahrung wert.

Pausch war Professor an der Carnegie Mellon University in Pittsburgh, Pennsylvania. Sein Forschungsgebiet war die Human-Computer Interaction (HCI), vor allem aber Virtual Reality. Er begruendete u.A. das Alice-Project, bei dem eine offensichtlich funktionierende Idee einfach einmal realisiert wurde: Wenn man Menschen dazu bringt Spass zu haben, dann fokussieren sie ihr Interesse darauf und beginnen dabei Dinge zu lernen, die keine offensichtlichen Beziehungen zum eigentlichen Geschehen haben. Das Alice-Project erleichtert es auf spielerische Weise Programmiersprachen zu lernen und wird (Stand 2008) von 10% der Studierenden von IT-Bereichen in den USA genutzt.

Bei Pausch wurde im September 2006 Bauchspeicheldruesenkrebs diagnostiziert. Er kaempfte mit vielen Behandlungen dagegen an, starb aber im Juli 2008. Zehn Monate vor seinem Tod hielt Randy Pausch seine Last Lecture. Eine letzte Vorlesung zu halten ist Brauch an vielen Universitaeten. Als die CMU allerdings zu seiner letzten Vorlesung lud, war bereits klar, dass der Begriff woertlich zu nehmen ist.

Seine offiziell letzte Vorlesung nutzte Pausch, um auf brilliante Art ueber sein Leben zu sprechen. Er stellte die Vorlesung unter einen Titel (Achieving Your Childhood Dreams), der durchdachter kaum sein koennte. Er nannte seine Kindheitstraeume und wie er sie erreicht hat bzw. wieso es gut ist, dass er auch manche Kindheitstraeume nicht erreicht hat. Er erklaerte, wie er anderen Menschen dabei geholfen hat ihre Kindheitstraeume zu erfuellen und was er aus Allem gelernt hat.

Um die Komplexitaet des Inhalts und der Botschaft seiner Last Lecture zu verstehen reicht es nicht aus darueber zu schreiben. Man muss sie sehen. Es lohnt sich und hat mich sehr beeindruckt.

Das Video der letzten Vorlesung:

Beim Menschen bezeichnet Identitaet (v. lat. idem, derselbe, der gleiche) die ihn kennzeichnende und als Individuum von anderen Menschen unterscheidende Eigentuemlichkeit seines Wesens.

Es geht also um Alleinstellungsmerkmale und die kann man zumindest stochastisch evaluieren. Wir ich schon in meinem Paper ueber Reality Mining¹ bereits beschrieben habe, ist Entropie ein dabei besonders interessantes Mass. Es gilt als Einheit fuer Unordnung, aber es ist viel mehr als das. Entropie kann dazu verwendet werden, um Muster zu visualisieren und sie sogar mathematisch vergleichbar zu machen, selbst wenn wir diese Muster nicht in Worte fassen koennen. Eine andere Definition von Entropie nennt es die Generalisierung der Anzahl von moeglichen zufaelligen Unterschieden. Solche Anzahlen werden haeufig auch durch Bits of Entropy dargestellt. Beispiel: Bei einem Zufallsexperiment gibt es zwei moegliche Elementarereignisse. Wir sprechen hierbei dann von einer Entropy von einem Bit, da . Wenn wir eine Entropy von 3 Bits bei einem Zufallsexperiment annehmen, so gibt es Ereignisse, usw.

Nun koennen wir dieses simple mathematische Modell auf die Identitaet anwenden: Es gibt ca. 6,9 Milliarden Menschen (6.900.000.000). Also benoetigt man Bits, um eine Person auf der Welt eindeutig zu identifizieren. Da es bei Computern so immer die Sache mit der 8 ist, koennen wir jetzt mal approximieren: , also weniger als 5 Byte. Zum Vergleich: Auf x86 Maschinen ist die Assembler Anweisung nop (=no operation, hexadezimal 90 oder auch 10010000) 8 Bit lang. 8 Bits wuerden genuegen, um im optimalen Fall 256 Personen unterscheiden zu koennen. Das ist alles wirklich nicht viel.

Treiben wir das ganze noch weiter und werden politischer: Wenn EVILOFYOURCHOICE Daten von Personen speichert, z.B. Land, Most Viewed Website, durchschnittliche Online-Zeit, Browser, Displaygroesse, zuletzt online gekaufter Artikel, zuletzt offline gekaufter Artikel, etc., ohne zu wissen, wer diese Person ist, so ist das voellig egal, denn man kennt natuerlich auch die Personen, die mit dieser Person kontakt hatten (Telefon, E-Mail, SMS) und deren Daten und das alles aggregiert sich zu einem riesigen Netz (ja, jetzt sind wir beim Reality Mining angelangt). Jetzt nehmen wir mal an, dass wir dieses Netz kennen und eine Person aus diesem Neetz geht in einen Laden und nutzt seine Payback-Karte, die mit dem Namen der Person assoziiert ist… dann wissen wir auf einmal noch viel mehr und koennen ohne Muehe andere Personen aus diesem Netz identifizieren.

Leute, die unsere Daten speichern, nutzen solche Techniken (die ich bewusst sehr plump erklaert habe) schon seit Jahren! Sie nutzen das auch aus und senden Werbung oder bevorzugen besondere Zentralpersonen solcher Netze bei Hotlines und bei Kulanz. Wisst ihr ueberhaupt, wer was von euch weiss? Glaubt ihr wirklich, dass eure Privatsphaere geschuetzt ist und ihr nichts zu verbergen habt?

Uebrigens: Wenn die Polizei so etwas macht, dann nennt man das Rasterfahndung, deren Vertraeglichkeit mit dem Grundgesetz doch stark zu bezweifeln ist, da sie die Unschuldsvermutung, die wie folgt rechtlich (GG Art. 11 Abs. 1) definiert ist, aufhebt:

Jeder Mensch, der einer strafbaren Handlung beschuldigt wird, ist solange als unschuldig anzusehen, bis seine Schuld in einem oeffentlichen Verfahren, in dem alle fuer seine Verteidigung noetigen Voraussetzungen gewaehrleistet waren, gemaess dem Gesetz nachgewiesen ist.

Auf Europaeischer ebene verletzt es meiner Ansicht nach auch Art. 6 Abs. 2 der Europaeischen Menschenrechtskonvention:

Jede Person, die einer Straftat angeklagt ist, gilt bis zum gesetzlichen Beweis ihrer Schuld als unschuldig.

Dennoch wird es gemacht! Wollt ihr wirklich den neuen Personalausweis oder bis vor kurzem ePA?

SRSLY?

Mehr Informationen zu Bits & Privacy? Hier.

1. Veroeffentlichung steht noch aus.

• ein Thin Client
• ein paar USB Sticks
• ein paar externe Festplatten
• Linux

Ich habe mir also bei eBay zwei (just in case…) Thin Clients (FSC Futro S300 und HP Thin Client t5510) fuer insgesamt rund 70 EUR gekauft. Da der HP schoener aussieht und als erstes geliefert wurde, habe ich ihn auserkoren zum NAS zu werden.

Der naive Versuch

Da der HP (und auch der FSC) kein CD Laufwerk hat, bleibt nur USB. Das war mir ja klar, also habe ich auch direkt ein paar (2x 4GB, 10x 2GB, weil die so guenstig waren) USB Sticks gekauft und den Ubuntu Installer auf einen der 4GB Sticks geknallt. Da der Installer aber nach 30 Minuten noch immer nicht komplett geladen war, habe ich das mit dem Ubuntu ad acta gelegt.

Kleine Pueppchen

Nun musste also eine Ersatzdistro her, die am Besten auf Debian basiert (Debian ist sexy). Nach ein paar brutalen Stunden, die ich mit Google verbracht hab, war ich von dem Linux Terminal Server Project etwas enttaeuscht. Dann bin ich endlich auf Puppy Linux gestossen. Die knapp 100MB grosse Linux Distribution habe ich dann gepflegt in den Downloadmanager geladen und froehlich 1,5 Stunden(!!!) gewartet. Tolle Mirrors….

Aber endlich war es dann soweit. USB Stick mit Puppy Linux beladen und gib ihm… Haettstewohlgern! Die Fehlermeldung beim Booten haette genauso gut auch EPIC FAIL heissen koennen. Blieb mir nur eins:

dd if=/dev/null of=/dev/sda

Verdammt klein

… soll ja Damn Small Linux sein. Da es auch auf Debian basiert, war es meine naechste Wahl. Saugen,? auf den Stick knallen, booten. Endlich! Innerhalb von Sekunden(!!!) startete Fluxbox. Coole Sache. Das hat mich an meine (spaete, da ich anfaenglich nur mit CLI gearbeitet habe) OpenBSD Zeit erinnert. Da gab es tatsaechlich auch die Moeglichkeit ein Pendrive Linux zu installieren. Also steckte ich einen weiteren USB Stick in den Thin Client, der zum Glueck 4 USB Slots hat, und startete sogleich auch den Pendrive Installer. EPIC FAIL. Abgeschmiert. Zu wenig RAM… Damn Small aber dennoch Damn Memory-leaky. Diesmal habe ich mir dann mit…

shred -n 10 -v /dev/sda

…geholfen. *facepalm*¹

Verzweiflung

Zu dem Zeitpunkt war ich doch schon sehr verzweifelt, da ich schon mehrere Tage (da ich ja immer erst spaet von der Uni komme) daran gehockt habe und noch zu keinem Ergebnis gelangt bin. Unter Windows lief mal wieder mein VMware-Ubuntu im Unity-Mode (sexy, wenn auch von Parallels abgeguckt). Da Ubuntu von Debian abstammt, kommt man auch sehr schnell auf die Idee debootstrap anzuschmeissen und sich sein Debian manuell zusammenzubauen. Gesagt, getan: Nach ein paar Stunden Frickelei (USB+ext3 = keine gute Idee, USB+vfat+Linux = noch schlechtere Idee, USB+Grub = beschissene Idee) habe ich es dann auch geschafft mir ein Linux zu bauen, das ich halbwegs booten konnte. Halbwegs. Kernel Panic. Aus die Maus.

cfdisk -z /dev/sda

… und auf Wiedersehen Partitionstabelle.

RTFM

Manchmal ist es doch so einfach: Die Debian Doku enthaelt einen netten Abschnitt ueber das Vorbereiten von Dateien fuer das Booten von einem USB Stick. Die boot.img.gz-URL hat mir Google sofort geliefert. wget, zcat, mount und eine sowieso in meinem Dateiarchiv existierende und aktuelle Debian ISO draufgeschoben, brachte mich nun endlich zum Erfolg. Der Debian Installer im Textmodus startete problemlos und hat es zugelassen die Installation auf einen anderen USB Stick vorzunehmen. Nur das mit dem Grub ist da so eine Sache… Der Installer dachte “ich USB, ich = sda, sdb = Ziel, (hd2,0) also Bootpartition” (hd0 ist die interne 32MB Flash Card, die so fest verbaut ist, dass man sie nicht austauschen kann). Dementsprechend pflanzte der Installer eine Grub Config (in (hd1,1), also /dev/sda1, wtf?) und die Flash Card habe ich als MBR-Bettchen erkoren. Beim Rebooten (und gleichzeitigem Entfernen des Installer-Sticks) war es natuerlich klar, dass Grub etwas verwirrt war. Interessanterweise hat er die Config gefunden. Nunja, jetzt zwei Zeichen im Bootmenue zu aendern war nicht das Problem und so bootete endlich(!!!) ein jungfraeuliches Debian.

Fileserver

… sind auch so eine Sache fuer sich. Samba (jaja, oldschool – aber soll ja jeder hier im Haus nutzen koennen) hat eine sehr interessante fluide Syntax fuer die Config. Wichtig hierbei war lediglich root preexec zum Mounten der Festplatte (sofern nicht bereits geschehen). Da meine Externe einen netten Stromsparmodus hat und sich selber abschaltet, wenn sie laenger nicht genutzt wurde, konnte ich mir postexec sparen.

Wenn man nun schon einen Fileserver hat, dann kann der ruhig auch hier und da mal dezentrales Filesharing (ohja, man kann auch legale Sachen damit herunterladen!) betreiben. rtorrent hatte ich noch im Hinterkopf, aber das habe ich ganz schnell wieder verworfen. Drecksteil. Das hat mehr Shortcuts als screen und vi zusammen. Oergs. Dann wollte ich noch torrentflux, eine Webschnittstelle zu rtorrent, nutzen… Ein guter Tipp: MySQL und 128MB RAM vertragen sich gar nicht. Letztendlich war MySQL an, dpkg dachte es sei deinstalliert (sogar purged) und das Init-Script mochte es nicht stoppen, weil es dazu ersteinmal initial-gestartet werden muesste, um die Configs zu generieren. Argh! Uebrigens, folgendes hilft:

dpkg --remove --force-remove-reinstreq mysql-server-5.0

Wo war ich? Achja, torrentflux. MySQL + Low Memory = Dreck. Apache ging lustigerweise. Aber ohne torrentflux brauch ich es nicht. Also weg mit dem Mist. Dann blieb ich erstmal bei Transmission. Dank babels Tipp habe ich mir dann doch (das per Default bereits installierte) BitTornado bzw. btdownloadcurses angeschaut. Nach knapp 1,5 Stunden Spielereien mit screen und btdownloadcurses kam dann ein nettes Bash-Script heraus, das Torrents herunterladen, sie archivieren, sharen und gleichzeitig in eine wunderbare Multiwindow-Screen-Umgebung packen kann. Das moechte ich natuerlich niemanden vorenthalten (ja, inkonsistente Schreibweise, aber ich bin atm zu faul):

#!/bin/bash
 
### CONFIG ###
 
DEVICE="/dev/sdb1"
MOUNTPOINT="/media/storage"
TORRENTDIR="/root/torrents"
DOWNLOADDIR="/media/storage/public"
PORTFILE="/root/torrents/.ports"
SCREEN_SESSION_NAME="__DEFAULT"
SCREEN_DATETIME="$(date +%Y%m%d_%H%M%S)"
MAX_UPLOAD_RATE=30
MIN_PORT=53535
MAX_PORT=53559
 
### CODE ###
 
if [ "$(cat /proc/mounts | grep /media/storage | wc -l)" -eq "0" ]; then
    echo -n "Mounting $DEVICE on $MOUNTPOINT..."
    mount -t ntfs-g3 $DEVICE $MOUNTPOINT > /dev/null 2>&1
    if [ "$?" -eq 0 ]; then
        echo " done."
    fi
fi
 
FILE=""
 
if [ -f "$1" ]; then
        echo "Loading $1..."
        FILE="$1"
else
        echo -n "Downloading torrent..."
        rm -f tmp.torrent
        wget -O tmp.torrent $1 > /dev/null 2>&1
        echo " done."
        if [ -f "tmp.torrent" ]; then
                echo -n "Name: "
                read NAME
                FILE="$NAME.torrent"
                mv tmp.torrent "$FILE"
        else
                echo "Torrent file does not exist"
                exit 1
        fi
fi
 
cd $DOWNLOADDIR
 
SCREEN_EXISTS=$(screen -ls | grep ${SCREEN_SESSION_NAME} | wc -l)
 
if [ "$SCREEN_EXISTS" -eq "0" ]; then
        /usr/bin/screen -S "${SCREEN_SESSION_NAME}" /usr/bin/btdownloadcurses --max_upload_rate $MAX_UPLOAD_RATE --minport $MIN_PORT --maxport $MAX_PORT "$TORRENTDIR/$FILE"
else
        COMMAND="screen /usr/bin/btdownloadcurses --max_upload_rate $MAX_UPLOAD_RATE --minport $MIN_PORT --maxport $MAX_PORT \"$TORRENTDIR/$FILE\""
        /usr/bin/screen -r "${SCREEN_SESSION_NAME}" -X eval "$COMMAND"
fi

Last but not least muss ich sagen: Es hat sich (bisher) gelohnt.

1. Ich lese definitiv zu viel Fefe

Nachdem Google sich zunaechst der chinesischen Regierung gebeugt und Inhalte zensiert hat, will Google das nicht laenger mitmachen. Ausgeloest haben das vor allem kuerzlich durchgefuehrte Angriffe auf Google und andere Unternehmen aus dem Bereichen Internet, Finanzen, Technologie, Medien und Chemie. Google hat die U.S. Behoerden und die jeweiligen Firmen ueber die Angriffe informiert und zieht daraus nun Konsequenzen.

Die Angriffe auf Google bezogen sich vor allem auf Diebstahl von Intellectual Property und auf GMail Konten von Menschenrechtsaktivisten. Hier mal ein Auszug aus dem Blogpost von Google:

These attacks and the surveillance they [China] have uncovered–combined with the attempts over the past year to further limit free speech on the web–have led us to conclude that we should review the feasibility of our business operations in China. We have decided we are no longer willing to continue censoring our results on Google.cn, and so over the next few weeks we will be discussing with the Chinese government the basis on which we could operate an unfiltered search engine within the law, if at all. We recognize that this may well mean having to shut down Google.cn, and potentially our offices in China.

Am Ende des Blogposts nimmt Google noch die Mitarbeiter in China in Schutz und schreibt, dass dieser neue Weg, den Google nun einschlaegt, einzig und allein von den Entscheidungstraegern in den USA bestimmt wurde:

We want to make clear that this move was driven by our executives in the United States, without the knowledge or involvement of our employees in China who have worked incredibly hard to make Google.cn the success it is today.

Google hat nun also endlich Menschlichkeit bewiesen und erklaert der chinesischen Zensurpolitik den Krieg.