Open Source im professionellen Einsatz

Newsletter abonnieren
Seite durchsuchen

HEFTARCHIV | NEWS | E-BIBLIOTHEK | VIDEO | BLOGS | WHITEPAPER | EVENTS | ACADEMY | ABO | SHOP

user friendly

  Home  »  Heft & Abo  »  Heftarchiv  »  2007  »  11  »  LAMP mal ohne AMP  

RSS-Feed der aktuellen News von Linux-Magazin Online Folgen Sie Linux-Magazin Online auf Twitter
Diesen Artikel druckenDiesen Artikel weiterempfehlen Diesen Artikel kommentieren Newsletter abonnieren
Share/Bookmark

HTTP-Server weg

Nachdem aus LAMP nun das M und das P verschwunden sind, muss konsequenterweise noch das A folgen, nämlich der HTTP-Server Apache. Bei LOA ist er ein Bestandteil des Serverprozesses. Dessen Implementierung für die Tauschzone ist überraschend schlank ausgefallen, obwohl alle wichtigen Komponenten vorhanden sind.

Der HTTP-Server (Klasse »HTTPServer«) hört auf TCP-Port 80 und verteilt Anfragen (also durch »accept(2)« erhaltene Verbindungssockets) an einen Pool von Threads der Klasse »ClientConnection«. Jeder wartet, bis er vom Server die nächste Verbindung zugeteilt bekommt, holt dann geduldig die HTTP-Anfrage vom Browser auf der anderen Seite des Netzes und bereitet sie in Form eines Objekts vom Typ »HTTPRequest« auf. Der Pseudocode aus Listing 3 skizziert die Implementierung.

Listing 3:
HTTP-Server

01 // Hauptschleife von Webserver
02 HTTPServer::serve()
03 {
04     // Threads für die Verbindungen erzeugen
05     for (int i=0; i<NUM_THREADS; i++) {
06         createClientThread();
07     }
08 
09     int s = openTCPSocket(80); // auf Port 80 hören
10     int client;
11     while (true)
12     {
13         // Systemcall accept() wartet auf nächste Clientverbindung
14         client = accept(s);
15         // Filedescriptor in Warteschlange stopfen
16         pushConnection(client);
17     }
18 }
19 
20 
21 // Hauptschleife von Thread
22 ClientConnection::run()
23 {
24     while (!should_terminate)
25     {
26         // nächste Clientverbindung aus Warteschlange holen
27         // (blockiert, solange Warteschlange leer ist)
28         int fd = server->getConnection();
29 
30         // HTTP Header von Socket lesen und parsen
31         HTTPRequest request(fd);
32 
33         // HTML Objekt erzeugen zum Speichern des Ergebnisses
34         HTML html;
35 
36         // Seite von Engine berechnen lassen
37         engine->processRequest(request, html);
38 
39         // Ergebnis an Client zurückschreiben
40         writeHTTPHeader(request, fd);
41         write(fd, html.buffer(), html.length();
42 
43         // Verbindung zum Client schließen
44         close(fd);
45     }
46 }

Nach dem Empfangen kann die Engine den Request bearbeiten. Sie ist gewissermaßen Datenbank und Seitengenerator in einem. Sie generiert HTML-Code in Form eines Objekts vom Typ »HTML«, das einen Puffer für die Aufnahme des HTML-Code kapselt. Ist die Engine fertig, kann der Thread das Ergebnis in einem Rutsch an den Browser zurücksenden. Damit es keine Probleme mit der Datenkonsistenz gibt, darf allerdings immer nur ein Thread gleichzeitig die Engine benutzen.

Schneller als SQL

Listing 4 zeigt, wie die Engine anhand von Bestandteilen der URL in verschiedene Funktionen verzweigt, die jeweils eine Art Seite generieren. Das Beispiel der Artikelseite (Funktion »pageArticle«) demonstriert, wie sich der Artikel anhand seiner ID im Index »articleById« auffinden lässt. Danach stehen alle Daten des Artikels direkt über das Objekt »art« zur Verfügung.

Listing 4: Seitengenerierung
durch die Engine

01 Engine::processRequest(HTTPRequest &request, HTML &html)
02 {
03     // Dafür sorgen, dass nur ein Thread die Engine
04     // betritt (hier mit pthread-Mechanismen gelöst)
05     pthread_mutex_lock(&_mutex);
06 
07     // Kein Verzeichnis -> index.html
08     if (request.numDirs() == 0)
09         pageIndex(request, html);
10 
11     // 1. Pfadkomponente unterscheidet Art der Seite
12     else if (!strcmp(request.dir(0), "art"))
13         pageArticle(request, html); // Artikelseite
14 
15     else if (!strcmp(request.dir(0), "search"))
16         pageSearch(request, html); // Suchabfrage
17 
18     else
19         pageUnknown(request, html); // Unbekannte Seite
20 
21     // Zugang zur Engine wieder freigeben
22     pthread_mutex_unlock(&_mutex);
23 }
24 
25 
26 // Artikelseite, exemplarisch
27 Engine::pageArticle(HTTPRequest &request, HTML &html)
28 {
29     // Artikelnummer ist 2. Pfadkomponente, z.B. /art/1829/
30     int artid = atoi(request.dir(1));
31 
32     // Finde Artikel in Suchindex
33     Article *art = articleById(artid);
34     if (art) {
35         // HTML-Kopf mit Seitentitel erzeugen
36         html.addPageHeader(art->title()); // Titel des Artikels
37 
38         // Inhalt der Seite anhand der Daten aus dem Objekt art
39         html.add("Beschreibung: %s<br>n", art->description());
40         html.add("Anbieter: %s<br>n",     art->owner->fullname());
41 
42         // Seitenfuss und HTML-Abschlusscode
43         html.addPageFooter();
44     }
45     else // Artikel nicht gefunden
46         pageUnknown(request, html);
47 }

Das ist nicht nur einfacher und übersichtlicher als bei der Programmierung mit einer SQL-Datenbank, sondern auch um Größenordnungen schneller. Tabelle 1 beweist mit den verwendeten C++-Klassen die überschaubare Komplexität der HTTP-Implementierung.

Tabelle 1:
Code-Umfang


Sie können diesen Artikel als PDF für 99 Cent kaufen. Klicken Sie dazu einfach auf eine der beiden Bezahloptionen Paypal oder ClickandBuy.


Diesen Artikel druckenDiesen Artikel weiterempfehlen Diesen Artikel kommentieren Newsletter abonnieren
Share/Bookmark
Ähnliche Artikel
Gefüttert Groupware mit dem VoIP-Telefon
Tooltipps Werkzeuge im Kurztest
Vollautomatik Pentesting mit Metasploit und dem Autopwn-Modul
Projekteküche Neues aus der Welt der freien Software und ihrer Macher
Konservierungsmittel Objektdatenbank Db4o für Java und Mono
Edler Tropfen? Open-Source-Groupware Group-E von Endo7
Whitepaper
Open Source Datenintegration in der Praxis: Fallstudien und Anwendungsbeispiele

Über die letzten Jahre hinweg haben sich Open Source Lösungen als fester Bestandteil des gesamten Datenintegrationsmarktes etabliert. Viele Unternehmen haben bereits das Open Source Modell für Ihre Datenintegrationsprojekte aufgegriffen. Das vorliegende White Paper illustriert anhand ausgewählter Fallstudien und Anwendungsbeispiele die Implementierung von Open Source Datenintegration in der Praxis und benennt die daraus resultierenden Vorteile.

Download PDF (Registrierung erforderlich)
The Role of Open Source in Data Integration

Obwohl in den letzten Jahren viele technische Fortschritte erzielt werden konnten, verfügen die meisten Datenintegrationsprozesse nach wie vor nur über eine sehr begrenzte Automatisierung. Das vorliegende White Paper von dem Industry Analyst Mark Madson wird zunächst ein grundlegendes Verständnis von Daten Integration vermitteln, die Vorzüge von Open Source Lösungen für Daten Integration erläutern und Ihnen professionelle Empfehlungen geben, damit Sie Ihre Integrationsjobs noch einfacher und produktiver gestalten können.

Download PDF (Registrierung erforderlich)
Kommentare (3)
von
Andreas W.,
23.11.2010 23:56
Tolle Idee
Warum sollte das in der Praxis nicht tauglich sein? Wenn man es mit bereits bestehenden Lösungen (siehe eBay) vergleicht dann ist es sicher ein Schritt in die richtige Richtung welcher sicherlich noch verfeinert werden müßte. Es gibt zahlreiche Ansätze die ein ähnliches Ziel verfolgen (C++ Servlets, ...)
von
sinseq,
11.10.2009 17:46
Seitenaufbau
Also der Seitenaufbau ist beeindruckend. Ich habe es unter Opera (Mac OS X) ausprobiert. So etwas wünsch ich mir für viele andere Seiten, z.B. ebay!
von
Martin,
07.10.2009 23:48
Na, nicht wirklich ein optimaler Ansatz :-(
LAMP also ohne alles, sogar der Apache wird in C++ nachgebildet. Da stehen mir die Haare obgelich der möglichen Sicherheitslücken zu Berge!

Und ganz im Ernst: Der Seitenaufbau der genannten Tauschseite ist echt langsam! Und dann wurde bei den Bildern nicht mal ihre Größe angegeben, so dass zu Problemen beim Rendering kommt.

Das Ego des Autors in allen Ehren - aber so kann und sollte (!) das in KEINEM Fall in der Praxis eingesetzt werden!