Herzlichen Dank an Nils, dass er mir die Möglichkeit gegeben hat, selfoss in seinem Blog vorzustellen.

Neu verfügbar ist nun neben MySQL ein Datenbankbackend für Sqlite und MongoDB (danke Harald). Zudem habe ich noch ein paar Bugs entfernt. Vielen Dank an alle Betatester. Euer Feedback war echt super!

Auf selfoss.aditu.de ist nun auch eine Dokumentation zu finden. Dort ist auch eine kurze Erklärung, wie eigene spouts, also andere Anwendungen und Quellen an Selfoss angeschlossen werden können. Dazu habe ich hier im Blog ja auch schon einmal ein Tutorial geschrieben.

Tja, sonst kann ich nur sagen: schaut euch selfoss einfach einmal an. Ich nutze es ja schon seit einigen Monaten und schätze die schlichte und übersichtliche Art, News zu lesen sehr.

Manchmal möchte man aber auch nur einzelne Einträge von RSS Feeds um zusätzliche Informationen anreichern. Ich mache das beim RSS Feed von heise, wo der Inhalt des News Beitrages nicht mitgeliefert wird. Diesen lade ich dann einfach in einer speziellen Datenquelle, die sich um diese Funktion von einem gewöhnlichen RSS Feed unterscheidet, nach.

Nun gibt es eine Schritt-für-Schritt Anleitung, wie so eine Datenquelle erstellt werden kann.

Eine Datenquelle, eine Klasse

selfoss stellt ein kleines Framework zur Verfügung, das es erlaubt recht einfach neue Datenquellen hinzuzufügen. Dazu muss nur eine einzelne PHP Datei unter
/spouts/your_spouts/your_spout.php
abgelegt werden (your_spouts und your_spout kann frei durch einen anderen Namen ersetzt werden). Diese PHP Datei muss eine einzelne Klasse enthalten, welche von der abstrakten Klasse \spouts\spout abgeleitet ist (man beachte, dass selfoss PHP 5.3 voraussetzt und \spouts der Namespace für alle Datenquellen ist).

Datenelemente der Klasse

Die eigene Klasse muss drei Datenelemente definieren:

• name: der Name der Datenquelle
• description: eine Beschreibung
• params: hier werden die Optionen der Datenquelle festgelegt. Soll z.B. ein Benutzername eingegeben werden, so kann dies hier vorgegeben werden.

Folgend gleich ein Beispiel für so eine Klasse. Natürlich fehlen hier noch die Methode, auf die ich gleich eingehe. Es wird eine Datenquelle für einen Email Account via IMAP definiert. Der Benutzer muss, wenn er eine solche neue Email IMAP Quelle definiert, die Email Adresse, das Passwort und den Server eintragen. $params beschreibt diese drei Parameter, legt fest, was für ein Typ diese darstellen und wie die Eingabe des Benutzers validiert wird.

<?PHP
namespace spouts\mail;
class imap extends \spouts\spout {
    public $name = 'Email';
    public $description = 'email imap account as source';
    public $params = array(
            "email" => array(
            "title"      => "Email",
            "type"       => "text",
            "default"    => "",
            "required"   => true,
            "validation" => array("email")
        ),
        "password" => array(
            "title"      => "Password",
            "type"       => "password",
            "default"    => "",
            "required"   => true,
            "validation" => array("notempty")
        ),
        "host" => array(
            "title"      => "URL",
            "type"       => "text",
            "default"    => "",
            "required"   => true,
            "validation" => array("notempty")
        )
    );
}

Methoden der Klasse

Durch die abstrakte Elternklasse \spouts\spout muss die Datenquelle einige Funktionen implementieren. Diese werden dann im laufenden Betrieb von selfoss aufgerufen. Folgendes UML Diagramm gibt einen Überblick über die Struktur:

Die Klasse muss drei Dinge implementieren:

• Sie muss eine Funktion load($params) für das Laden der Informationen zur Verfügung stellen. Diese wird während der Aktualisierung einmal aufgerufen und erhält als Parameter die aktuellen Einstellungen. load($params) muss von der Datenquelle implementiert werden und holt die Daten von der entfernten Quelle (z.B. führt einen IMAP Zugriff aus und lädt aktuelle Emails).
• Sie muss das Interface Iterable implementieren. selfoss iteriert, nachdem load() ausgeführt wurde, dann über die einzelnen Einträge (mit Hilfe der Funktionen, die das Interface Iterable vorgibt: rewind, current, key, next, valid). Die einzelnen Einträge könnten z.B. neue Emails sein.
• Während selfoss über die einzelnen Einträge iteriert, werden dann die Informationen dieser einzelnen Einträge abgerufen. Dies geschieht über Funktionen, welche durch die abstrakte Klasse \spouts\spout vorgegeben werden. Informationen sind z.B. Betreff einer Email, Email Body usw.

Der Ablauf ist dann folgender:

1. Im Beispiel würde load($params) von selfoss mit der vom Benutzer eingegebenen Email, Passwort und Host aufgerufen.
2. Diese Methode würde dann die Emails vom IMAP Account herunterladen und zwischenspeichern.
3. selfoss iteriert über die einzelnen Emails (mit rewind, current, key, next, valid).
4. Bei jedem einzelnen Iterationsschritt (also für jede Email) werden die Email-Informationen abgerufen (Inhalt, Betreff, Datum usw.) und zwar mit Hilfe der Funktionen: getId(), getTitle(), getContent(), getIcon(), getLink(), getDate().
5. Um den Rest kümmert sich selfoss (prüfen ob es den Eintrag schon gibt, alte Einträge löschen usw.)

Eine Implementierung für diese Funktionen liegt natürlich völlig in der Hand des Entwicklers einer Datenquelle. Daher verweise ich an dieser Stelle auf die vorhandenen Datenquellen. \spouts\spout\feed (\spouts\rss\feed.php) stellt ein gutes Beispiel dar. Wer diese als Vorlage nimmt, kommt recht schnell sehr weit, denn dort werden alle Funktionen genutzt. Soll nur ein Standard RSS Feed um Funktionen erweitert oder angepasst werden, dann verweise ich auch die Klasse \spouts\spout\heise (\spouts\rss\heise.php). Hier wird lediglich die getContent() überschrieben und ansonsten verhält sich die Datenquelle wie ein gewöhnliches RSS Feed.

Thumbnails

Soll anstelle eines Textes ein Vorschaubild angezeigt werden, so muss die Methode getThumbnail() implementiert werden. Diese liefert für einen einzelnen Eintrag das Vorschaubildchen (die URL auf das Bild). \spouts\spout\images (\spouts\rss\images.php) ist ein Beispiel dafür. Diese Datenquelle geht von einem gewöhnlichen RSS Feed aus, durchsucht es nach Bilder (entweder ausgezeichnete Thumbnails im XML des Beitrages, oder das erste Bild im Content des Beitrages) und liefert die URL an selfoss. Das Laden, Verkleinern, Speichern und Aufräumen der Bilder übernimmt selfoss.

Los gehts…

Das war sie, die kurze und knackige Einführung, wie Datenquellen für selfoss entwickelt werden können. Gerne könnt ihr mir dazu Fragen stellen und bei Problemen schreiben (am besten hier im Blog, so dass auch andere von den Antworten profitieren können). Sehr freue ich mich auch über fertige Datenquellen. Gerne nehme ich neue in selfoss auf.

Benannt habe ich Selfoss nach dem isländischen Wasserfall. Aus vielen Quellen werden Informationen abgegriffen und landen am Ende in einem immerwährenden Storm an Informationen. Das kommt einem Wasserfall irgendwie nahe.

Features

selfoss sammelt Nachrichten von verschiedenen Quellen und stellt diese in einem einzigen Stream dar. Es gibt keine Kategorien, keine umfangreichen Optionen oder ein Prioritätensystem, wie bei rsslounge. Die Idee ist nicht neu, immerhin bieten twitter, facebook und wie sie alle heißen als zentrale Anlaufstelle eine “Pinnwand” in der aktuelle Meldungen einfach untereinander angezeigt werden. selfoss ist aber darauf ausgelegt, Informationen aus verschiedensten Quellen zu aggregieren. Ein offenes Pluginsystem erlaubt es, einfach neue Datenquellen hinzuzufügen (ein Tutorial dazu werde ich noch verfassen).

Out of the Box unterstützt selfoss folgende Quellen (Wer rsslounge kennt, wird die Liste wiedererkennen):

• RSS Feeds
• RSS Feeds mit Bilder
• deviantArt Benutzer, Favoriten und Daily Deviations
• Tumblr Blogs
• Eigene Twitter Timeline
• Twitter Benutzer
• Heise Feed mit vollem Text

Unterstützt werden auch wieder Bilder, von denen automatisch Thumbnails erzeugt und angezeigt werden. Interessante Einträge können markiert werden und gefiltert angezeigt werden. Zudem steht eine Suche zur Verfügung.

selfoss als mashup

Darüber hinaus stellt selfoss die aggregierten Beiträge als ein neues RSS Feed zur Verfügung. Wer also selfoss nur zum Sammeln von Informationen verwenden will, um diese dann via RSS weiter zu verarbeiten, wird hier das Tool seiner Wahl finden. Nachdem es möglich ist, auch eigene Plugins für Datenquellen zu schreiben, können beispielsweise Informationen aus RSS Feeds, Emails und Logfiles zusammengefasst werden.

selfoss als lifestream

selfoss lässt sich auch als schreibgeschützte Version konfigurieren, die es nur mit einem angemeldeten Benutzer erlaubt Einstellungen zu ändern. selfoss kann also mit eigenen Inhalten befüllt werden. So könnte man eigene Einträge von Twitter, Facebook, deviantArt und anderen Seiten zusammenfassen und gesammelt in einer Seite anzeigen. Für mich ist das jetzt nicht wirklich ein Feature, aber da es sich angeboten hat auch einen “Public” Modus einzubauen, habe ich das vorgesehen.

Anforderungen

selfoss benötigt folgende Ausstattung:

• WebServer (Apache, lighttpd usw.)
• MySQL
• PHP 5.3 oder höher
• Browser (Chrome, Firefox, Safari, IE7+)
• iPad und Android

Clientseitig läuft es auf allen gängigen Browsern und ist insbesondere auch auf dem iPad oder unter Android lauffähig. Zumindest war mir das wichtig, denn ich will auch mal unterwegs oder vom Sofa aus kurz die aktuellsten News checken.

Standardmäßig ist die .htaccess Konfigurationsdatei für den Apache Webserver dabei, aber eine Konfiguration ist auch unter nginx oder lighttpd möglich (siehe dazu das Manual von Fat Free PHP Framework).

Installation

Die Installation ist simpel:

1. alle Dateien hochladen (auch die versteckten nicht vergessen)
2. das data Verzeichnis und dessen Unterverzeichnisse schreibbar machen
3. in die config.ini die Datenbankverbindung eintragen
4. CronJob http://<yourselfossurl>/update einrichten
5. selfoss im Browser aufrufen und Quellen eintragen

Download

Herunterladen könnt ihr selfoss hier:

• selfoss 1.0 beta (644 kb) mittlerweile gibt es die finale Version: http://selfoss.aditu.de

Die Sourcen sind auf github zu finden. An der Stelle will ich natürlich auch auf den Künstler des Logos verweisen.

Feedback

Über Feedback freue ich mich natürlich sehr. Ihr könnt mir Emails schreiben, auf diesen Beitrag kommentieren oder das Ticket System von github verwenden.

Für mein neuestes Projekt wollte ich etwas einfaches, das eine saubere Struktur ermöglicht, aber nicht mit tausenden Dateien und riesigem Funktionsumfang daher kommt. Da ich schon vor einiger Zeit auf das PHP Fat-Free Framework gestoßen bin, und es einen sehr guten ersten Eindruck hinterlassen hat, habe ich mich entschlossen mir das Framework etwas genauer anzusehen. Sehr schnell war klar, dass es perfekt geeignet ist.

Features

Das PHP Fat-Free Framework verfügt über alle wichtigen Features, die mittlerweile so Standard sind:

• Routing Mechanismus (sehr einfach auch im MVC Style realisierbar)
• Datenbankzugriff (sogar mit einem mini ORM und einem MongoDB mapper)
• Template Engine
• Schnick Schnack wie: On-the-fly JavaScript/CSS compressor, CAPTCHA generator, OpenID, usw.

Die Template Engine konnte mich nicht ganz überzeugen, hier habe ich selbst Hand angelegt, eine kleine Hilfsklasse geschrieben und auf den in PHP integrierten Syntax zurückgegriffen. Ansonsten konnte das Framework in voller Linie überzeugen. Selbst eine Migration um eine Major Version funktionierte mit sehr geringem Aufwand, was mich doch sehr überrascht hat.

Anforderungen

Das Framework selbst ist sehr klein und wird mit einer einzigen 55KB großen PHP Datei beworben. Ganz richtig ist das aber nicht: Der Datenbankzugriff und weitere Funktionen wurden in Plugins ausgelagert. Nimmt man den gesamten Funktionsumfang, so hat man 27 Dateien mit einer gesamten Größe von 223 KB, was natürlich immernoch sehr schlank ist.

Ein bestimmter Server ist nicht erforderlich und das Manual bietet Anleitungen für das Umschreiben der URLs für den Apache Webserver, lighttpd und nginx. Einziger Wermutstropfen: Es benötigt mindestens PHP 5.3, was für einen simplen RSS Reader, der möglichst überall laufen soll eine doch recht hohe Anforderung ist. Gleichzeitig liefert diese Anforderung auch zahlreiche Vorteile, wie beispielsweise schlankeren Code durch Lambda-Funktionen oder der Einsatz von Namespaces.

F3 in der Praxis

Warum mir das Framework so zusagt, sieht man schnell, wenn man ein paar Zeilen Code sieht. Ein Beispiel ist das Routing:

require __DIR__.'/libs/f3/base.php';
F3::set('AUTOLOAD','libs/f3/|libs/|libs/WideImage/|models/|libs/twitteroauth|libs/FeedWriter');
F3::route('GET /', 'controllers\Index->home');
F3::route('GET /mark/@item', 'controllers\Items->mark');
F3::route('POST /source', 'controllers\Sources->add');
F3::route('PUT /source/@id', 'controllers\Sources->write');

Mit der ersten Zeile wird das Framework eingebunden. Mit der zweiten wird ein Autoloader registriert und die entsprechenden Inlcude-Pfade gesetzt (das Pipe Symbol | dient hier als Trennzeichen. Dann werden die Routen definiert. Das Fat-Free Framework unterstützt hierbei auch den REST Ansatz und einzelne URLs können mehrfach, je nach Art des HTTP Requests belegt werden. In diesem Beispiel wird bei einem GET Aufruf der URL / die Klasse \controllers\Index instaziiert und dort die Methode home aufgerufen.

Ähnlich einfach ist der Datenbankzugriff:

F3::set('DB',
	new DB(
		'mysql:host=localhost;port=3306;dbname=mysqldb',
		'admin',
		'p455w0rD'
	)
);
DB::sql('SELECT brandName FROM wherever');
foreach (F3::get('DB->result') as $row) {
	// whatever you want to do with $row
}

Um SQL Injection vorzubeugen, werden natürlich auch parametrisierte Queries unterstützt.

Ähnlich simpel ist das gesamte Framework gestrickt und meist bietet es verschiedene Wege etwas umzusetzen. Besonders elegant finde ich das Routing mit Lambda Funktionen:

F3::route('GET /about',
	function() {
		echo 'No subliminal messages here...';
	}
);

Lizenz und Downloads

Das Framework steht unter der GPLv3 Lizenz zur Verfügung, es wird aber auch eine kostenpflichtige, kommerzielle Lizenz angeboten. Das finde ich das einzige Manko, hier bietet beispielsweise das Zend Framework unter der MIT Lizenz sehr viel mehr Möglichkeiten.

Zur Projektseite des PHP Fat-Free Frameworks: http://fatfree.sourceforge.net/

An dieser Stelle vielen Dank an alle, die mich mit Sprachdateien versorgt haben und mir Feedback geben. Sofern ich die Zeit finde, versuche ich sinnvolle Neuerungen einzubauen. Die Performance zu optimieren (besonders das erstmalige Laden von rsslounge zu beschleunigen) war im aktuellen Update mein primäres Anliegen. Die Änderungsliste ist im Changelog zu finden.

Download: rsslounge 1.7

Zend_Translate bietet hier eine einfache Möglichkeit “Routen” zu erstellen. Das heißt man kann festlegen, welche Sprache alternativ verwendet werden soll. Dabei können sogar Ketten gebildet werden (z.B. wenn Französisch nicht gefunden wurde, dann in der deutschen Übersetzung suchen und wenn dort auch nichts gefunden wird, in der englischen). Wobei sich mir der Sinn von so einer Verkettung nicht ganz erschließt.

Das setzen einer Route ist sehr einfach. Folgendes Beispiel scanned ein übergebenes Verzeichnis nach CSV Dateien und übernimmt deren Inhalt als Übersetzung. Mit dem Key “route” wird definiert, wie die Sprachen verkettet werden sollen. In diesem Beispiel ist Englisch die Fallbacksprache für Deutsch und Französisch.

$language = new Zend_Translate(
            'csv',    // Typ der Quelle: hier csv Dateien
            'locale', // Quell-Verzeichnis
            'en',     // Standard Sprache
            array(    // Optionen
                'scan' => Zend_Translate::LOCALE_DIRECTORY,
                'route'     => array( 'de' => 'en', 'fr' => 'en' )
            ));

Der sauberste Weg ist es natürlich alle Schlüssel auf zu übersetzen. Beim Aufspüren von fehlenden Übersetzungen hilft Zend_Translate ebenfalls.

The Secret of Monkey Island: Special Edition, for iPad

Guybrush Threepwood ist wieder unterwegs und zwar diesmal auf dem iPad. Einfach ein Genuss für jeden, der die Originale kennt. Die Special Edition wartet mit neu gezeichneten Grafiken auf und erlaubt ein flüssiges Wechseln zwischen der alten und neuen Fassung. Auf dem iPad ein besonderer Genuss.

Einsamer Wolf Band 4: Die Schlucht des Schicksals

Es ist wieder soweit: ein weiterer Band der halbjährlich erscheinenden Neuauflage des Rollenspiel Klassikers Einsamer Wolf gibt es seit wenigen Tagen zu bestellen.

jQuery.dform

Dieses Projekt von Daff bietet ein jQuery Plugin, dass aus einer JSON-formatierten Beschreibung ein HTML Formular erzeugt. Besonders interessant ist das für alle, die möglichst die gesamte Logik in JavaScript halten wollen. Eine kleine Besonderheit: jQuery UI wird gleich mit unterstützt. Stelle mir das in Kombination mit einem PHP Backend sehr praktisch vor, wenn es um das Nachladen von Formularen geht.

deviantArt @tumblr

DeviantArt ist nun auch auf tumblr zu finden. Dort werden herausragende Kunstwerke vorgestellt. Auf jeden Fall gelungen, hab deviantart @tumblr schon in meine rsslounge Aboliste hinzugefügt (btw: [Werbung]rsslounge unterstützt tumblr Profile[/Werbung] ).

Sintel

Basierend auf dem OpenSource Programm Blender wurde mittlerweile der dritte Film erstellt. Einfach sehenswert, mehr will ich dazu nicht sagen.

Neue Fotos

Ein paar wenige, neue Fotos gibt es auch von mir, die ich auch niemanden vorenthalten will

Hierfür habe ich verschiedene Verfahren der Test-Klassifikation aus dem Information Retrieval in Betracht gezogen und hinsichtlich ihrer Eignung bezüglich des Problems untersucht. Anschließend habe ich als Referenz die Lernfähigkeit mittels dem naiven Bayes-Klassifikators implementiert. Als zweite Lösung habe ich das k-nächste-Nachbarn Verfahren, basierend auf dem simulierten Abkühlen implementiert und untersucht, ob eine der beiden Lösungen für dieses Problem in Frage kommt. Das Ergebnis ist ist leider sehr ernüchternd.

Trotzdem möchte ich hierzu das Paper, das ich dazu verfasst habe, veröffentlichen. Zum einen gibt es einen guten Überblick und eine gute Einführung in die gängigen Verfahren der Text-Klassifikation, zum anderen halte ich das optimierte k-nächste-Nachbarn Verfahren für sehr leistungsfähig. Für passende Problemstellungen ist das ein praxistauglicher Lösungsweg.

Nachdem ich die gesamte Entwicklung von rsslounge offen gelegt habe, halte ich es für sinnvoll auch diesen Versuch (und das damit verbundene Paper) zu veröffentlichen. Vielleicht inspiriere ich jemanden, oder liefere für weitere Arbeiten eine Grundlage bzw. Informationen.

Das Paper als PDF zum Download (1.5MB): Automatisiertes Priorisieren von RSS Feed Beiträgen mittels maschinellem Lernen

Die Problemstellung

Nun aber zum Thema: für ein aktuelles Projekt benötige ich, von meiner PHP Webapplikation heraus, den Zugriff auf einige Hardwarekomponenten. Zudem will ich einige Fremdbibliotheken verwenden, die sehr rechenintensive Aufgaben übernehmen und auch nur in C++ zur Verfügung stehen. Die Frage ist also: wie kann ich diese Komponenten an mein PHP Programm ankoppeln?

Für Java gibt es eine ganz gute Server Bridge, die innerhalb der Java Virtual Machine einfach einen kleinen Server startet, der XML Anfragen entgegen nimmt, stellvertretend ausführt und das Ergebnis, auch wieder über eine XML Kommunikationsschnittstelle, zur Verfügung stellt. Die nötige PHP Klasse wird ebenfalls durch den Java Server direkt zur Verfügung gestellt. Eine ähnliche Bridge Lösung bringt auch der Zend Server bereits out of the box mit.

Für C++ habe ich so eine Lösung nicht gefunden und als weiteren Ansatz überlegt, eine PHP Extension zu entwickeln. Sowohl für Linux, als auch für Windows, gibt es hier Tutorials (siehe “Extension-Entwicklung unter WAP“, “Wrapping C++ Classes in a PHP Extension” oder “Extension Writing Part I: Introduction to PHP and Zend“). Allerdings ist, neben den Tutorials, der ganze Vorgang nicht gut dokumentiert und scheinbar muss das Kompilat der Extension exakt dem des verwendeten PHP Kompilats entsprechen. Insgesamt also eher eine wackelige Angelegenheit.

Lösungsansatz

Meine Lösung ist hingegen pragmatisch und verfolgt eine eher losere Kopplung: Meine C++ Komponenten werden in ein eigenständiges Programm ausgelagert, das selbst, über einen gewöhnlichen HTTP Server, die benötigten Dienste zur Verfügung stellt. Dabei orientiere ich mich an dem REST Architektur Prinzip und binde jeweils eine Teil-Funktionalität an eine feste URL. Die Parameter und Rückgabewerte werden mittels JSON kodiert. Von PHP Seite aus, wird der Aufruf der C++ Komponenten sauber gekapselt, so dass für das PHP Programm der Eindruck entsteht, dass eine gewöhnliche Funktion aufgerufen wird.

Welche Vor- und Nachteile hat das Vorgehen? Zum einen ist die in C++ implementierte Funktionalität sauber gekapselt und von der Webapplikation getrennt. Dadurch wird die Software leichter wartbar. Durch eine saubere Schnittstellendefinition, kann die C++ Serverkomponente auch unabhängig vom Wissen über die PHP Applikation gepflegt werden. Zum anderen entsteht aber ein zusätzlicher Aufwand (mit zusätzlichen Fehlerquellen). Die Schnittstelle muss definiert und implementiert werden, ein Fehlerhandling muss durchgeführt werden und eine zusätzliche Serverapplikation muss gestartet werden, was hinsichtlich der Sicherheit berücksichtigt werden muss. Dennoch halte ich die Lösung für die eleganteste, denn sie nutzt genau die Vorteile der Vernetzung und der losen Kopplung aus. So könnte die C++ Komponente bei höherer Last auch leicht auf einen eigenen Server umgezogen oder unabhängig von der Webapplikation betrieben werden.

Implementierung

In der Theorie hört sich natürlich immer alles ganz nett an, aber wie sieht das mit dem HTTP Server aus? Hier gibt es eine hervorragende C++ Bibliothek, mit der sich ohne großen Aufwand eine solcher HTTP Server realisieren lässt. mongoose heißt das Wunderding, steht unter der MIT Lizenz unter Google Code zur Verfügung. Es unterstützt Windows, Linux und Mac OS X, bietet eine CGI Schnittstelle, SSL Verschlüsselung, ACL, eine saubere API und ist nicht größer als 60 kB. Die Dokumentation ist zwar recht knapp, aber dank Beispiele findet man sich schnell zurecht und auch die API Beschreibung ist vollkommen ausreichend.

Will man einen eigenen Server starten, so muss zuerst ein neuer Context erzeugt werden:

struct mg_context* ctx;
ctx = mg_start();

Mit mg_set_options, werden die Servereinstellungen geändert. Folgende zwei Zeilen deaktivieren das Directory Listing und setzten 8080 als Port.

mg_set_option(ctx, "dir_list", "no");
mg_set_option(ctx, "ports", "8080");

Aus Sicherheitsgründen erlaube ich nur einen Zugriff vom selben Rechner aus, also erlaube nur die IP Adresse 127.0.0.1:

mg_set_option(ctx, "acl", "-0.0.0.0,+127.0.0.1");

Mit mg_set_uri_callback kann ein Pointer auf eine eigene Funktion an eine URL gebunden werden. Diese wird aufgerufen, wenn der Client die URL aufruft, wobei die URL auch Wildcards enthalten kann.

mg_set_uri_callback(ctx, 'dosomething', &Server::dosomething, NULL);

Als dritter Parameter darf ein Pointer (void*) auf ein beliebiges Objekt übergeben werden. Die Callback Methode bekommt dazu alle notwendigen Parameter, wie die aktuelle Verbindung, den aktuellen Request und das zuvor übergebene Objekt (hier NULL) übergeben.

void Server::capture(struct mg_connection *conn,
 const struct mg_request_info *request_info,
 void *user_data) {
char* param = mg_get_var(conn, "param");
mg_printf(conn, "%s", "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
}

Mit mg_printf kann dann eine Antwort an den Client gesendet werden. Hier als einfaches Beispiel einfach nur ein OK (HTTP 200). In meinem Szenario wird hier der generierte JSON Text zurück gegeben. Mit mg_get_var können übergebene Parameter (POST, GET) ausgelesen werden. Wichtig: um memory leaks zu vermeiden, müssen diese mit mg_free wieder freigegeben werden.

Natürlich ist das nur die eine Hälfte. PHP muss jetzt auch Funktionen, auf dem Server, aufrufen können. Dazu kommt der Zend_Http_Client zum Einsatz. Dieser ist im Zend Framework enthalten, mit etwas Frickelei kann er aber auch aus dem Gesamtpaket heraus gepickt werden. Da ich aber das Zend Framework für die ganze Anwendung nutze, ist das Aufrufen der URL und das Decodieren des JSON Strings in einen Action Helper ausgelagert, der gleichzeitig eine einfache Fehlerbehandlung durchführt:

class JsonHttpHelper extends Zend_Controller_Action_Helper_Abstract {
   public function get($url, $params = array()) {
      try {
         $client = new Zend_Http_Client($url);
         foreach($params as $param=>$value)
            $client->setParameterPost($param, $value);
            $response = $client->request('POST');
            $res = Zend_Json::decode($response->getBody());
            if($response->isSuccessful()) {
               return $res;
            } else {
               return array("error" => "request not successfully: ".$res["error"]);
            }
      } catch(Exception $e) {
         return array("error" => $e->getMessage());
      }
 }
}

Bisher bin ich mit der Lösung sehr zufrieden. Besonders mongoose kann ich nur wärmstens empfehlen. Auch von der Verarbeitungsgeschwindigkeit ist das Ergebnis zufriedenstellend und kann sich sehen lassen. Um den Rahmen nicht zu sprengen, habe ich die serverseitige Generierung und Verarbeitung von JSON außen vor gelassen. Hier gibt es aber auch zahlreiche Bibliotheken, so dass die Suche nicht schwer fallen dürfte.