#encoding utf-8
#extends templates.main_template
#attr $title = "Ein paar Worte ueber CherryPy"
#attr $description = "Die wichtigsten Dinge, die man ueber CherryPy schreiben kann"
#attr $keywords = "Python CherryPy Cheetah Template Programmierung Linux Windows Web Design"

#block rest
#raw

.. image:: cplogo.gif
   :alt: CherryPy-Logo
   :target: http://cherrypy.org/
   :class: image-float-right


| deamon schrieb:
| > CherryPy gefällt mir zwar wegen seiner Einfachheit und Kompaktheit, 
| > aber die Doku finde ich grausam und wenn man vom Standardschema abweichende 
| > URLs haben möchte, hört es auch auf einfach zu sein.

Hallo!

Was die Dokumentation von CherryPy_ betrifft: Ich bin recht gut damit gefahren, 
mir alle Seiten der CherryPy-Website auszudrucken und durchzulesen. 
Die wichtigsten Dinge werden dort auf jeden Fall erklärt. Weiters habe ich 
noch dieses Buch http://www.cherrypyessentials.com/ gelesen. 
Dort steht der Rest drinnen, den man vielleicht mal brauchen kann.

Die wichtigsten CherryPy-Objekte sind:

- cherrypy.request
- cherrypy.response
- cherrypy.session
- cherrypy.config

Über das **Request-Objekt** (``cherrypy.request``) erfährt man,
welche Informationen der Browser bei der Anfrage mitgeliefert hat. Das sind
z.B. angeforderte URL, gewünschte Sprache, HTTP-Version, Browser-Name, IP-Adresse, 
Cookies, usw.
Ich habe mir eine kleine Funktion geschrieben, die mir diese Informationen
anzeigt::

  import cherrypy
  
  ...
  
  def show_request():
      """
      Gibt die Attribute des aktuellen Requests zurück.
      """
      from pprint import pformat
      
      retstr = "<pre>"
      for key, value in cherrypy.request.__dict__.items():
          retstr += "%s: %s\n\n" % (key, pformat(value).replace("\\n", "\n"))
      retstr += "</pre>"
      
      return retstr

Sehr nützlich das Ding, ehrlich! :-)

Jeder Request eines Browsers wird an eine Funktion (die Handler-Funktion) 
weitergeleitet. In diesem Beispiel ist die *index*-Funktion so ein
Handler::

  import cherrypy
  
  class HelloWorld(object):
      def index(self, *args, **kwargs):
          return "Hello World!"
      index.exposed = True
  
  cherrypy.quickstart(HelloWorld())

Über ``*args`` und ``**kwargs`` der Handler-Funktion bekommt man den Pfad und 
die vom Browser übermittelten Parameter übergeben. Die Rückgabe dieser Funktion, 
wird dann direkt als Response an den Browser zurück gesendet. 
Der Einfachheit halber, wird das Ganze als Content-Typ "text/html" übermittelt. 
Möchte man stattdessen einen anderen Content-Typ zurück liefern, dann kann man 
den Content-Typ direkt im Response-Objekt ändern, bevor man die Funktion mit
``return`` verlässt.

Der **Response** kann angepasst werden, bevor dieser an den Browser zurück gesendet 
wird. Der Response ist genau so ein Objekt wie der Request. Der Response ist 
in CherryPy über ``cherrypy.response`` ansprechbar.

Genau so wie es ein Request-Objekt und ein Response-Objekt gibt, gibt es auch 
ein **Session-Objekt** (``cherrypy.session``). Dabei handelt es sich um ein 
Dictionary-artiges Objekt, an welches man Objekte binden kann. 
Objekte, die so lange gültig bleiben, so lange es die Session gibt.

Man kann die Session so einstellen, dass diese im Dateisystem als Pickle oder 
in einer Datenbank abgelegt wird. CherryPy erkennt die Session über ein Cookie
wieder, das beim Browser hinterlegt wird. Wie lange das Cookie gültig bleibt,
kann man in der INI-Datei einstellen.

Wenn man mit Datenbanken arbeitet, dann ist noch recht fein, dass man ein 
**threadsicheres Objekt** (``cherrypy.thread_data``) zur Verfügung hat, an 
welches man Objekte/Daten binden kann, die immer nur für den aktuellen 
Thread gültig sind. 
So kann man je eine Connection für je einen Thread vorhalten. Das sind dann 
in der CherryPy-Standardeinstellung neun Threads mit je einer eigenen Connection.

Die **Einstellungen** können in einer INI-Datei gehalten werden. Man greift 
mit ``cherrypy.config`` darauf zu. Das kann man z.B. nutzen um die 
Datenbankeinstellungen in die INI-Datei auszulagern.

Über die INI-Datei kann man z.B. einstellen, dass CherryPy immer nur UTF-8 
zurück liefert. Dafür muss man sich nur darum kümmern, dass man beim "return" 
der jeweiligen Handler-Funktionen **Unicode** zurück gibt. CherryPy kümmert 
sich um den Rest.

::

  #
  # Encoding der auszuliefernden HTML-Seiten
  #
  tools.encode.on = True
  tools.encode.encoding = "utf-8"

Weiters kann man CherryPy so einstellen, dass man auch vom Request 
Unicode (z.B. von HTML-Formularen) geliefert bekommt. 
  
  Unicode rein -- Unicode raus :-)
   
Dieses Verhalten wird seit der neuen Version auch von Cheetah_, 
der Python-ähnlichen Vorlagensprache, unterstützt.

Ich programmiere schon seit einiger Zeit mit CherryPy. Und seit zwei Monaten 
arbeite ich an einem mehrsprachigen Webshop. Mehrsprachig heißt in diesem Fall,
dass die Python-Module, die HTML- und Email-Vorlagen und die JavaScripte 
mit "gettext" übersetzt werden.
Im Hintergrund arbeitet CherryPy. Die HTML-Seiten lasse ich mir von Cheetah 
generieren. Ich habe noch keine Schwachstelle entdecken können und bin wie
am Anfang immer noch gleich begeistert, wie einfach CherryPy mir das
Programmieren, einer doch recht komplexen Webanwendung, macht.

mfg
Gerold
:-)

.. _CherryPy: http://cheerypy.org/
.. _Cheetah: http://cheetahtemplate.org/


#end raw
#end block rest

#block main_block
  $rest2html($rest)
#end block main_block