4 in 1 - Medieninformatik - Hochschule RheinMain

Organisatorisches 


Web-basierte Anwendungen 

Grundlagen und Frameworks 

Prof. Dr. Peter Barth 

Hochschule RheinMain 

Fachbereich Design Informatik Medien 

Medieninformatik 

24. April 2013 

Prof. Dr. Peter Barth (HS-RheinMain) Web-basierte Anwendungen 24. April 2013 1 / 91 

Vorlesung 

• Mittwochs, Raum 14, 8:15 – 9:45 Uhr 

Praktikum 

• Mittwochs, Raum 13: B ab 11:45 Uhr, A ab 14:15 Uhr, C ab 16:00 Uhr 

Vorlesungsfolien, Übungsblätter, weitere Informationen 

• http://read.mi.hs-rm.de 

• http://www.mi.hs-rm.de/˜barth/hsrm/webanw 

Bewertung 

• Prüfungsleistung, Mündliche Prüfung 70 % 

• Studienleistung, Praktikum 30 % 

• Projekt Web Python/Basis, mindestens 8 von 15 Punkten 

• Projekt Web Servlet/Framework, mindestens 8 von 15 Punkten 

Infrastruktur 

• Pool und/oder fertiges Image /opt/share/downloads/linux/ZuHause 

• Jeder individuell und die Projektgruppe(n) ein Repository 


Ziele der Veranstaltung 


Voraussetzungen 


Design und Realisierung Web-basierter Anwendungen 

• Einsatzgebiete Web-basierter Anwendungen erkennen 

• Problemadäquater Entwurf, Architektur und Technologie- Frameworkwahl 

• Integration externer Dienste und Anwendungen, z.B. DBMS 

• Sicherheitsaspekte, Lastaspekte 

Umgang mit praxisrelevanten Web-Technologien 

• Grundlagen (CGI, Templating, Integration): mit Python 

Bewußt ohne (minimal) weitere Frameworks (selber machen) 

• Applikationsserver/Servlet-Container: mit Tomcat 

• Webkomponentensystem: mit Java Server Faces 

Vorbereitung Praxisphase und Beruf 

• Oft wichtigstes Thema 

• Im Praktikum dann meist auch Django (Python + Framework), Rails (Ruby), PHP 

mit Zend oder Typo3, . . . 

• . . . womit Sie nach Veranstaltung nach 1 Woche produktiv arbeiten können 

Auszeichnungssprachen 

• HTML Grundkenntnisse 

(de.selfhtml.org) 

• XML Grundkenntnisse 

Programmieren 

• Python, Java 

• OO, UI-Patterns 

Datenbanken 

• SQL 

• Integration in 

Programmiersprachen 

Spaß 

• An komplexen Dingen 

• An der Umsetzung 

Infos, Tools und Downloads: 

/opt/share/praktika/WebAnw/ 

/opt/share/downloads/linux/ZuHause 


Prof. Dr. Peter Barth (HS-RheinMain) Web-basierte Anwendungen 24. April 2013 4 / 91


Grundlagen Web 

Einführung 

Literatur 


CGI, Grundlagen 

• http://de.selfhtml.org/servercgi/cgi/index.htm 

• http://docs.python.org/2/library/cgi.html 

• http://www.python.org/dev/peps/pep-0333, 

http://code.google.com/p/modwsgi/ 

• Programming Python, O’Reilly, Lutz, Kapitel 16 

Servlets 

• Servlets & JSP, Addison-Wesley, Falkner 

• JAVAEE/servlet, JavaEE/jsp 

http://jcp.org/en/jsr/detail?id=315 


Java Server Faces 

• Java Server Faces 2.0, dpunkt, Marinscheck et. al 

• JAVAEE/javaserverfaces-139869.html, 



Web-basierte Anwendung 

• Dokumentenbasiert, Client-Server 

Client 

• Präsentation, Dokumentendarstellung 

• Web-Browser 

• Desktop, mobiles Device 

Server 

• Anwendungsfunktionalität, 

Dokumentenerzeugung 

• Web-Server 

• Meist Server 

Klassifikation 

• Inhalte, Layout, Interaktion 

• Anzahl Nutzer, Zugriffe 

• Sicherheit, Verfügbarkeit 

Anfrage 

Server 

Antwort 






Statische Inhalte 

Historie 

• 88, Tim Berners-Lee, Enquire 

• Hypertext, 

WWW 

• 90, Name “World Wide Web” 

• Standards HTTP, URI, HTML 

Übertragungsprotokoll 

• HTTP, Hypertext Transfer Protocol 

Eindeutiger Zugriff auf Ressourcen 

• URI (Bezeichner), Uniform Resource 

Identifier 

• URL (Locator), ein URI 

Dokumentenformat 

• HTML, Hypertext Markup Language 

HTTP-Client (Web Browser) 

www.html 

Anfrage 

http://de.selfhtml.org/intro/ 

internet/www.html 

de.selfhtml.org 

Http-Server (Web Server) 

Antwort 


Dynamische Inhalte 

Statische Dokumente 

• Dokument liegt vorbereitet vor 

• Keine Personalisierung, keine 

zustandsabhängigen Seiten, keine 

Interaktion 

Dokumente dynamisch generieren 

• Erzeugen des Dokuments für die 

Antwort der Anfrage 

• Durch Ausführen eines Programms 

unter Berücksichtigung des Zustands 

• Programm-Ausgabe ist HTML 

Client/Server 

• Web-Server weiß wann was generiert 

wird und kommuniziert mit Programm 

• Web-Client (Browser) merkt davon 

nichts 

HTTP-Client (Web Browser) 

„dynamisch 

generiert“ 

Anfrage 

http://www.mi.hs-rm.de/portal/ 

www.mi.hs-rm.de 

Http-Server (Web Server) 

Konfiguration 

Konfiguration 

Antwort 






Dynamische Inhalte – Server 

Infrastruktur an der Hochschule 

Common Gateway Interface (CGI) 

• Einfache Integration, mit allen 

Programmen und Umgebungen 

möglich, meist Skriptsprachen 

• Aufruf eines externen Programms 

(separater Prozess) je Anfrage 

• Kommunikation über stdin/stdout und 

Umgebungsvariablen 

Integration in Web-Server 

• Programm und Ablaufumgebung 

(Interpreter) läuft im Web-Server 

• Effizienter, ein Prozess mehrere 

Anfragen 

Separater Container 

• Eng integriert mit HTTP-Server oder 

eigener HTTP-Server 

• Zusätzliche Dienste (Skalierung, 

Sicherheit, . . . ), Ablaufumgebung 

HTTP-Server 

Prozess 

HTTP-Server 

Prozess 

HTTP-Server 

HTTP-Server 

Container 



Dynamische Inhalte – Client 


Host 

Host 

Host 

Host: www.mi.hs-rm.de 

Web-Server: Apache, httpd 

• ˜ssinn001/public_html/ 

• Verfügbar als http.../˜ssinn001/ 

CGI-Programme 

• ˜ssinn001/public_html/cgi-bin/p.cgi 

• Verfügbar als CGI-Programm 

http.../˜ssinn001/cgi-bin/p.cgi 

• Nur in public_html/cgi-bin 

Integration in Web-Server, Python 

• Web Server Gateway Interface (WSGI) 

• Unter Apache Benutzerkennung 

• ˜ssinn001/public_html/wsgi/app.wsgi 

http.../˜ssinn001/wsgi/app.wsgi 

• Eine WSGI-Datei je App 

httpd (apache2) 

Prozess 

httpd (apache2) 

Prozess 

Prozess 

www 

login3 

mi12 

www 

login3 

mi12 



Common Gateway Interface 

Erzeugen dynamischer Web-Seiten auf dem Server – CGI 

Roundtrips Visualisierung 

Common Gateway Interface (CGI) 

• Problem: Jede Interaktion bedingt 

Server-Kommunikation, auch reine 

Visualisierung 

• Lösung 

• Skript (Javascript) im Web-Browser 

• Veränderung der Anzeige durch 

Manipulation des DOM 

Roundtrips Flackern, wenig Daten 

• Problem: Neuaufbau Seite bei 

Server-Zugriff (Usability), vorhandene 

Daten neu übertragen 

• Lösung 

• Skript (Javascript) im Web-Browser 

• Geänderte Daten nachladen und 

Aktualisieren Manipulation DOM 

• Daten asynchron über HTTP 

Beispiel 

Autocompletion 

HTML 

HTTP-Server 

XML(Daten) 

Asynchronuous Javascript and XML 

(AJAX) 

• In Veranstaltung nur Verwendung, 

nicht wie es funktioniert 

• Starten externer Programme zur 

Dokumentenerzeugung 

• Kommunikation über 

Umgebungsvariablen und 

Standardeingabe / Standardausgabe 

• Standardisiert 

Vorteil 

• Funktioniert in jeder Umgebung, mit 

jeder Programmiersprache 

• Darauf aufbauend alles realisierbar 

Nachteil 

• Ressourcen-intensiv, ein neuer 

Prozess je Anfrage 

• Keine weitergehenden Features 

Anfrage 

HTTP-Server 

Prozess 

Antwort 

Host 


Standardausgabe 







CGI-Programm in Python 

Ausgabe auf Standardausgabe 

• Erst Header, dann Content 

(HTTP-Protokoll) 

• Getrennt durch eine Leerzeile (Extra 

newline Zeile 2) 

HTTP-Header 

• Content-Type zwingend notwendig, 

meist text/html 

• Weitere Header-Zeilen möglich, 

werden meist von Web-Server ergänzt 

HTML-Dokument, Content 

• Einfach print auf Standardausgabe 

• Beliebiger Code 

Fehler: “Internal Server Error” 

• Vielleicht noch was im Log... 

hallo.cgi 

1 #!/usr/bin/python 

2 print "Content-Type: text/html\n" 

3 print "" 

4 print "Hallo" 


6 print "Hallo CGI Python" 


CGI Beispiel – Details 

Anfrage 

1 GET 

2 /~pbart001/cgi-bin/hallo.cgi 

3 HTTP/1.1 


1 SERVER_SOFTWARE=Apache/2.2.14 .... 

2 SCRIPT_NAME=/~pbart001/cgi-bin/hallo.cgi 

3 REQUEST_METHOD=GET 

4 SERVER_PROTOCOL=HTTP/1.1 

5 HTTP_CONNECTION=Keep-Alive 

6 REMOTE_ADDR=172.26.33.61 

7 SERVER_PORT=80 

8 SERVER_ADDR=195.72.105.32 

9 DOCUMENT_ROOT=/var/www/ 

10 HTTP_HOST=www 

11 GATEWAY_INTERFACE=CGI/1.1 

12 REMOTE_PORT=53197 

Antwort 

1 HTTP/1.1 200 OK 

2 Date: Mon, 04 Feb 2013 10:21:42 GMT 

3 Content-Encoding: gzip 

4 Connection: Keep-Alive 

5 Content-Length: 82 

6 Server: Apache/2.2.14 (Ubuntu) ... 

7 Vary: Accept-Encoding 

8 Content-Type: text/html 

9 Keep-Alive: timeout=15, max=100 

10 

11 ... 

Standardausgabe 

1 Content-Type: text/html 

2 

3 

4 Hallo 

5 

6 Hallo CGI Python 

7 







Komfortable CGI-Programmierung 


Python-Bibliothek 

• cgi Hilfsroutinen 

• cgitb (TraceBack), Ansicht 

Fehlermeldungen, sehr sinnvoll 

hallokomf.cgi 

Informationen in Umgebungsvariablen 

• Vom Web-Server, aus Anfrage 

• Vom Skript verwertbar 

Informationen – Anfrage 

• Anfragemethode, Query-String, . . . 


2 # immer gleich am Anfang 

Informationen – Infrastruktur 


4 import cgi, cgitb 

5 cgitb.enable() 

6 

7 # ab hier spezifisch je Skript 

8 fehler 






Fehler in Zeile 8 wird erkannt und 

entsprechend im Browser ausgegeben. 

Sehr hilfreich beim Programmieren. 

• Web-Browser, Web-Server, . . . 

env.cgi 





5 import os 

6 for key in os.environ: 

7 print key, "=", os.environ[key] 


Beispiel ohne HTML-Rahmen. Viele Browser können daraus immer noch 

etwas machen. Für Vorlesung ok, da man ansonsten zu viel Boilerplate-Code hat. 

Sie generieren immer korrektes HTML. 







Anfragemethode GET 

Anfragemethode GET – Query-String 

Uniform Resource Locator (URL) 

• Abruf einer Ressource 

• Beispiel-URL 

http://www/˜pbart001/cgi-bin/hallo.cgi 

• Protokoll: HTTP 

• Server: www(.mi.hs-rm.de) 

• Pfad: /˜pbart001/cgi-bin/hallo.cgi 

HTTP-Protokoll GET 

• GET /˜pbart001/cgi-bin/hallo.cgi HTTP/1.1 

• Methode GET 

• Ressource /˜pbart001/cgi-bin/hallo.cgi 

• HTTP Protokoll Version 1.1 

Im Web-Server verpacken 

• In Umgebungsvariablen 

• POST Inhalte in stdin 

Anfrage 

GET 

~pbart001/cgi-bin/hallo.cgi 

HTTP/1.1 

HTTP-Server 

Prozess 

Antwort 

Host 

REQUEST_METHOD = GET 

SERVER_PROTOCOL = HTTP/1.1 

REQUEST_URI = /~pbart001/cgi-bin/hallo.cgi 

Ziel 

• Übergabe von zusätzlichen 

Informationen an Web-Server 

• Nur die Anfrage (Query) betreffend 

Query-String – Anfrageparameter 

• String an die URL angehängt 

• Einleitendes ? 

• Schlüssel/Wert-Paare durch & getrennt 

• Kodierung: ohne Änderung 

[a-zA-Z0-9]|’.’|’-’|’˜’|’_’, 

Leerzeichen als +, %FF HEX sonst 

Query-String Integration bei CGI 

• Durch Umgebungsvariable 

• QUERY_STRING 

Einleitendes 

? 

?name=Tim&ende=ciao 

Schlüssel 

Wert 

name = Tim 

ende = ciao 

Trennendes 

& 







Query-String verwenden 

CGI-Bibliothek 

• Auslesen aus FieldStorage 

• Vorgefertigtes Aufbereiten 

querystring.cgi 





5 import os 

6 form = cgi.FieldStorage() # Aufbereiten 

7 name, ende = "noname", "EOF" 

8 if "name" in form: 

9 name = form["name"].value 

10 if "ende" in form: 

11 ende = form["ende"].value 

12 print "Hallo %s,%s" % (name, ende) 

13 print "%s" % os.environ["QUERY_STRING"] 

Ohne Query-String 

Query-String ?name=Tim&ende=ciao 

Formulare erzeugen Query-String 

Erzeugen Query-String mit 

-Tag 

• action-Attribut: (relative) 

Ziel-URL 

• method-Attribut: 

Anfrage-Methode, get (oder 

post) 

Eingabefelder mit -Tag 

• type-Attribut: Welches 

Eingabefeld 

• text: Text-Eingabefeld 

• submit: Knopf 

• . . . SelfHTML 

Erzeugter Query-String im Beispiel 

• name=Tim&ende=ciao&ok=Ok 

querystringform.html 

1 

2 

3 Name: 

4 Ende: 

5 

6 

7 






Formularelemente 

Parameter mit POST statt GET 

Formularelemente – Hausaufgabe 

POST statt GET 

• Philosophie: Daten schicken statt 

holen 

• Server-Zustand darf sich ändern 

• Wiederholte Anfragen können 

unterschiedliche Ergebnisse haben, 

Ergebnisse nicht cachen 

Eigenschaften POST 

• Verpacken auch in String aus 

Schlüssel/Wert-Paaren, aber 

• Größere Datenmengen möglich (GET 

auf 2 KByte beschränkt), auch 

Binärdaten (Bilder, etc.) 

• Nicht sichtbar in URL (nicht im 

Query-String) 

• Verschlüsselt bei HTTPS 

Änderung in HTML-, nicht in 

FieldStorage (ist für POST und GET) 

Weitergabe CGI über Standardeingabe 

1 

postparam.cgi 



3 import sys 

4 print sys.stdin.read() 

Wichtigste Formularelemente 

• Einzeiliges Eingabefeld 

• Einzeiliges Eingabefeld für Passwörter 

• Mehrzeiliges Eingabefeld 

• Mehrzeilige Auswahlliste 

• Dropdown-Box, einzeilige Auswahlliste 

• Radiobuttons 

• Check Box 

• Versteckte Eingabewerte 

• Aktion ausführen, Knopf/Button 

In SelfHTML nachlesen und ausprobieren 

• Namen/Werte setzen, vorbelegen, 

formatieren 

• http://de.selfhtml.org 

/html/formulare/index.htm 




Formularelemente 


Templating 

Formulare und Mehrfachauswahl 

Mehrfachauswahl 

• Derselbe Schlüssel mehrfach in 

Formular verwendet 

• Bei Radiobuttons natürlicherweise 

• Mehrere Ergebnisse in Parameter je 

Schlüssel möglich 

• Muss in Anwendungsprogramm 

berücksichtigt werden 

1 

2 

mehrfach.cgi 


3 C 

4 Java 

5 Python 

6 

7 

8 


3 import os, cgi 

4 

5 form = cgi.FieldStorage() 

6 for skill in form.getlist("skill"): 

7 print "Ich kann %s \n" % skill.capitalize() 

Erzeugen der Dokumente 

Dokumentenfragmente als String im Quellcode :-( 

• HTML im Quellcode nicht als Markup zu erkennen 

• Markup-Quelle ist nicht validierbar 

• Keine Tool-Unterstützung beim Editieren 

• Vermischen von Anwendungslogik und Präsentation 

Ziel 

• Trennen von Anwendungslogik und 

HTML-Präsentation 

• HTML-Präsentation auslagerbar 

• Anwendungslogik frei von Markup 

Ansatz – Templating 

• Server Pages Konzept 


2 typ = "Content-Type: " 

3 mime = "text/html" 

4 print typ+mime+"\n" 

5 








• Template-Engines 

Achtung: Art der Dokumentenerstellung unabhängig von 

technischer Integration (egal ob CGI oder proprietär) 







Server Pages Konzept 

Server Pages – Anwendungsgebiet 

hello.sp 

Server Pages 

• Einbettung von Skript-Code in 

Markup (HTML) 

• Zwischen speziellen Tags, 

z.B. oder 

• Verfügbar für viele Sprachen und 

Umgebungen 

Entwicklungssicht 

• Erstelle statische HTML-Seite 

• Spezieller Bereich “agiert dynamisch” 

Ausführungssicht 

• Übersetze HTML-Seite in Skript 

• HTML kopiert sich auf Ausgabe 

• Code bleibt erhalten 

• Führe entstehendes Skript aus 

1





Templating mit Python 

Einfachst-Templating eingebaut 

• Python Formatier-Operator % 

• Ersetzungsstelle in template durch 

%(name)s markieren 

• In Ersetzungs-Dictionary 

dic["name"] = wert setzen 

• Für mehrere Stellen und mehrere 

Name/Wert-Paare 

• Einsetzen mit template % dic 

Template-Engines 

• Reichlich vorhanden, ein paar 

Dutzende in 

http://wiki.python.org/moin/Templating 

• Mehr Features, zum Beispiel Iterieren 

• Uns reicht Einfachst-Templating 

tpage.tpl 

1 

2 %(title)s 

3 

4 %(title)s 

5 %(tablecontent)s 

6 

7 

tabline.tpl 

1 

2 %(first)s 

3 %(second)s 

4 

Templating mit Python – Beispiel 

Beispiel 

• Template-Dateien vollständig einlesen 

• Ersetze z.B. title durch Zeichen, zwei 

Mal, im Header und am Anfang der 

Seite 

• Typische letzte Zeile, vorher nie eine 

Ausgabe 

tplzeichen.cgi 



3 import cgi, cgitb, string 


5 

6 tabline = file("tabline.tpl").read() 

7 page = file("tpage.tpl").read() 

8 

9 lines = [] 

10 for c in string.lowercase: 

11 dic = {’first’ : c, 

12 ’second’ : c.upper()} 

13 lines.append(tabline%dic) 

14 

15 dic = {’title’: "Zeichen"} 

16 dic[’tablecontent’] = "\n".join(lines) 

17 

18 print page % dic 







Sichere Integration von Inhalten 

Komponenten zur Ansicht 

Korrekte/sichere Darstellung von Texten 

• Spezielle Regeln für Markup (HTML) 

müssen eingehalten werden (Aufgabe 

des Template-Autors) 

• Benutzerdefinierte Inhalte (potenziell 

böse) müssen integriert werden 

Probleme – böse Inhalte 

• Browserland ist Feindesland 

• Texte mit Sonderzeichen/Tags 

Vorgefertigte Funktionen verwenden 

• Beispiel “Quotieren” von Strings mit 

cgi.escape, Sonderzeichen und 

Tag-Zeichen () umwandeln 

• Einfügen von Skript-Code verhindert 

• Weiteres: Entfernen von Tags, . . . 


2 # -*- coding: utf-8 -*- 


4 import os, cgi 

5 lines = ["Hallo", "Hällo", "", " bold ", ’a " double quote’] 

6 for line in lines: 

7 print "%s " % line 

8 print 

9 for line in lines: 

10 print "%s " % cgi.escape(line, True) 

Hallo 

Hällo 

 

bold 

a " double quote 

Hallo 

Hällo 

<tag> 

 bold 

a " double quote 

Rendern von HTML beschränken 

• Manuelles Generieren von HTML 

unabhängig von Präsentationslogik 

• Reines Rendern (Generieren) von 

HTML unabhängig, wiederverwendbar 

realisieren 

Beispiel – Tabelle 



3 import cgi, cgitb, string 


5 

6 from tabelle import table 

7 

8 V,N,M = ’vorname’,’nachname’,’matnr’ 

9 keys = [(V, ’Vorname’), (N, ’Nachname’), (M, ’MatNr’)] 

10 data = [{V: ’Susi’, N: ’Sinnlos’, M: ’135789’}, 

11 {V: ’Rudi’, N: ’Ratlos’, M: ’222333’}, 

12 {V: ’WWW’, N: ’WickedWestWitch’, M: ’666666’}] 

13 ctable = table(keys, data) 

14 c = "Tabelle%s" % ctable 

15 print c 

1 # Markup nur konstant, auslagerbar/aenderbar 

2 _table = "\n%(header)s\n%(data)s\n\n" 

3 _row = "%s" 

4 _header = "%s" 

5 _entry = "%s" 

6 

7 def _rowformat(line, keys, wrap): 

8 entries = [wrap % line[t[0]] for t in keys] 

9 return _row % " ".join(entries) 

10 

11 def table(keys, data): 

12 dic = dict() 

13 hdict = {} 

14 for tup in keys: 

15 hdict[tup[0]] = tup[1] 

16 dic["header"] = _rowformat(hdict, keys, _header) 

17 rows = [_rowformat(line, keys, _entry) 

18 for line in data] 

19 dic["data"] = "\n".join(rows) 

20 return _table % dic 




Proprietäre Integration 



Vor- und Nachteile von CGI 

Vorteile 

• Einfach, standardisiert 

• Funktioniert immer, mit jeder Programmiersprache 

• Ausführung unter der eigenen Benutzerkennung 

Nachteile 

• Je Anfrage ein Prozess, Last 

• Lösungsansatz: FastCGI, mehrere Anfragen je 

Prozess, vermeidet Start der Ablaufumgebung 

• Lösungsansatz: Integration in Web-Server, meist 

proprietär, Interpreter/Runtime läuft im Web-Server, 

mehr Features möglich 

• Keine Trennung Anwendungslogik und 

Präsentationslogik erzwungen 

• Verleitet zu Spaghetti-Code (muss aber nicht sein) 

Einsatzgebiet 

• Einfache Anwendungen 

mit wenigen 

dynamischen Seiten 

• Darstellung und 

Eingabe von 

strukturierten Daten 

• Einfache 

Wiederverwendung von 

vorhandenem 

Anwendungs-Code 

Beispiele 

• Bugzilla, Bugtracking 

Tool, Perl 

• MoinMoin, Wiki, Python 

• . . . 


Integration von Python in Web-Server – WSGI 

Ziele 

• Integration so einfach wie CGI 

• Kein neuer Interpreter je Aufruf, ein 

Prozess für mehrere Anfragen 

• Unabhängig vom Web-Framework 

Web Server Gateway Interface (WSGI) 

• Python-Schnittstelle zur Integration in 

Web-Server, Teil der 

Standardbibliothek 

• Gut dokumentiert, PEP-0333 (2003) 

• Akzeptiert: Von (fast) allen 

Frameworks und Http-Servern 

unterstützt www.wsgi.org 

mod_wsgi für Apache-Integration 

• code.google.com/p/modwsgi/ 

• Proprietäre effiziente Integration 

HTTP-Server 

WSGI 

Python-Prozess 


Apache-HTTP-Server 

mod_wsgi 

(WSGI-Gateway) 

WSGI-Protokoll 







Ablauf – WSGI im Web-Server 

WSGI 

Anfrage von Client im Web-Server 

• Skript jetzt.wsgi wird verwendet 

• Warum konfigurierbar (kommt noch), 

zum Beispiel anhand von Dateiname 

Übergabe an Python Prozess/Interpreter 

• Nur bei erstem Aufruf 

• Python soll Modul jetzt importieren 

• Python übersetzt Modul in Byte-Code 

und lädt Modul 

• Bei jedem Aufruf 

• Konfigurierte Funktion wird gerufen 

(zum Beispiel application) 

• Iterieren über Funktionsergebnis ist 

Ergebnisseite 

Gut für Betrieb, aber bei Entwicklung 

zunächst kein Neuladen bei Änderung 

Python 

Bytecode 

Apache-HTTP-Server 

mod_wsgi 

(WSGI-Gateway) 


Importieren,1x 

Übersetzen, 

1x 

Funktionsaufruf, 

jedes Mal 

Python 

Quellcode 

HTTP-Server mit WSGI liefert 

• environ Umgebungsvariablen 

• start_response Antwort-Funktion 

HTTP-Server mit WSGI erwartet 

• Eine Funktion 

• Params (environ, start_response) 

• Aufruf von start_response mit 

• status: HTTP Status, meist 200 OK 

• header: Liste von Schlüssel/Wert- 

Tupeln, zum Beispiel mit 

("Content-Type", "text/html") 

• Rückgabe ein iterierbares Objekt aus 

dem Dokument erzeugt wird 

Beispiel 

• jetzt.wsgi, aktuelles Datum/Uhrzeit 

jetzt.wsgi 

1 import datetime 

2 page = "%s" 

3 def app(environ, start_response): 

4 today=str(datetime.datetime.today()) 

5 header=[("Content-Type","text/html")] 

6 start_response("200 OK", header) 

7 return [page % today] 

8 

9 application = app # mod_wsgi 

WSGI und Apache 

• mod_wsgi 

• Erwartet den Namen application 







URL auf WSGI-Skript abbilden 

Je nach URL andere Seiten erzeugen 

url.wsgi 

Abbildung bei CGI/WSGI 

• Konfiguration Web-Server 

• Meist automatische Assoziation von 

Skriptname im Pfad auf Skript 

URL-Mapping 

• Üblich bei statischen Inhalten: 

Assoziation zwischen Dateipfad und 

Zugriffspfad in URL 


2 rurl = environ["PATH_INFO"] 

3 page = "Rest-URL: %s" % rurl 



6 return [page] 

• Eingeschränkt auf spezifisches 

Unterverzeichnis cgi-bin bzw. wsgi 

unterhalb von public_html mit 

Endung .cgi bzw. .wsgi 

• Assoziation abhängig von der 

Konfiguration des Http-Servers 

• Bei Anwendungen meist alles, bis auf 

statische Dateien, auf ein Skript 

7 


• Achtung: Pfadangabe nach 

Skriptname möglich (und sinnvoll) 

• (Rest-)URL kann verwendet werden 

um andere Seiten zu generieren 

Im Produktivbetrieb nicht sichtbar 

Konfiguration an Hochschule 

• Web-Server Konfiguration (z.B. 

Apache mod_rewrite), alle Anfragen 

auf ein Skript, sinnvoll 

• Hochschule: Angabe von Skript 

http://www.mi.hs-rm.de/ 

˜ssinn001/wsgi/jetzt.wsgi 

• Skriptname unterhalb von 

public_html/wsgi mit Endung .wsgi 

• Alles “darunter” auch! URL darf weiter 

gehen 

Bei cgi gleiches Verhalten 

Mapping: Je nach URL andere Funktion 







GET Anfragen mit WSGI 

POST-Anfragen mit WSGI 

get.wsgi 

postparam.wsgi 

GET Anfragen mit WSGI 

• Zugriff auf Query-String wie bei cgi, 

parse_qs auch bei cgi 

• parse_qs liefert Dict. aus Inhalten des 

Query-Strings, Achtung: Liste als 

Wert, da mehrere Einträge erlaubt sind 

• Abhängig von Query-String Inhalten 

unterschiedliche Seiten generieren 

1 from urlparse import parse_qs 

2 def application(environ, start_response): 

3 query=parse_qs(environ[’QUERY_STRING’]) 

4 content = "Bye" 

5 if "hi" in query: 

6 content = hi(query) 



9 return [content] 

10 def hi(query): 

11 name = "niemand" 

12 if "name" in query: 

13 name = "".join(query["name"]) 

14 return "Hallo, %s\n" % name 

Rückrichtung mit urllib.urlencode 

• Folge von Schlüssel/Wert-Paaren als 

ein Query-String kodieren 

• Tupel können Sonderzeichen 

enthalten, die encodiert werden 

• Leerzeichen als +, & als %26 

• %XY generische Kodierung 


POST Anfragen mit WSGI 

• Änderung Formular für POST 

 

• Zugriff auf Query-String durch Lesen 

des Eingabestroms 

• Verarbeiten wie bei GET mit parse_qs 

1 from urlparse import parse_qs 

2 


4 name, ende = ["niemand"], ["None"] 

5 post = environ[’wsgi.input’].read() 

6 dic = parse_qs(post) 

7 if "name" in dic: name = dic["name"] 

8 if "ende" in dic: ende = dic["ende"] 

9 tup = (name[0], ende[0]) 

10 content = "Hallo %s, %s" % tup 



13 return [content] 

14 







Lokale WSGI-Umgebung zur Entwicklung 

Entwicklung 

• Integration in HTTP-Server 

(Container) kompliziert und für 

Entwicklung nicht notwendig 

• Einfacher HTTP-Server Teil der 

Python Standardbibliothek 

• Nutzung mit Paket wsgiref 

Paket wsgiref 

• Referenzimpl. von wsgi 

• simpleserver für Entwicklung 

• make_server erstellt 

HTTP-Server mit 

WSGI-Anwendung 

• Servername: localhost 

• Port (beliebig): 8080 

• app: WSGI-Anwendung 

envwsgiref.wsgi 


2 

3 def app(env, start_response): 


5 content = ["%s: %s " % (k,env[k]) for k in env] 


7 return content 

8 

10 

9 application=app 

11 if __name__ == ’__main__’: 

12 from wsgiref.simple_server import make_server 

13 httpd = make_server(’localhost’, 8080, app) 

14 httpd.serve_forever() 

mod_wsgi Kompatibilität 

• app in application umbenennen 

• if: Anwendung mit mod_wsgi im Apache und 

wsgiref lokal ausführbar 

Benutzung wsgiref 

Starten als lokales Python Programm 

• python envwsgiref.wsgi 

• Endung .wsgi nur für mod_python, 

sonst auch .py möglich 

• Log-Ausgabe je Anfrage auf Konsole 

Benutzung mit IDEs 

• Idle, Emacs oder Eclipse (PyDev) 

• Debugging unterstützt, einfach 

Breakpoint in Anwendung setzen und 

mit Browser auf Anwendung zugreifen 

• PyDev 

• Endung muss .py sein 

• Separate .wsgi-Datei, importiert nur 

application-Objekt 

• Beispiel env2.py und env2.wsgi 

• Testen mit env2.py 

env2.wsgi 


2 import sys, os 

3 sys.path.append(os.path.dirname(__file__)) 

4 os.chdir(os.path.dirname(__file__)) 

5 from env2 import application 






werkzeug 

pydev – Python mit Eclipse 

Abstraktion von der dokumentenbasierten Web-Schnittstelle 

PyDev 

Web-Anwendung 

Abstraktion bei Web-Frameworks 

• pydev.org 

• Eclipse-Plugin, über 

Eclipse-Marketplace 

verfügbar und von 

jedem selbst zu 

installieren 

• Vor Start einmal 

Python-Interpreter 

setzen 

Python-Entwicklung 

• Completion 

• Debugging 

• Subversion 

• . . . 

Im Praktikum Idle oder Eclipse mit PyDev verwenden 

(oder natürlich Emacs). 


• Anfrage erzeugt Antwort, 

Textdokumente 

• Kommunikation in Anwendung hinein 

• Schlüssel/Wert-Paare 

• der Eingabestrom 

• Kommunikat. von Anwendung heraus 

• Schlüssel/Wert-Paare 

• (HTML-)Dokument 

Viele Konventionen: 

• → REQUEST_METHOD: GET 

bei GET-Anfrage 

• ← Content-Type: text/html 

bei HTML-Dokument als Antwort 

• . . . 

Nicht komfortabel 

• Request-Objekt, Response-Objekt; 

kapselt Anfrage, Antwort 

• Zugriff über Request-Objekt auf 

Eigenschaften der Anfrage, z.B. 

(Query)-Parameter, . . . 

• Verändern des Response-Objekt um 

dann Text-Antwort zu erzeugen, z.B. 

Typ setzen 

Web-Abstraktion/Frameworks in Python 

• werkzeug, einfache WSGI-Abstraktion, 

verwenden wir 

• Alternative webob, nur Req.-/Resp. 

• django, Full-Stack Framework (sehr 

schön, aber zu Lehrzwecken zu groß 

und zu stark abstrahiert) 

Prof. Dr. Peter Barth (HS-RheinMain) Web-basierte Anwendungen • . . . 

24. April 2013 44 / 91


werkzeug 


werkzeug 

Abstraktion mit werkzeug 

werkzeug Entwicklung 

werkzeug 

• Weit verbreitete WSGI-Abstraktion, 

noch kein Web-Framework 

• Python-Bibliothek 

Features 

• Request/Response Objekte 

• URL-Routing, welche Funktion für 

welche URL 

• Cookies, Sessions, . . . 

• Entwicklungsunterstützung: 

automatisches Neuladen, Tracebacks 

Einfaches Beispiel: 

werkzeug.pocoo.org/docs/quickstart 

(Tutorial passt nicht) 

werkzeug.pocoo.org 

1 from werkzeug.wrappers import Request, Response 

2 


4 request = Request(environ) 

5 name = request.args.get("name", "Welt") 

6 response = Response("Hallo %s" % name) 

7 response.content_type="text/html" 

8 return response(environ, start_response) 

9 



12 httpd = make_server(’localhost’, 8080, app) 


Request/Response häufig gebraucht 

• @Request.application eine Abkürzung 

• Nur noch ein Parameter, request 

• Neue Instanz von Response zurück 

werkzeug.serving, run_simple 

• Reloader: Bei Änderung der 

Quelldatei wird automatisch die 

Quell-Datei neu geladen; kein 

Neustart mehr notwendig 

• Debugger 

• Aussagekräftige Fehlermeldung 

• Cool: Interaktive Konsole im Browser 

• Nachteil: Debugger (Eclipse) 

funktioniert nicht mehr 

• Beides verwenden je nach Bedarf 

• Eclipse: use_reloader=False 


2 @Request.application 

3 def app(request): 

4 name = request.args.get("name", "Welt") 

5 fehler 

6 return Response("Hallo %s" % name) 


8 from werkzeug.serving import run_simple 

9 run_simple(’localhost’, 8080, app, 

10 use_reloader=True, use_debugger=True) 




werkzeug 


werkzeug 

Standard WSGI-Rahmen 

Request-Objekt 

Für Deployment in Apache; für Entwicklung mit Debugging in Eclipse oder Entwicklung 

mit Traceback und Debug-Konsole im Browser 

webapp.wsgi 


2 # -*- coding: utf-8 -*- 

3 import sys, os 

4 sys.path.append(os.path.dirname(__file__)) 

5 if os.path.dirname(__file__): 

6 os.chdir(os.path.dirname(__file__)) 

7 from webapp import application 

8 

9 # Für Eclipse ab hier noch in webapp.py (Syntax-Highlighting, run) 

10 RUN_WERKZEUG=1 # oder 0 für wsgi_ref.simple_server 


12 if RUN_WERKZEUG: 

13 from werkzeug.serving import run_simple 

14 run_simple(’localhost’, 8080, application, 

15 use_reloader=True, use_debugger=True) 

16 else: 


18 httpd = make_server(’localhost’, 8080, application) 


Request-Objekt 

• request = Request(environ) (oder Parameter) 

• Erzeugt aus Umgebungsvariablen 

• Nur lesbar 

Attribute, Methoden: 

• Dokumentation: 

werkzeug.pocoo.org/docs/wrappers 

• method: GET, POST, . . . 

• args: Dictionary aus Query-String (GET) 

• form: Dictionary aus Formulareingaben (POST) 

• values: kombiniert args und form 

• url(base_url): URL (ohne Query-String) 

• path: Angefragter Pfad 

• environ: Die Original-Umgebungsvar. 

Web-Anwendung definiert application, z.B. in Modul webapp(.py) 




werkzeug 


Routing 

Response-Objekt 

Routing – Welche Seite soll angezeigt werden? 

Response-Objekt 

Web-Anwendung 

Beispiel: Apache Web-Server Hochschule 

• response = Response(); ... ; 

return response(environ, start_response) 

(oder return response) 

• Optional Inhalts-String 

• Veränderbar, auch Liste als Inhalt 

Attribute, Methoden: 

• Dokumentation: 

werkzeug.pocoo.org/docs/wrappers 

• Iterable als Content (im Beispiel Liste) 

• status, status_code: HTTP-Status 

• headers: HTTP-Header 

• automatically_set_content_length: 

Größe (HTTP/1.1 offene Verbindung!) 

• charset: ’utf-8’ 


2 



5 c = [] 

6 response = Response(c) 

7 c.append("content modifiable\n") 

8 response.status = "200 OK" 

9 response.status_code = 200 

10 c.append("response.headers:\n") 

11 hs = response.headers 

12 for k in hs.keys(): 

13 s=" %s: %s\n" % (k, hs[k]) 

14 c.append(s) 

15 response.automatically_set_content_length = True 

16 return response 

Mehr mit Mixins; Dokumentation 

• Mehrere “Seiten” (Formulare) 

• Nicht nur angepasst, sondern andere 

Aufgabe (Produkt vs. Warenkorb) 

• Je nach Anfrage (Routing) und 

Zustand der Anwendung wird eine 

andere Seite ausgewählt 


• Statische Seiten/Inhalte: Abbildung 

von Pfad in URL und Dateiname in 

Ordnerhierarchie (z.B. index.html, 

/static/style.css) 

• Dynamisch: Abbildung von Pfad in 

URL auf inhaltsgenerierende 

Funktionalität (Skript) 

• von /˜/... auf 

user/public_html/... (unter anderem 

statische Inhalte wie Bilder, HTML-Seiten, 

Style-Sheets, JavaScript-Dateien, . . . ) 

• von / /cgi-bin/.cgi/* auf 

CGI-Skript 

/˜user/public_html/cgi-bin/.cgi 

• von /˜/wsgi/.wsgi/* auf 

Python-Skript 

/˜user/public_html/wsgi/.wsgi 

• von allem mit Endung * .php auf 

eingebetteten PHP-Interpreter 







Routing Beispiel – Statische Inhalte mit WSGI 

Optionen Code-Organisation 

Statische Inhalte 

• Statische Inhalte (Assets wie Bilder, 

Style-Sheets) müssen in 

Web-Anwendung zur Verfügung 

gestellt werden 

• In Produktiv-Umgebungen häufig 

separater Server und separate URL, 

bzw. Apache speziell konfiguriert 

• Während Entwicklung mühselig 

• Ziel: statische Inhalte während 

Entwicklung 

Beispiel: Einfaches statisches Routing 

• Wenn URL mit /static/ beginnt, 

dann einfach nur Inhalt wiedergeben 

• Ansonsten mit application 

weitermachen 


2 import datetime, os 

3 page = """Es ist %(uhr)s Uhr 

4 """ 

5 


7 def application(request): 

8 if request.path.startswith("/statisch"): 

9 return statisch(request) 

10 n = datetime.datetime.now() 

11 uhr="%02d:%02d:%02d"%(n.hour,n.minute,n.second) 

12 c = page % {’uhr’: uhr} 

13 return Response(c, content_type="text/html") 

14 def statisch(request): 

15 base = os.path.dirname(__file__) 

16 # fuehrendes / bei path wegmachen 

17 asset_fname = os.path.join(base, request.path[1:]) 

18 asset = file(asset_fname).read() 

19 return Response(asset) 

Eine Python-Funktion je Seite 

• Klassisches Dispatching 

• Mappen Anfrage auf Funktion 

• Meist auf Basis der URL, geht auch 

auf Grund des Zustands 

Eine Python-Funktion für alles 

• Ein Python-Funktion generiert alles 

• Je nach Bedarf spezifisch Content 

(durch Funktionsaufrufe) generieren 

Kombiniert 

• application-Objekt von WSGI als “ein 

Skript für alles”, einfache API 

• Darin Dispatcher um unterschiedliche 

Seiten zu generieren 

routing.py 


2 product_page = """%(name)s sind toll""" 

3 def product(request, name): 

4 return product_page % {’name’: name} 

5 service_page = """Wir kuemmern uns um %(name)s""" 

6 def service(request, name): 

7 return service_page % {’name’: name} 



10 name = "ACME Luftgitarren" 

11 if request.path.startswith("/product"): 

12 c = product(request, name) 

13 elif request.path.startswith("/service"): 

14 c = service(request, name) 

15 else: 

16 c = "nicht verfuegbar" 

17 return Response(c) 







Einfache Routing-Abstraktion 

Abbildung URL-Anfang auf Funktion 

• Falls URL mit Schlüssel beginnt, dann 

auf passende Funktion weiterleiten 

• Vorbelegen von Funktionsparametern 

möglich, nur ein Parameter (request) 

erwartet 

Mächtigere Alternativen in Frameworks 

• URL-Matcher – wann passt eine URL 

auf ein Pattern 

• Übernahme von Parametern aus URL 

und Typkonvertierung automatisch 

• Ausgefeilte Regelwerke und 

Konfigurationsmöglichkeiten 

• Beispiel: werkzeug 

werkzeug.pocoo.org/docs/routing 

(brauchen wir nicht) 


2 from routing import product, service 

3 

4 name = "ACME Luftgitarren" 

5 url_map = { 

6 ’/product/’: lambda req: product(req, name), 

7 ’/service/’: lambda req: service(req, name), 

8 # None default 

9 None: lambda req: product(req, name) 

10 } 

11 

12 



15 for key in url_map: 

16 if key and request.path.startswith(key): 

17 return Response(url_map[key](request)) 

18 return Response(url_map[None](request)) 

Hinweis: Abbildung sollte eindeutig sein, sonst 

ist Reihenfolge nicht definiert 


Struktur Programmlogik 

Hinweise 

• Trennen HTML und Code, durch 

Einsatz von Templating erledigt 

• Einsatz von Funktionen und Objekten 

für die Programmlogik 

• Ausgabe (Generieren HTML) meiden 

• Ausnahme für dynamische Strukturen 

(Listen, Tabellen) da mächtigere 

Templatesprache/Controls fehlen 

• Strikte Reihenfolge einhalten 

Reihenfolge 

• Programmzustand wiederherstellen 

(Auswertung Eingabe, Z13) 

• Berechnung neuer Zustand 

(Funktionalität Z15–Z18) 

• Ausgabe (Templating und 

Ausgaberoutinen Z20–Z21) 


2 

3 page = """Zaehler 

4 %(zahl)d 

5 

6 

7 

8 """ 

9 



12 

13 zahl = int(request.form.get("zahl", "0")) 

14 if request.form.get("up", None): 

15 zahl += 1 

16 elif request.form.get("down", None): 

17 zahl -= 1 

18 

19 c = page % {’zahl’ : zahl} 




Zustandsverwaltung über Anfrage hinaus 



Lebensdauer Daten über Anfragen hinaus 

Bisher Daten nur aus der Anfrage 

• Kein Zustand in der Anwendung 

• Daten nur in der Anfrage vorhanden 

• Eigentlich kein Anwendungskontext 

• Erste Ausnahme: Zähler zahl 

Anwendungskontext 

• Satz von Variable/Wert-Paaren 

Gültigkeitsbereiche 

• Anwendung: Für alle gleich, für die 

Lebensdauer der Anwendung, 

Beispiel: Klick-Zähler 

• Session: Für jeden Anwender 

unterschiedlich, für eine Folge von 

Interaktionen eines Anwenders 

(Session) gleich, Beispiel: Warenkorb 

Lebensdauer Daten 

• Block 

• Programmiersprachenebene, {} 

• Lokale Variablen 

• Nicht spezifisch für Web 

• Während einer Anfrage 

• Für Dauer Bearbeitung einer Anfrage 

• In Prog.sprache Attribute des 

request- Objekts, 

nicht globale Variablen 

• Session 

• Interaktionsfolge eines Anwenders 

• In Prog.sprache nicht abgebildet 

• Meist Speicher oder Dateisystem 

• Anwendung 

• Über Session hinaus 

• In Prog.sprache nicht abgebildet 

• Meist persistent (Dateisystem, DBMS) 


Sessions 

Session 

• im Mehrbenutzerbetrieb 

• mehrere Interaktionen 

• je Benutzer 

• im gleichen Anwendungskontext 

(bestehend aus Daten) 

Welche Daten, Beispiele 

• Benutzerdaten, Einstellungen, 

Optionen, Einkaufskorb . . . 

Problem 

• HTTP-Protokoll ist zustandslos, 

Request/Response 

• Keine Daten der letzten Anfrage in 

aktueller Anfrage 

Lösung – Explizite Session-Verwaltung 


• Kontext-Daten manuell verwalten 

• Ablage: Client (Browser) oder Server 






Anwendungskontext im Client 

Kontext im Client – Formulare 

Anwendungskontext im Web-Browser 

• Manuelle Weitergabe des Kontextes 

von Seite zu Seite 

• Techniken: Formulare (GET/POST), 

Cookies 

Vorteile 

• Keine Belastung des Servers 

(Datenhaltung) 

• Keine eindeutige Zuordnung zu 

Server-Session notwendig 

Nachteile 

• Datenübertragung je Anfrage 

• Anfällig gegenüber Manipulationen 

• Abhängig von Web-Client 

• Garantie Persistenz schwierig 

Formulare als Träger des 

Anwendungskontextes 

• Verstecke Formularfelder 

 

• Alle Schlüssel/Wert-Paare 

Weitergabe Anfrage 

• POST: Datenstrom in Anfrage 

• GET: Query-String in Anfrage 

(sichtbar) 

Auswertung/Wiederherstellung 

• Automatisch: request.form/args 


2 import cgi 

3 _hidden = ’’ 

5 

6 def render_context(context): 

7 entries = [] 

8 for k,v in context.iteritems(): 

9 v = cgi.escape(unicode(v), True) 

10 entry = _hidden % {’key’: k, ’value’: v} 

11 entries.append(entry) 

12 return "\n".join(entries) 

13 



16 ctx, args = {}, request.args 

17 ctx[’a’] = args[’a’] if ’a’ in args else ’A’ 

18 ctx[’b’] = args[’b’] if ’b’ in args else ’B’ 

19 ctx[’z’] = int(args[’z’]) if ’z’ in args else 0 

20 ctx[’z’] += 17 

21 f =’%s’ 

23 c = f % render_context(ctx) 

24 for k, v in ctx.iteritems(): 

25 c += "%s: %s\n" % (k, v) 








Kontext im Client – Generiertes Formular 

Cookies 

Generiertes Formular 

• Verstecke Eingabefelder für 

Schlüssel/Wert-Paare 

• name als Schlüssel 

• value als Wert 

• Werden automatisch durch Formular 

submit übertragen 

• Formular selbst hat keine sichtbaren 

Elemente außer dem Knopf 

1 

2 

3 

4 

5 

6 

7 a: A 

8 b: B 

9 z: 17 

Ziel – Lokale Datenablage 

• Daten im Browser speichern 

• Über Neustart des Browsers 

• Verwaltet durch Browser 

• Server setzt, Browser sendet 

automatisch zurück 

• Missbrauch, Ad-Tracking 

Cookies 

• Namen: beliebig, max. 300 Cookies 

• Wert: max. 4KB/Cookie (inkl. Namen) 

• Verfallsdatum (Expires): Nach 

Verfallsdatum ungültig, wird gelöscht 

• Domain (Pfad): Nur an diese Domain, 

max. 20 Cookies je Server/Domain 

• secure: nur wenn gesichert übertragen 







Cookies – Übertragung 

Cookies setzen und lesen 

setcookie.cgi 

Übertragung – HTTP, RFC 2109/6265 

Manuell – CGI 


• Teil des HTTP-Headers 

• Set-Cookie: =, 

Cookie: = 

• PATH= 

• Header Set-Cookie 

• Auslesen aus Umgebungsvariable 

HTTP_COOKIE 

• Inhalt sind Schlüssel=Wert Paare 

2 from datetime import datetime 

3 print "Set-Cookie: jetzt="+ str(datetime.now()) 




7 import os 

8 print "Cookie is: "+str(os.environ["HTTP_COOKIE"]) 

• SECURE (optional) 

Mit Standardbibliothek 

• URL-encodiert (cgi.escape), %FF 

• Cookies auf dem Server mit Cookie 

Ablauf – Beispiel 

• Server schickt Set-Cookie-Header als 

Teil der Antwort auf eine Anfrage 

• Ab da schickt der Browser immer 

wieder das Cookie in der Anfrage mit 

Cookie-Header 

• Mehrere Cookies in dem einen 

Header-Feld 


• Cookie.SimpleCookie als einfache 

Abstraktion 

• Schreiben und Lesen 

• Mehrere Schlüsselwert-Paare im 

Beispiel 

Set-Cookie: jetzt="2013-03-11 

19:52:47.505760"; Path=/ 

• Löschen: Leerer Inhalt und 

überschrittenes Verfallsdatum 


2 from datetime import datetime 

3 import os, cgi, Cookie 

4 cookie = Cookie.SimpleCookie() 

5 cookie["jetzt"] = str(datetime.now()) 

6 cookie["jetzt"]["path"] = "/" 

7 print cookie.output() 


9 rc = Cookie.SimpleCookie(os.environ["HTTP_COOKIE"]) 

10 print "Cookie is: "+rc["jetzt"].value 

11 print cookie.output() 






Kontext im Client – Cookies 

Kontext im Client – Sichere Cookies 

Cookie als Träger des 

Anwendungskontextes 

• Schlüssel/Wert-Paare in Cookies 

• Alternativ zusammenpacken als 

Query-String in einem Cookie möglich 

Weitergabe zum Browser 

• set_cookie 

• Automatisch, über Header 

Auswertung/Wiederherstellung 

• Mit request.cookies 


2 import cgi, Cookie 

3 

4 def render_context(content, context): 

5 response = Response(content, 

6 content_type="text/html") 

7 for k,v in context.iteritems(): 

8 v = cgi.escape(unicode(v), True) 

9 response.set_cookie(k, v) 


11 



14 ctx, args = {}, request.args 

15 ctx[’a’] = args[’a’] if ’a’ in args else ’A’ 

16 ctx[’b’] = args[’b’] if ’b’ in args else ’B’ 

17 ctx[’z’] = int(args[’z’]) if ’z’ in args else 0 

18 ctx[’z’] += 17 

19 c = [] 

20 response = render_context(c, ctx) 

21 c.append(’’) 

23 c.append(’’) 

24 for k,v in request.cookies.iteritems(): 

25 c.append("%s: %s\n" % (k, v)) 


Verschlüsseln der Daten auf dem Client 

• Schwierig zu lesen, schwierig zu 

manipulieren 

• Einfache Sicherung von Manipulation: 

Fingerabdruck 

Verhindern von Manipulationen 

• Wenn Daten verändert wurden, dann 

stimmt der “Fingerabdruck” der Daten 

nicht mehr 

• Standardalgorithmus SHA1 

• Eingabe ist beliebiger String (Zahl) 

• Ergebnis ist ein 160-Bit 

Message-Digest (meist als Hex-String 

dargestellt) 

Python und SHA1 

• hashlib.sha1(message).hexdigest() 

RFC 3174 “ The SHA-1 is called secure 

because it is computationally infeasible to 

find a message which corresponds to a 

given message digest, or to find two 

different messages which produce the 

same message digest. Any change to a 

message in transit will, with very high 

probability, result in a different message 

digest, and the signature will fail to verify.” 

Geheimes Salz 

• Nachricht muss (teilweise) geheim 

sein, sonst kann Digest berechnet 

werden 

• Lösung: Hinzufügen eines geheimen 

“Salzes” (Salt), ein beliebiger String 

a99219f952208c68c30cb4a99cf9d7902e395702 







Kontext im Client – Sichere Cookies, Beispiel 

Kontext im Client – Sichere Cookies, werkzeug 

ctxlib.py 

1 import urllib, hashlib, urlparse 

2 

3 SALT="secret" 

4 CONTEXT, FP = "context", "fingerprint" 

5 def render_context(response, context): 

6 ctx = urllib.urlencode(context) 

7 response.set_cookie(CONTEXT, ctx) 

8 fp = hashlib.sha1(ctx+SALT).hexdigest() 

9 response.set_cookie(FP, fp) 

10 

11 def restore_context(request): 

12 if CONTEXT not in request.cookies: 

13 return {} 

14 if FP not in request.cookies: 

15 raise Exception("Security Error") 

16 ctx = request.cookies[CONTEXT] 

17 fp = hashlib.sha1(ctx+SALT).hexdigest() 

18 if fp != request.cookies[FP]: 


20 ret = urlparse.parse_qs(ctx) 

21 for k in ret: # nur ein Wert 

22 ret[k] = "".join(ret[k]) 

23 return ret 


2 import cgi, Cookie, ctxlib 

3 

4 form = """""" 

6 



9 ctx = ctxlib.restore_context(request) 

10 if ’a’ not in ctx: # uninitialisiert 

11 ctx[’a’], ctx[’b’] = ’A’, ’B’ 

12 ctx[’z’] = ’0’ 

13 c = [form] 

14 for k,v in ctx.iteritems(): 

15 c.append("%s: %s\n" % (k, "".join(v))) 

16 ctx[’z’] = int(ctx[’z’]) # Typkonversion 

17 ctx[’z’] += 17 # Zustandsfortschritt 

18 response = Response(c,content_type="text/html") 

19 ctxlib.render_context(response, ctx) 


SecureCookie in werkzeug 

• Teil der Erweiterungen 

• Verfolgt vorgestelltes Prinzip 

• Leeres Dictionary bei Manipulation 

ctxlibwerkzeug.py 

1 import werkzeug.contrib.securecookie as sc 

2 

3 SALT="secret" 

4 CONTEXT="context" 

5 def render_context(response, ctx): 

6 scs = sc.SecureCookie(ctx, SALT).serialize() 

7 response.set_cookie(CONTEXT, scs) 

8 

9 def restore_context(request): 

10 if CONTEXT not in request.cookies: 

11 return {} 

12 scs = request.cookies[CONTEXT] 

13 ctx = sc.SecureCookie.unserialize(scs, SALT) 

14 if not ctx: 


16 return ctx 


2 import cgi, Cookie, ctxlibwerkzeug as ctxlib 

3 

4 form = """""" 

6 



9 ctx = ctxlib.restore_context(request) 

10 if ’a’ not in ctx: # uninitialisiert 

11 ctx[’a’], ctx[’b’] = ’A’, ’B’ 

12 ctx[’z’] = 0 

13 c = [form] 

14 for k,v in ctx.iteritems(): # Typ bleibt int 

15 c.append("%s:%s\n"%(k,"".join(str(v)))) 

16 # keine Typkonversion mehr notwendig 

17 ctx[’z’] += 17 # Zustandsfortschritt 

18 response = Response(c,content_type="text/html") 

19 ctxlib.render_context(response, ctx) 


• Serialisierung nicht als Querystring, 

default pickle 

• Typinformation bleibt erhalten 







Anwendungskontext im Server 

Session-Identifikation im Web-Browser 

Verwalten des Anwendungskontextes in 

der Web-Anwendung im Server 

• Ein Datensaz je Session 

• Session-Identifikation über Browser 

notwendig 

Vorteile 

• HTTP ist zustandslos 

• Unabhängig(er) von Client 

• Schwieriger zu manipulieren 

• Persistenz 

Nachteile 

• Hohe Belastung des Servers 

• Session-Zuordnung trotzdem 

notwendig im Browser 

• Session-Id 

Session-ID 



Session-Identifikation (Session-ID) 

• Ein eineindeutiger Bezeichner je 

Session 

• Nicht vorhersagbar 

• IP-Adresse, Benutzerkennung und Zeit 

weder ausreichend noch hinreichend 

• Internet-Café, anonymer 

Mehrbenutzerbetrieb 

• Dynamisches Ändern der IP-Adresse 

• Meist Hash einer Zufallszahl plus 

IP-Adresse (99,9...%-Lösung) 

Verwalten der Session-ID 

• Bevorzugt im Cookie 

• Oft optional im GET-String 

• Falls Cookie verboten 

• Navigation mit location: geht schief 

(und ist verboten!) 

Session-ID in Python erzeugen 

• import uuid, OpenSSL 

r = OpenSSL.rand.bytes(16) 

sessionid = uuid.UUID(bytes=r) 

#38e9aa97-fe49-2ea2-4d92-4aa0369942a0 

• “Gute” Zufallszahl 

• Ausreichend eindeutig 






Session-Verwaltung auf Server 

Session-Verwaltung auf Server mit Python 

Zusammenspiel Session-ID und Kontext 

Anwendungskontext Verwendung 

• Inhalte des Anwendungskontextes 

werden auf Server gehalten 

• Assoziation von Session-ID mit 


• Session-Objekte, Middleware 

• Middleware entscheidet über Ort und 

Art der Speicherung 

Session-ID 

Datenhaltung auf Server, Alternativen 

• Hauptspeicher/Prozesskontext: Bei 

CGI/WSGI nicht (einfach) möglich, 

Zuordnung Anfrage auf Prozess bei 

CGI immer neu oder durch 

Web-Server gesteuert 

• Datei: Aufwändig, viele kleine Dateien 

schreiben, Session-ID ist Dateiname 

• Datenbank: Sicher, aufwändig, 

unabhängig von Web-Server 

Web-Server/Skriptumgebung 

Server/Host 

• Bevorzugt mit sicheren Cookies 

Ablage zwischen den Seitenaufrufen 

• Prozesskontext des Skripts hat keine 

Bedeutung! Je Anfrage andere Python 

Instanz möglich oder (CGI) immer neu 

• Serialisierung meist mit pickle, 

beliebige Python-Objekte möglich 

• Ablageort meist Dateisystem und 

Datenbank; Client (Cookie) oder 

Hauptspeicher (Shared Memory, 

memcached) möglich 

Shared 

Memory 

Hauptspeicher/ 

Prozesskontext 

Dateisystem 

Datenbank 

Dateisystem 

Datenbank 

Web-Server/Skriptumgebung 

Server/Host 







Session-Verwaltung auf Server – Session-ID 

Session-ID 

• Wenn schon vorhanden, dann einfach 

als String zurückgeben 

• Wenn nicht, dann vorher erzeugen 

• Session-ID in einem Cookie 

• Header setzen beim Erzeugen 

• Antwort muss also schon zur 

Verfügung stehen 

• Holen und gegebenenfalls erzeugen 

Verwendung 

• Vor jeder Anfrage: Inhalte auslesen 

• Nach jeder Anfrage: Inhalte speichern 

• Ablageort beliebig: Schlüssel (zum 

Beispiel Dateiname) ist die Session-ID 

session_id 

1 import os, uuid, OpenSSL 

2 import werkzeug.contrib.securecookie as sc 

3 

4 SESCOOKIE, SALT = "session_cookie", "secure" 

5 

6 def get_sid(request, response): 

7 "session_id aktueller session, ggf. neu" 

8 if SESCOOKIE not in request.cookies: # new 

9 r = OpenSSL.rand.bytes(16) 

10 sid = str(uuid.UUID(bytes=r)) 

11 cd = {SESCOOKIE: sid} 

12 c = sc.SecureCookie(cd, SALT).serialize() 

13 response.set_cookie(SESCOOKIE, c) 

14 else: 

15 c = request.cookies[SESCOOKIE] 

16 cd = sc.SecureCookie.unserialize(c, SALT) 

17 sid = cd[SESCOOKIE] 

18 return sid 

Session-Verwaltung auf Server – Dateisystem 

Sessions selbst gemacht (Verständnis) 

• Session-Objekt einfaches Dictionary 

mit Eintrag ’_SID’ auf Session-ID 

• Ablage in Dateisystem 

• Keine Überprüfung ob Kollision 

(schon vorhandene Session) 

• Kein Aufräumen alter Sessions 

Verwendung, als Middleware 

• response erzeugen, Session-Objekt 

mit load_start erhalten 

• Die Anwendung manipuliert das 

Session-Objekt (nicht _ * ) 

• save_session am Ende zum Speichern 

aktualisierter Session Inhalte 

• kill_session Session technisch 

beenden (vermeiden) 

session_fs 

1 import os, cPickle 

2 

3 STORAGE, SID = "/tmp", "_SID" 

4 def load_session(session_id): 

5 fpath = os.path.join(STORAGE, session_id) 

6 try: 

7 return cPickle.load(file(fpath, "r")) 

8 except (IOError, EOFError) as e: 

9 return {SID: session_id} 

10 

11 def save_session(session): 

12 fpath = os.path.join(STORAGE, session[SID]) 

13 cPickle.dump(session, file(fpath, "w")) 

14 

15 def kill_session(session): 

16 fpath = os.path.join(STORAGE, session[SID]) 

17 try: 

18 os.unlink(fpath) 

19 except OSError: 

20 pass 







Session-Verwaltung auf Server – Beispiel 

Achtung beim Schreiben – Nebenläufigkeit! 

Anforderung Anwendung 

• Hochzählen Zähler je Anfrage, Start 

17, je Benutzer unabhängig 

Umsetzung, wie beschrieben 

• Anwendung selbst in doit ausgelagert 

• Sessionverwaltung ist Middleware 


2 from session_id import get_sid 

3 from session_fs import load_session, save_session 

4 

5 page = file("page.tpl").read() 

6 

7 def doit(request, session): 

8 if "zahl" not in session: 

9 session["zahl"] = 16 

10 session["zahl"] += 1 

11 lis = [] 

12 for k,v in session.iteritems(): 

13 if not k.startswith("_"): 

14 lis.append("%s = %s" % (str(k), str(v))) 

15 return "\n".join(lis) 

16 



19 c = [] 

20 response = Response(c, content_type="text/html") 

21 sid = get_sid(request, response) 

22 session = load_session(sid) 

23 content = doit(request, session) 

24 save_session(session) 

25 dic = {’title’:’Sessions’, ’content’: content} 

26 c.append(page % dic) 


Parallele Zugriffe 

• Dateien liegen auf einem Server 

• Mehrere Zugriffe auf die Datei zur 

selben Zeit ist möglich 

• Selbst bei einer Session-Datei, zum 

Beispiel bei (böse) 

• Lesender/schreibender Zugriff 

Konflikte – Unklares Verhalten 

• Gleichzeitiges Schreiben und Lesen 

• Was wird gelesen? Halb/halb? 

• Was wird geschrieben? Noch 

konsistent? 

Lösung – Sperren 

• Verwaltung exklusiver Zugriffsrechte 

Web- 

Server 

Dateisystem 

Server/Host 







Sperren mit Dateien 

Exklusiver Zugriff auf Datei, fnctl 

• flock(fd, operation) für 

Sperrverwaltung, nur Unix 

• fd File descriptor, offene Datei 

• Konstanten LOCK_ * in fnctl 

Operationen (Auszug) 

• LOCK_EX (2): Exklusiver Zugriff, warten 

wenn (eine) Sperre noch vergeben 

• LOCK_UN (8): Sperre freigeben 

Verwendung 

• Klammer um Anfang/Ende der 

Anwendung (kompletter Request ist 

kritischer Bereich aus Session-Sicht) 

• lockf, thread-sicher Sperre erhalten 

• _ * -Schlüssel, interne Merker 

• ToDo: Schließen im Fehlerfall, . . . 

session_fslock 

1 import os, cPickle, fcntl 

2 from session_fs import STORAGE, SID, kill_session 

3 

4 FKEY, LOCKFKEY = "_file", "_lockfile" 

5 def load_session(session_id): 

6 fpath = os.path.join(STORAGE, session_id) 

7 lockf = file(fpath, "a") # force open file 

8 fcntl.flock(lockf, fcntl.LOCK_EX) 

9 f = file(fpath, "r+") # lock to read and write 

10 try: 

11 session = cPickle.load(f) 

12 except EOFError: 

13 session = {} 

14 session[SID] = session_id 

15 session[LOCKFKEY] = lockf 

16 session[FKEY] = f 

17 return session 

18 

19 def save_session(session): 

20 f = session[FKEY]; del session[FKEY] 

21 lockf = session[LOCKFKEY]; del session[LOCKFKEY] 

22 f.seek(0) # Anfang von Datei 

23 cPickle.dump(session, f) 

24 f.close() 

25 fcntl.flock(lockf, fcntl.LOCK_UN) 

26 lockf.close() 


Sessions mit werkzeug 

Realisieren von Sessions 

• Komplexe, fehleranfällige Middleware 

• Vorgefertigte Lösungen verwenden 

• Beispiel: werkzeug.contrib.sessions 

werkzeug.contrib.sessions 

• Vorgefertigte Bibliothek, kümmert sich 

um Cookies und Storage 

• Eine Option ist Dateisystem zum 

speichern (Z23) 

• Als Middleware einfach zwischen 

Aufruf und Ergebnis setzen 

ToDo 

• Aufräumen abgelaufener Sessions 

• Weitere Konfiguration möglich 


2 import werkzeug.contrib.sessions as sessions 

3 


5 

6 def doit(request, session): 

7 if "zahl" not in session: 

8 session["zahl"] = 16 

9 session["zahl"] += 1 

10 lis = [] 

11 for k,v in session.iteritems(): 

12 lis.append("%s = %s" % (str(k), str(v))) 

13 return "\n".join(lis) 

14 



17 session = request.environ["werkzeug.session"] 

18 content = doit(request, session) 

19 dic = {’title’:’Sessions’, ’content’: content} 

20 return Response(page%dic,content_type="text/html") 

21 

22 # haenge die Middleware dazwischen 

23 fsstore=sessions.FilesystemSessionStore() 

24 application=sessions.SessionMiddleware(app,fsstore) 





Bibliotheken 

Sessions 

Integration von Datenbanken 

Sessions – Umsetzung 

Datenbanken für Web-Anwendungen 

• Serialisieren häufig notwendig 

• Mehrbenutzeranw., immer mit dabei 

• Versuchen wenig Daten in der Session zu halten 

• Keine Frames, kein , konkurrierende Zugriffe 

Dateien als Ablage und sperren häufig nicht beste Wahl 

• Funktioniert nur gut auf einem Dateisystem auf einem Rechner (/tmp), nicht gut 

bei Network File System (NFS) 

• Skaliert nicht immer wie gewünscht, nicht ursprünglich gebaut für sehr viele 

Anfrage/Dateien gleichzeitig 

• Einsatzgebiete: Sessions, Zugriffszähler, Kommentare in Blogs, . . . 

Alternativen für Speicher-Backend 

• tmpfs, shared memory mit locking 

• Datenbanken 

• Sichere Ablage von Daten 

• Design für gleichzeitigen schreibenden und lesenden Zugriff 

• Ausgefeilte Sperrverwaltung, Transaktionskonzept (ACID) 

• Alle Anwendungsdaten, auch 

Session-Daten möglich 

Datenbanken und Python 

• Anbindung aller wichtigen DBMS 

• Python DB-API 2.0 (PEP 249) definiert 

DB-unabhängige Schicht (Pythons 

JDBC) 

• Treiber für spezifische DBMS 

Postgresql und Python 

• Treiber psycopg2, pygresql 

• Postgresql wie gewohnt (auch auf 

ZuHause-Image) 

Frameworks: Tools, ORM, . . . 

Datenbank 

Python DB-API 2.0 

psycopg 




Bibliotheken 


Bibliotheken 

Web-Seite mit Python und Postgresql – Beispiel 

Verwendung, wie gewohnt 

• Verbindungsaufbau connect 

• cursor-Konzept, je Verbindung 

• Anfragen mit execute, Parameter 

verwenden! 

• www.python.org/dev/ 

peps/pep-0249/ 

• initd.org/psycopg/ 


2 import psycopg2 as pg 

3 


5 keys = ["vorname", "name", "matnr"] 

6 tline = " %s " 

7 thead, tdata = "%s ", "%s " 

8 

9 def doit(request): 

10 conn = pg.connect(host="localhost", 

11 user="medieninf", password="medieninf") 

12 curs = conn.cursor() 

13 curs.execute("SELECT "+", ".join(keys)+" FROM studi") 

14 lis = [tline%"".join(map(lambda k:thead%k,keys))] 

15 for row in curs.fetchall(): 

16 lis.append(tline%"".join(map(lambda k:tdata%k,row))) 

17 return "\n" + "\n".join(lis) + "\n" 

18 



21 content = doit(request) 

22 dic = {’title’:’Namen’, ’content’: content} 


Sicheres Parametrisieren von Anfragen 

Externe Daten sind bedrohlich 

• Benutzereingabe, Datei, DB, . . . 

• Verhindere SQL-Injection 

Umsetzung mit execute 

• Wie %-Operator, extra Argument 

• Tupel oder Dictionary 


2 

3 keys = ["vorname", "name", "matnr"] 

4 tline = " %s " 

5 thead, tdata = "%s ", "%s " 

6 

7 def doit(request): 




11 sql = "SELECT "+", ".join(keys)+" FROM studi " 

12 if "matnr" in request.args: 

13 sql += "WHERE matnr = %s" 

14 curs.execute(sql, (request.args["matnr"], )) 

15 elif "vorname" in request.args: 

16 sql += "WHERE vorname LIKE %(vorname)s" 

17 like = "%%" + request.args["vorname"] + "%%" 

18 curs.execute(sql, {’vorname’: like}) 

19 else: 

20 curs.execute(sql) 

21 lis = [tline%"".join(map(lambda k:thead%k,keys))] 

22 for row in curs.fetchall(): 

23 lis.append(tline%"".join(map(lambda k:tdata%k,row))) 

24 return "\n"+"\n".join(lis)+"\n" 




Bibliotheken 


Bibliotheken 

Sicheres Parameterisieren von Anfragen – Ernst gemeint 

Postgresql und Python – Hinweise 

initd.org/psycopg/docs/usage.html 

Spalten-/Tabellennamen 

• Schlüssel vorname, name, matnr sind keine Variablen, kommen im Quelltext vor 

• Falls Spalten-/Tabellennamen dynamisch gesetzt werden, dann müssen diese per 

String-Operation integriert werden 

• Dann manuell prüfen zum Beispiel mit Dictionary, wobei Schlüssel die 

Benutzereingabe ist und der Wert im Quelltext steht 

Ergebnisse als Dictionary 

• Spaltenname statt Position in 

Anfrage für Wertzugriff 

• Verständlicherer Quellcode 

• psycopg2.extras.DictCursor 

Thread-Sicherheit 

• Sowohl Datenbankverbindung 

als auch Cursor ist thread-sicher 

• Connection-Pools separat 

• Praktikum: eine Verbindung conn 

je Anfrage 

Transaktionen 

• Eine Transaktion je Verbindung 

• Start automatisch, beenden mit 

commit oder rollback 

>>> import psycopg2.extras as ext 

>>> curs=conn.cursor(cursor_factory=ext.DictCursor) 

>>> curs.execute("SELECT * FROM studi") 

>>> row = curs.fetchone() 

>>> row 

[815, ’Susi’, ’Sinnlos’] 

>>> row["vorname"] 

’Susi’ 

>>> curs = conn.cursor() 

>>> curs.execute("INSERT INTO studi (matnr,vorname,name)"+ 

" VALUES (777,’Votan’,’Wahnwitz’)") 

>>> conn.rollback() 

>>> curs.execute("SELECT vorname FROM studi WHERE matnr=777") 

>>> curs.fetchall() 

[] 

>>> curs.execute("INSERT INTO studi (matnr,vorname,name)"+ 

" VALUES (777,’Votan’,’Wahnwitz’)") 

>>> conn.commit() 

>>> curs.execute("SELECT vorname FROM studi WHERE matnr=777") 

>>> curs.fetchall() 

[(’Votan’,)] 




Bibliotheken 


Bibliotheken 

Web-Anwendungen und Transaktionen 

Transaktion – DB-Sicht 

• Alles zwischen Begin (auto) und Ende 

• DBMS kümmert sich um transaktionale Sicherung 

Transaktion – Anwendersicht, Logical Unit of Work 

• Formular-Feld gesehen, geändert, gespeichert 

• Formular-Feld darf sich zwischenzeitlich nicht geändert haben 

• Mindestens zwei! Anfragen: Lesen in erster (Formular aufbauen), Schreiben in 

zweiter (Formular auswerten) 

• Mit einer Transaktion alleine nicht durchführbar 

Aufgabe: Transaktional sicher arbeiten 

• Lesen in erster Anfrage, sichern Werte in Session 

• Vor Schreiben Kontroll-Lesen in zweiter Anfrage, Abbruch bei Änderung 

• Kontrolllesen innerhalb Transaktion 

Hinweis 

• FOR UPDATE nicht vergessen 


Hochladen von Dateien 

Spezielles HTML-Formular 

• enctype="multipart/form-data", 

POST,


Bibliotheken 


Bibliotheken 

Speichern Binärdatei in Datenbank 

Laden Binärdatei von Datenbank 

Passende Datenbank-Struktur 

• Tabelle mit Referenzinformation 

• id, zum Wiederfinden 

• name, mime, size sind Extras 

• Datei als BLOB (Binary Large Object) 

mit lobject) in Datenbank ablegen 

CREATE TABLE bin ( 

id OID PRIMARY KEY, 

name TEXT, mime TEXT, size INT 

); 

... 

medieninf=> SELECT * FROM bin; 

id | name | mime | size 

-------+-----------------+-----------+------- 

31693 | fileupload1.png | image/png | 22595 

31694 | fileupload2.png | image/png | 29164 

medieninf=> \lo_list 

Large objects 

ID | Owner | Description 

-------+-----------+------------- 

31693 | medieninf | 

31694 | medieninf | 


2 

3 KEY="binarydata" 

4 def doit(request): # wenn POST 

5 fs = request.files[KEY] 

6 blob = fs.stream.read() 



9 lo = conn.lobject(0, "wb") 

10 lo.write(blob) 

11 sql = "INSERT INTO bin VALUES " 

12 sql += "(%(loid)s, %(name)s, %(type)s, %(size)s)" 

13 data = {’loid’: lo.oid, ’name’: fs.filename, 

14 ’type’: fs.content_type, ’size’: len(blob)} 


16 curs.execute(sql, data) 

17 conn.commit() 

18 return "uploaded " + str(lo.oid) 

Hochladen mit POST 

• Anlegen large object, id 

• Eintragen Meta-Information in Tabelle 

• Muss in Transaktion sein 

Download Datei von DBMS 

• Verwaltungsinformationen anhand von 

id lesen, zum Beispiel aus 

Query-Parameter id 

• Lesen des BLOB mit lobject 

• Rückgabe von Inhalt der kompletten 

Datei mit passenden mimetype zur 

Ausgabe 


2 from dbdownloaddoit import doit 


4 img = ’’ 



7 if "id" in request.args: # das Bid selbst 

8 c,mime = doit(int(request.args["id"])) 

9 return Response(c, content_type=mime) 

10 else: # Rahmen fuer ein Beispielbild 

11 c = img % {’id’: 31693} 

12 dic={’title’:’Image Show’,’content’:c} 



2 

3 def doit(id): # get image 



6 sql = "SELECT mime FROM bin WHERE id = %s" 


8 curs.execute(sql, (id, )) 

9 res = curs.fetchone() 

10 if not res: 

11 return "Kein Image", "text/plain" 

12 lo = conn.lobject(id, "rb") 

13 blob = lo.read() 

14 return blob, res[0] 




Bibliotheken 


Bibliotheken 

Bilder erzeugen mit Image 

PDF erzeugen mit reportlab 

Alle bekannten Bibliotheken verwendbar 

• Beispiel Image 

• Zeichnen mit ImageDraw, 

• Fonts mit ImageFont 

Anzeige eines selbstgebauten Buttons 

• Laden eines Templates button.png 

• Füllen des Templates mit Text, Text in 

spezifischem Font (Vera) und Größe 

(16) 

• Ausgabe in String über cStringIO da 

nur save möglich 

Beispiel 

• button.png 

• http://localhost:8080 

• http:.../?text=HS+RheinMain 


2 import Image, ImageDraw, ImageFont, cStringIO 

3 fp = "/usr/share/fonts/truetype/" 

4 fp += "ttf-bitstream-vera/Vera.ttf" 

5 fontsize = 16 



8 text = "Button" 

9 if "text" in request.args: 

10 text = request.args["text"] 

11 im = Image.open("button.png") 

12 draw = ImageDraw.Draw(im) 

13 font = ImageFont.truetype(fp, fontsize) 

14 twidth, theight = font.getsize(text) 

15 imwidth, imheight = im.size 

16 x, y = imwidth/2-twidth/2, imheight/2-(theight/2) 

17 draw.text((x, y), text, font=font, fill="black") 

18 output = cStringIO.StringIO() 

19 im.save(output, format="PNG") 

20 content = output.getvalue() 

21 return Response(content,content_type="image/png") 

reportlab 

• Bibliothek (frei) zum Erzeugen von 

PDF 

• Auch Formulare und Textsatz möglich 

• Einfaches Beispiel mit absoluter 

Positionierung (auf Canvas zeichnen), 

Quadratzahlen 


2 import cStringIO 

3 from reportlab.pdfgen import canvas 

4 



7 output = cStringIO.StringIO() 

8 c = canvas.Canvas(output) 

9 i = 0 

10 for x in range(50, 500, 85): 

11 c.drawString(x, 810, "Zahl") 

12 c.drawString(x+33, 810, "Quadrat") 

13 for y in range(50, 800, 15): 

14 c.drawString(x, 842-y, "%d"%i) 

15 c.drawString(x+33, 842-y, "%d"%(i*i)) 

16 i += 1 

17 c.save() 

18 content= output.getvalue() 

19 mime = "application/pdf" 

20 return Response(content,content_type=mime) 




Bibliotheken 


Bibliotheken 

XML verarbeiten mit lxml 

Frameworks – Beispiel django 

lxml 

• etree, Elementree, einfaches DOM 

• Einfacher Zugriff auf Unterelemente 

mit find, auf Attribute mit get 

• Viel mehr möglich 


2 from lxml import etree 

3 



6 xmlstring = file("adressen.xml").read() 

7 addrs = etree.fromstring(xmlstring) 

8 l = [] 

9 for addr in addrs: 

10 anrede = addr.find("anrede").get("bez") 

11 name = addr.find("name").text 

12 l.append("%s %s" % (anrede, name)) 

13 c = "\n".join(l) 

14 return Response(c,content_type="text/html") 

 

 

 

 

 

Hanna Mustermann 

Seestr. 5 

20000 

Hamburg 

 

 

 

Demo 

3042134 

10000 

Berlin 

 

 

django – Das Fullstack Framework 

• Alles dabei was man braucht 

• Objekt-Relationaler Mapper 

• Admin-Oberfläche 

• Aussagekräftige URLs, Routing 

• Templating 

• Caching 

• Internationalisierung 

• . . . 

• Weit verbreitet 

• Man ist sehr schnell sehr produktiv! 

Alternativen 

• wiki.python.org/moin/WebFrameworks, Dutzende 

in Python 

• Andere Sprachen: Ruby (on Rails), PHP (Zend), Java 

(JavaEE, JSF), C (-) 

Django is a high-level 

Python Web framework 

that encourages rapid 

development and clean, 

pragmatic design. 

www.djangoproject.com 




Bibliotheken 

Fazit – Grundlagen Web 

Was passiert wirklich (in Frameworks) 

• HTTP, CGI/WSGI, Request/Reponse-Zyklus 

• Templating, Routing 

• Sessions, Cookies 

• Zustandsmanagement (Anwendungskontext) auf Client und Server 

• Eine konkrete Middleware (werkzeug) aber noch kein Framework 

• Integration von Datenbanken und anderer Bibliotheken 

Verwendung 

• Immer, wenn auch versteckt in Frameworks 

• Immer, wenn man durchgreifen will oder muss 

• Immer, wenn man bei der Fehlersuche verstehen will was passiert 

Als nächstes 

• Ein Framework (nicht django :-) und ein Container 

• JavaEE Web Profile

4 in 1 - Medieninformatik - Hochschule RheinMain

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?