Vorweg: Ich glaube dieser Post wird lang…

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.

Manchmal ist es frustrierend, wenn man mit dem Zend Framework arbeitet. Es kann zwar so ziemlich alles, aber die Dokumentation ist nicht besonders zu empfehlen. Darin wird zwar jedes leidige Thema angesprochen, jedoch nie in einem globaleren Kontext. Beispiel: PHP kann mit einer speziellen __autoload Funktion Klassen dynamisch aus Dateien laden, sofern sie benoetigt werden. Darauf basierend arbeiten Autoloader von Zend, die es verschiedene Aufgabenbereiche gibt. Die Dokumentation sagt nun, wie man Autoloader erzeugt. Es fehlen aber einige wichtige Informationen: Wo wird das gemacht, wieso wird das gemacht, welchen Nebeneffekte hat das und wie sieht ein Standard-Use Case aus? Es gibt natuerlich eine Begruendung dafuer, wieso die Dokumentation so anscheinend wichtige Dinge weglaesst: Das Zend Framework ist so konzipiert, dass man es auf beliebige Weise anwenden kann: Ob es als Model-View-Controller Framework oder fuer noch komplexeren Spaghetticode genutzt wird ist so ziemlich egal und diese Flexibilitaet ist durchaus erwuenscht. Best Practice sieht aber anders aus.

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.

Wenn man ueber etwas nachdenkt, dann ist es schwierig solange man sich mittendrin befindet. Wenn man jedoch am Ende steht, scheint es fuer Menschen wesentlich einfacher zu sein Dinge zu reflektieren. Anscheinend laesst sich das auch auf das Leben anwenden. Den Beweis fuer diese These hat Prof. Randy Pausch (* 23. Oktober 1960; † 25. Juli 2008) erbracht.

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:

Identitaet – was ist das eigentlich? Irrelevanzia definiert die Identitaet wie folgt:

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. [↩]

Wie ich waehrend des 26C3 festgestellt habe, mag ich Netzwerk Storages. Ich habe also bei eBay herumgeschaut und musste wiederum feststellen, dass ich mir eine richtige Kiste nicht leisten kann. Also habe ich mich prompt dazu entschieden, mir ein NAS zu improvisieren. Die Zutaten:

• 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 [↩]

Normalerweise twitter ich solche Sachen oder ich teile sie auf Facebook. Aber das Folgende ist es einfach wert gebloggt zu werden:

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.

Dass Apple der Teufel ist, ist doch sicher mittlerweile jedem klar. Aber hier gibt es noch ein schoenes Video dazu.

via Elektrischer Reporter – Digitale Entmündigung: Was Dir gehört, gehört Dir nicht.

Meine Berichte werden immer kuerzer…

• … und die Anzahl der Teilnehmer wurde wieder geringer.
• Ein GBit Switch macht doch schon einiges mehr als ein 100MBit Switch.
• Ein Beamer, ein kleiner Rechner, Maus und Tastatur (+CCC VPN) reichten heute vollkommen, um die Streams zu sehen. Der Rest blieb im Buero.
• Ich will jetzt einen NAS.

Gesamt laesst sich wohl folgendes sagen:

• Wenn man sich auf Andere verlaesst, dann ist man verlassen.
• In Essen und Umgebung ist die Anzahl der Hacker (abzgl. derer, die nach Berlin gefahren sind) sehr gering.
• Die Vortraege waren genial.
• Das Streaming verlief im Schnitt relativ gut.
• Wir waren fuer hunderte Personen vorbereitet und hatten zu Beginn enormen technischen Overhead.
• Ich mache so eine Aktion nicht mehr mit.

Wie gehabt:

• Wir haben puenktlich begonnen, das SOAHarbor-Team war bereits da und nicht sehr erfreut… Als Entschaedigung gab es eine Kaffee-Flat.
• Wir haben ein zweites NAS aufgestellt und beide mit externen Festplatten verstaerkt.
• Die Teilnehmeranzahl ist erneut gesunken.
• Auf Grund mangelnder Nachfrage fand kein Hackcontest mehr statt.
• Es wurde aus ge-hack-ten Zwiebeln und Hack-fleisch eine leckere Festplatte gehackt.
• Die VPN funktionierte problemlos, Streamingausfaelle blieben die Ausnahme.
• Mate (und somit Tschunk) ist leer – aber Bier ist noch da.
• Der Jahresrueckblick war genial.
• Wir haben beschlossen, dass wir naechstes Jahr nach Berlin fahren.
• Beim Abbauen haben wir vergessen dem hauptsaechlich genutzten NAS eine IP Adresse fest zuzuweisen, sodass wir ihn woanders hinstellen konnten… Ein rumfliegender Router hat das Problem geloest.
• Morgen gibt es nur einen kleinen Rechner, einen Beamer und Lautsprecher.
• Wir brauchen dringend mehr Schlaf.

Gerade startet Hacker Jeopardy, also wird es wohl Zeit ueber den heutigen Tag zu schreiben. Ich versuche es mal wie gestern:

• Vor der Eroeffnung waren wir zu Zweit. Das blieb auch erstmal so.
• Wir waren mehrere Stunden mit einem anderen Hacker da.
• Wir haben uns letztendlich entschlossen unsere 1000m² aufzugeben und zu einer ueberschaubareren Location zu wechseln. Waehrend wir das vollzogen haben, hat sich die Anzahl der Personen erst quadriert und dann noch einmal fast verdoppelt.
• Waehrend wir umgezogen sind, haben wir noch eine oeffentliche Kiosk-Mode-Workstation mit einem Ubuntu ausgestattet… Das tschechische Windows Vista Ultimate mit deutschem Language Pack haben wir natuerlich drauf gelassen… Ein versteckter Grub macht uns dann in Zukunft mehr Freiheit.
• Nachdem der Umzug vollzogen war, wurde die Stimmung immer besser.
• Wir haben einen Fileserver aufgesetzt.
• Wir haben leckeren Tschunk gemixt und getrunken.
• Morgen machen wir auch an der kleineren Location weiter. Diesmal aber erst ab 11 Uhr.
• Der Hackcontest wurde durchgefuehrt. 5 Teams haben mitgemacht. Ein Team hat es geschafft innerhalb von 27 Minuten den Server einzunehmen. Morgen machen wir damit weiter.
• Streaming hat heute besser funktioniert als gestern.
• Die VPN  nach Berlin klappt jetzt mittlerweile auch.
• Unsere Fragen zu den Jeopardy-Antworten sind besser.

Es ist nun Pi mal Daumen 23 Uhr. Wir sind seit 9 Uhr in der Universitaet, haben viele Sachen transportiert, aufgebaut und herumgetueftelt. Hier mal ein paar Stichpunkte zum Verlauf des aktuellen Tags:

• Der Transport der Sachen verlief problemlos.
• Bei der Ankunft stellten wir fest, dass der Strom in allen Hoersaelen abgestellt war. Wir haben das dem Pfoertner mitgeteilt, der wiederum den technischen Notdienst alarmiert hat. Eine Stunde Zeitverzoegerung. Erst kurz vor dem ersten Vortrag hatten wir Strom.
• Die Streams waren zu Beginn fast nicht nutzbar. Waehrenddessen genauso wenig. Im Moment ist es relativ akzeptabel.
• Die Konfigurationsdaten, die wir vom CCC erhalten haben, um der VPN des CCC in Berlin beizutreten waren nutzlos, da wir bisher keine Moeglichkeit gefunden haben, die Portblockaden der Universitaet zu umgehen, die Routen zu setzen etc. An dem Problem sassen wir bisher ungefaehr 12 Stunden.
• Um ca. 20 Uhr wollte uns ein anderer Pfoertner verklickern, dass die Veranstaltung nur bis 18 Uhr angemeldet sei. Wir haben jedoch 4 volle Tage angemeldet. Wir koennen natuerlich weitermachen.
• Mittags haben wir bei Pizzaboy bestellt. Das ging relativ schnell (40 Minuten) in Relation zu der Menge, die wir bestellt haben. Das Essen war lauwarm. Abends (ca. 19:30 Uhr) haben wir uns wieder entschieden bei Pizzaboy zu bestellen. Um 22 Uhr(!!!) wurde das Essen geliefert. Mein Cheese Burger hat gefehlt. Der Fahrer wollte trotzdem abkassieren, ich habe es verweigert und erst eine Nachlieferung gefordert. Die kam dann auch 30 Minuten spaeter und teilte mir mit, dass das Burgerbrot ausgegangen ist und sie stattdessen ein Baguette genommen haben. Der Burger/das Baguette hatte bereits die Aussentemperatur angenommen. Das war das letzte Mal, dass ich bei Pizzaboy bestellt habe. Trinkgeld gab es nicht.
• Die durchschnittliche Personenanzahl lag etwa bei 15. Sehr wenig, was vielleicht daran liegt, dass heute Sonntag ist, gestern noch Weihnachten war und alle noch so groggy sind. Wir sind noch optimistisch, vor allem weil ALLE anwesenden Personen auch registriert waren und die Anzahl der Registrierungen noch wesentlich hoeher ist.
• Die Atmosphaere hier in Essen war durchweg sehr gut – trotz Pizzaboy-Debakel.
• Vertreter der Piratenpartei sind auch nach Essen gekommen.
• Wir haben noch genug Mate.
• Kaffee war heute das beliebteste Getraenk. Wir haben daher spontan eine Kaffee-Flat angeboten. Unser Kaffee-Vorrat ist so gut wie aufgebraucht. Morgen frueh haben die Geschaefte gluecklicherweise wieder auf.
• Interessanterweise verbrachten die meisten Anwesenden lieber die Zeit ausserhalb der 3 Hoersaele. Wir haben uns daher kurzfristig dafuer entschieden einen Hoersaal zu schliessen und einen der Streams (je nach Vortrag) direkt im Foyer an die Wand zu werfen. Morgen entscheiden wir das wieder neu.
• Den Hackcontest haben wir nicht wie semi-angekuendigt heute schon angefangen, sondern findet erst ab morgen statt (bedingt durch diverse technische Probleme, Zeitverzoegerungen und eine geringe Anzahl von potentiellen Teilnehmern).
• Ich bin muede.

Da Netstumbler unter Windows 7 definitiv nicht funktioniert, dachte ich mir: “Hey, bau dir deinen eigenen Stumbler!” Und das habe ich auch getan. Dabei ist mir aufgefallen, dass ich gar nicht weiss, welche Daten fuer mich eigentlich relevant sind. Ich habe mir angeschaut, wie inSSIDer arbeitet und habe mir dort abgeschaut, wie ich Daten erfasse:

Zunaechst verbinde ich mich mit dem GPS Geraet und beginne zeilenweise die Daten zu parsen. Dann starte ich den Wifi-Scan. Jedesmal, wenn ein Scan abgeschlossen ist, schaue ich nach, ob ich das jeweilige Netzwerk schon kenne. Wenn ich es bereits kenne, dann ueberpruefe ich, ob der alte RSSI Wert geringer ist, als der neue. Ist das der Fall, dann setze ich die Position des gefundenen Netzes auf die aktuelle GPS Position, ansonsten lasse ich die alte bestehen. Kannte ich das Netzwerk noch nicht, dann habe ich es in die Liste der gefundenen Netze aufgenommen und die aktuelle GPS Position als Netzposition gesetzt.

Positionsapproximation

Letztendlich erhalte ich so eine nette Liste von Wifi-Infrastrukturen, und die GPS Koordinaten von dem Ort, an dem man sich am Nächsten an der Infrastruktur befunden hat. Natuerlich koennte man das noch verbessern, indem man sich der Mathematik bedient, aber da die Reichweite von Access Points noch weit unter Sichtweite ist, ist das erstmal egal.

Bei der Programmierung ist mir aufgefallen, dass ich Wifi-orientiert arbeite, d.h. ich finde Netze und suche mir dazu die Positionen. Es geht natuerlich auch andersherum: Jedesmal, wenn mir der GPS Receiver eine Koordinate rauswirft, also meist mit einem ausreichenden Takt von 1Hz, dann kann ich die zur Zeit verfuegbaren Netze dazu assoziieren. Letztlich geht es hierbei um zwei Betrachtungsweisen, die sich zwei verschiedenen Fragen widmen:

1. Welche Infrastrukturen gibt es an der Position X?
2. Welche Position hat die Infrastruktur Y?

Beide Fragen sind durchaus interessant. Die Frage, die von den meisten Geoprogrammen beantwortet wird, ist die zweite, da gerade diese beim Wardriving interessant ist. Was ich mich jetzt frage ist:

Gibt es Anwendungsfaelle, bei denen es wichtiger ist, zu wissen welche Infrastrukturen an einer bestimmten Position sind? Wenn ja: Ist ein Hybridverfahren* eventuell geeignet?

* Das Hybridverfahren, das ich mir vorstelle, laesst sich wohl am Besten durch ein Event-basiertes System und einer Datenbank entwickeln:

Uebersicht: Hybridverfahren

Hierbei registriert sich die Klasse Main bei zwei Listenern, und implementiert deren Interfaces. Beide Methoden networkFound() und positionChanged() machen jetzt im Prinzip das Gleiche:

• Gefundene Netzwerke (im networkFound()-Fall genau eins) werden in die Datenbank geschrieben (z.B. in die Tabelle networks).
• Die Position wird in die Datenbank geschrieben (z.B. in die Tabelle positions).
• Es werden Relationen in eine dritte Tabelle (z.B. network_positions) geschrieben. Darin enthalten sind nur die jeweiligen IDs der Netzwerke bzw. Positionen.

Mit dem Verfahren lassen sich beide Fragen beantwortet. Dieses Verfahren ist jedoch nicht verbreitet (keins der bekannten Tools arbeitet auf diese Weise). Aber wieso nicht?

Mjam, wie Einige schon mitbekommen haben, entwickle ich ein Real-Time Tracking System fuer Katastrophenschutzorganisationen am Pervasive Computing and User Interface Lehrstuhl von Prof. Albrecht Schmidt an der Universitaet Duisburg-Essen… Bevor ich alle langweile: Hier gibt es weitere Informationen fuer die jenigen, die mehr erfahren wollen:

ZoneTrak @ Tomorrow Lab

Ich habe mir ernsthaft darueber Gedanken gemacht, ob ich mir einen Presseausweis zulegen soll. Geht das als Blogger ueberhaupt? Ja, geht¹. Wozu? Ein Beispiel:

Der Eintritt in den Resellerbereich auf der CeBIT ist Resellern, die sich als solche Ausweisen koennen, und der Presse, unter Vorlage eines Presseausweises, vorbehalten.

Die CeBIT ist wahrscheinlich ein schlechtes Beispiel, weil sie als eine der wenig(st)en Veranstaltungen selber Presseausweise fuer Blogger ausstellt. Aber das Beispiel gilt o.B.d.A.

Nun, wieso nicht? Minimal 97 EUR Aufnahmegebuehr in den DVPJ + bis zu 36 EUR monatlichen Mitgliedsbeitrag. *cough*

Idee: Man sollte einen neuen Verband gruenden: den Deutschen Verband der Presseblogger (DVPB). Dabei muesste man Presseblogger nur noch so definieren, dass ein Blogger genau dann ein Presseblogger ist, wenn seine Beitraege nachweislich (zum Teil) journalistischer Natur sind.

1. http://www.jurablogs.com/de/presseausweis-fuer-blogger [↩]

Ich bin nun mehrfach darauf gestossen, wie fehlgeleitet manche Personen in Bezug auf Designentscheidungen sind.

C# fuehrt mit der Version 3.0 das Keyword var ein. In der offiziellen C# Reference wird klargestellt, dass var nicht von variant, sondern von variable kommt. Alles andere wuerde die Natur von C# veraendern: C# ist strongly typed, d.h. jede Variable ist von einem Typ. Typdeklarationen und Objektdeklarationen sind eindeutig.

Was ich nun gelesen habe, sind Sachen wie…

I would say use var wherever you can use it

var has a lot of benefits. It forces initializing to not null value, and it introduces flexibility inside the method scope as Chris illustrated in his example.

oder

1. It induces better naming for local variables.
2. It induces better API.
3. It induces variable initialization.
4. It removes code noise.
5. It doesn’t require the using directive.

Gegen Letzteres wurde richtigerweise wie folgt argumentiert:

It’s interesting how not only are almost all of these “benefits” mainly stylistic but how they contradict each other. For example, the claim that it leads to “better naming for local variables” really means it compels developers to use LONGER HUNGARIAN STYLE VARIABLE NAMES. Funny enough, these long variable names add more noise to the code overall since they show up everywhere the variable is used compared to a single type name showing up when the variable is declared. The argument that it leads to “better API” is another variation of this theme since it argues that if you are compelled to use LONGER MORE DESCRIPTIVE PROPERTY NAMES (e.g. XmlNode.XmlNodeName instead of XmlNode.Name) then this is an improvement. Someone should inform the ReSharper folks that encoding type information in variable names sucks, that’s why we’re using a strongly typed programming language like C# in the first place.

One more thing, the claim that it encourages variable initialization is weird given that the C# compiler already enforces that. More importantly, the common scenario of initializing a variable to null before it is used isn’t supported by the var keyword.

Zu letztem Absatz musste ich dann noch folgendes lesen:

Usually I don’t like initializing to null, but sometimes I find myself forced to because of some language limitations. So I can agree with you.

So. Zur Klarstellung: Erstens ist es keine Sprachlimitierung. Im Gegenteil: Es ist gewuenscht, dass Variablen, die nicht mit einem Wert belegt wurden, zumindest mit null belegt werden muessen, um keine undefinierten Zustaende zu erreichen. Ein Compiler sollte keine Annahmen ueber die Vorbelegung treffen muessen, da das zu undefinierten Zustaenden fuehren kann. Zweitens: var wurde zu Deklarationen von Variablen mit anonymen Typen geschaffen. Es wurde zeitgleich zu LINQ (und Lambda Expressions) eingefuehrt, was es C# ermoeglicht mit Sprachelementen Datenbankabfragen oder XML Abfragen in der selben Form durchzufuehren (ohne diese Anfragen in SQL umzuwandeln o.ae. Die Idee dahinter ist verwandt mit der von Embedded SQL). Eine solche Abfrage kann wie folgt aussehen (Auszug aus msdn):

var custQuery = from cust in customers
                where cust.City == "Phoenix"
                select new { cust.Name, cust.Phone };

Dieser Codeausschnitt deklariert die Variable custQuery und weist ihr einen Typ zu, der aus dem LINQ Ausdruck ermittelt wird. Aus dem IEnumerable implementierenden Interface customers werden alle Elemente gewaehlt, deren Property City den Wert Phoenix haben. Die Ergebnisrelation besteht aus Elementen, die anonyme Typen sind. Sie enthalten zwei Attributwerte, die aus einer Zeile der LINQ-Abfrage aggregiert werden. Es ist an dieser Stelle unmoeglich festzulegen, von welchem Typ new { cust.Name, cust.Phone } ist (heisst ja nicht umsonst anonymer Typ).

Genau hier und nur bei solchen Gelegenheiten, sollte var verwendet werden.

Nochmal zum Thema null-Initialisierung: Variablen mit null vorzubelegen zeugt von gutem Code. Jede nicht mit einem Objekt belegte Variable sollte den Wert null erhalten, um Fehlerbehandlung durch Ueberpruefung auf null erst moeglich zu machen. Wer damit argumentiert, dass ja an irgendwelchen Stellen NullReferenceExceptiosn geworfen werden, der gehoert erschossen. Exceptions sind keine Compilerfehler. Sie sollen auch gar keine Compilerfehler ersetzen, solange kein Algorithmus gefunden wurde, der in polynomieller Zeit berechnen kann, ob eine Variable bei fester Eingabe eines Programmes mit null belegt wurde (das Problem ist auf das Halteproblem reduzierbar; demnach ist das Problem unentscheidbar, solange nicht bewiesen wurde). Sie dienen viel mehr dazu Ausnahmen(!), die zur Laufzeit(!) auftreten behandeln zu koennen. Sollte (bei Vorbelegung mit null) dennoch regelmaessig eine NullReferenceException auftreten, so hat man beim Programmieren wohl Mist gebaut.

Uebrigens basiert LINQ auf dem generischen Interface IEnumerable. Klassen, die IEnumerable implementieren, bieten mittlerweile auch Methoden an, die mit Lambda Expressions genutzt werden koennen. Der oben angegebene Code wird (zur Compiletime) in folgenden Code uebersetzt:

var custQuery = customers.Where(cust => cust.City == "Phoenix").Select(cust => new { cust.Name, cust.Phone });

So und nicht anders. Argh.