[MANUAL] German:

- sync with r20757

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@20758 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/de/module_specs/Zend_Cache-Backends.xml

@@ -1,8 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 17749 -->
+<!-- EN-Revision: 20756 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.cache.backends">
     <title>Zend_Cache Backends</title>
+
     <para>
         Es gibt zwei Arten von Backends: Standard und erweiterte. Natürlich bieten erweiterte
         Backends mehr Features.
@@ -10,169 +11,193 @@
 
     <sect2 id="zend.cache.backends.file">
         <title>Zend_Cache_Backend_File</title>
+
         <para>
             Dieses (erweiterte) Backend speichert Cache Datensätze in Dateien (in einem gewählten
             Verzeichnis).
         </para>
+
         <para>
             Mögliche Optionen sind :
         </para>
+
         <table id="zend.cache.backends.file.table">
             <title>File Backend Optionen</title>
+
             <tgroup cols="4">
-                 <thead>
-                      <row>
+                <thead>
+                    <row>
                         <entry>Option</entry>
                         <entry>Daten Typ</entry>
                         <entry>Standardwert</entry>
                         <entry>Beschreibung</entry>
                     </row>
-                 </thead>
-                 <tbody>
-                      <row>
-                          <entry><emphasis>cache_dir</emphasis></entry>
-                          <entry><type>String</type></entry>
-                          <entry>'<filename>/tmp/</filename>'</entry>
-                          <entry>
-                              Verzeichnis, in dem die Cache Dateien gespeichert werden
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>file_locking</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>TRUE</constant></entry>
-                          <entry>
+                </thead>
+
+                <tbody>
+                    <row>
+                        <entry><emphasis>cache_dir</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>'<filename>/tmp/</filename>'</entry>
+
+                        <entry>
+                            Verzeichnis, in dem die Cache Dateien gespeichert werden
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>file_locking</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>TRUE</constant></entry>
+
+                        <entry>
                             Ein- oder Ausschalten von file_locking: kann die Beschädigung des
                             Caches unter schlechten Bedingungen verhindern, aber es hilft nicht bei
                             Multithreaded Webservern oder bei <acronym>NFS</acronym>
                             Filesystemen...
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>read_control</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>TRUE</constant></entry>
-                          <entry>
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>read_control</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>TRUE</constant></entry>
+
+                        <entry>
                             Ein- oder Ausschalten von read_control: eingeschaltet wird ein
                             Kontrollschlüssel im Cache File inkludiert und dieser Schlüssel wird mit
                             dem Schlüssel verglichen, der nach dem Lesen berechnet wird.
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>read_control_type</emphasis></entry>
-                          <entry><type>String</type></entry>
-                          <entry>'crc32'</entry>
-                          <entry>
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>read_control_type</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>'crc32'</entry>
+
+                        <entry>
                             Typ der Schreibkontrolle (nur wenn read_control eingeschaltet ist).
                             Mögliche Werte sind : 'md5' (bestes, aber am Langsamsten), 'crc32'
                             (etwas weniger sicher, aber schneller, beste Wahl), 'adler32' (neue
                             Wahl, schneller als crc32), 'strlen' um nur die Länge zu testen
                             (schnellstes).
                         </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>hashed_directory_level</emphasis></entry>
-                          <entry><type>Integer</type></entry>
-                          <entry>0</entry>
-                          <entry>
-                             Level der gehashten Verzeichnis Struktur: 0 heißt "keine gehashte
-                             Verzeichnis Strutur, 1 heißt "ein Level von Verzeichnissen", 2 heißt
-                             "zwei Levels"... Diese Option kann den Cache nur dann schneller machen,
-                             wenn viele Tausende Cache Dateien verwendet werden. Nur spezielle
-                             Messungen können helfen, den perfekten Wert zu finden. Möglicherweise
-                             ist 1 oder 2 ein guter Anfang.
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>hashed_directory_umask</emphasis></entry>
-                          <entry><type>Integer</type></entry>
-                          <entry>0700</entry>
-                          <entry>
-                              Umask für die gehashte Verzeichnis Struktur
+                    </row>
+
+                    <row>
+                        <entry><emphasis>hashed_directory_level</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>0</entry>
+
+                        <entry>
+                            Level der gehashten Verzeichnis Struktur: 0 heißt "keine gehashte
+                            Verzeichnis Strutur, 1 heißt "ein Level von Verzeichnissen", 2 heißt
+                            "zwei Levels"... Diese Option kann den Cache nur dann schneller machen,
+                            wenn viele Tausende Cache Dateien verwendet werden. Nur spezielle
+                            Messungen können helfen, den perfekten Wert zu finden. Möglicherweise
+                            ist 1 oder 2 ein guter Anfang.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>hashed_directory_umask</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>0700</entry>
+                        <entry>Umask für die gehashte Verzeichnis Struktur</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>file_name_prefix</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>'zend_cache'</entry>
+
+                        <entry>
+                            Präfix für Cache Dateien; man muss mit dieser Option sehr vorsichtig
+                            umgehen, weil ein zu generischer Wert in einem System Cache
+                            Verzeichnis (wie <filename>/tmp</filename>) kann beim Löschen des
+                            Caches zu großen Problemen führen.
                         </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>file_name_prefix</emphasis></entry>
-                          <entry><type>String</type></entry>
-                          <entry>'zend_cache'</entry>
-                          <entry>
-                              Präfix für Cache Dateien; man muss mit dieser Option sehr vorsichtig
-                              umgehen, weil ein zu generischer Wert in einem System Cache
-                              Verzeichnis (wie <filename>/tmp</filename>) kann beim Löschen des
-                              Caches zu großen Problemen führen.
+                    </row>
+
+                    <row>
+                        <entry><emphasis>cache_file_umask</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>0700</entry>
+                        <entry>umask nach Cache Dateien</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>metatadatas_array_max_size</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>100</entry>
+                        <entry>
+                            Interne maximale Größe für das Metadaten Array (dieser Wert sollte
+                            nicht geändert werden außer man weiß was man macht)
                         </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>cache_file_umask</emphasis></entry>
-                          <entry><type>Integer</type></entry>
-                          <entry>0700</entry>
-                          <entry>
-                              umask nach Cache Dateien
-                          </entry>
-                      </row>
-                       <row>
-                          <entry><emphasis>metatadatas_array_max_size</emphasis></entry>
-                          <entry><type>Integer</type></entry>
-                          <entry>100</entry>
-                          <entry>
-                              Interne maximale Größe für das Metadaten Array (dieser Wert sollte
-                              nicht geändert werden außer man weiß was man macht)
-                          </entry>
-                      </row>
-                  </tbody>
-              </tgroup>
-          </table>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
     </sect2>
+
     <sect2 id="zend.cache.backends.sqlite">
         <title>Zend_Cache_Backend_Sqlite</title>
+
         <para>
             Dieses (erweiterte) Backend speichert die Cache Datensätze in einer SQLite Datenbank.
         </para>
+
         <para>
             Mögliche Optionen sind :
         </para>
+
         <table id="zend.cache.backends.sqlite.table">
             <title>Sqlite Backend Optionen</title>
+
             <tgroup cols="4">
-                 <thead>
-                      <row>
-                           <entry>Option</entry>
+                <thead>
+                    <row>
+                        <entry>Option</entry>
                         <entry>Daten Typ</entry>
                         <entry>Standardwert</entry>
                         <entry>Beschreibung</entry>
                     </row>
-                 </thead>
-                 <tbody>
-                      <row>
-                          <entry><emphasis>cache_db_complete_path (mandatory)</emphasis></entry>
-                          <entry><type>String</type></entry>
-                          <entry><constant>NULL</constant></entry>
-                          <entry>
-                              Der komplette Pfad (inklusive Dateiname) der SQLite Datenbank
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>automatic_vacuum_factor</emphasis></entry>
-                          <entry><type>Integer</type></entry>
-                          <entry>10</entry>
-                          <entry>
-                              Deaktiviert oder stellt den automatischen Vakuumprozess ein.
-                              Der automatische Vakuumprozess defragmentiert die Datenbankdatei (und
-                              verkleinert sie) wenn <methodname>clean()</methodname> oder
-                              <methodname>delete()</methodname> aufgerufen wird: 0 bedeutet kein
-                              automatisches Vakuum; 1 bedeutet systematisches Vakuum (wenn die
-                              <methodname>delete()</methodname> or <methodname>clean()</methodname>
-                              Methoden aufgerufen werden; x (integer) > 1 => automatisches Vakuum
-                              zufällig einmal pro x <methodname>clean()</methodname> oder
-                              <methodname>delete()</methodname> Aufrufe.
-                          </entry>
-                      </row>
-                  </tbody>
-              </tgroup>
-          </table>
+                </thead>
+
+                <tbody>
+                    <row>
+                        <entry><emphasis>cache_db_complete_path (mandatory)</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry><constant>NULL</constant></entry>
+                        <entry>
+                            Der komplette Pfad (inklusive Dateiname) der SQLite Datenbank
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>automatic_vacuum_factor</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>10</entry>
+                        <entry>
+                            Deaktiviert oder stellt den automatischen Vakuumprozess ein.
+                            Der automatische Vakuumprozess defragmentiert die Datenbankdatei (und
+                            verkleinert sie) wenn <methodname>clean()</methodname> oder
+                            <methodname>delete()</methodname> aufgerufen wird: 0 bedeutet kein
+                            automatisches Vakuum; 1 bedeutet systematisches Vakuum (wenn die
+                            <methodname>delete()</methodname> or <methodname>clean()</methodname>
+                            Methoden aufgerufen werden; x (integer) > 1 => automatisches Vakuum
+                            zufällig einmal pro x <methodname>clean()</methodname> oder
+                            <methodname>delete()</methodname> Aufrufe.
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
     </sect2>
+
     <sect2 id="zend.cache.backends.memcached">
         <title>Zend_Cache_Backend_Memcached</title>
+
         <para>
             Dieses (erweiterte) Backend speichert Cache Datensätze in einem Memcached Server. <ulink
                 url="http://www.danga.com/memcached/">memcached</ulink> ist ein hoch-performantes,
@@ -180,101 +205,122 @@
             Memcached Dämon benötigt und <ulink url="http://pecl.php.net/package/memcache">die
                 Memcached <acronym>PECL</acronym> Erweiterung</ulink>.
         </para>
+
         <para>
             Vorsicht: mit diesem Backend werden zur Zeit "Marker" nicht unterstützt genauso wie das
             "doNotTestCacheValidity=true" Argument.
         </para>
+
         <para>
             Mögliche Optionen sind :
         </para>
+
         <table id="zend.cache.backends.memcached.table">
             <title>Memcached Backend Optionen</title>
+
             <tgroup cols="4">
-                 <thead>
-                      <row>
+                <thead>
+                    <row>
                         <entry>Option</entry>
                         <entry>Daten Typ</entry>
                         <entry>Standardwert</entry>
                         <entry>Beschreibung</entry>
                     </row>
-                 </thead>
-                 <tbody>
-                      <row>
-                          <entry><emphasis>servers</emphasis></entry>
-                          <entry><type>Array</type></entry>
-                          <entry>
-                              <command>array(array('host' => 'localhost','port' => 11211,
-                                  'persistent' => true, 'weight' => 1, 'timeout' => 5,
-                                  'retry_interval' => 15, 'status' => true,
-                                  'failure_callback' => '' ))</command>
-                          </entry>
-                          <entry>
-                              Ein Array von Memcached Servern; jeder Memcached Server wird durch ein
-                              assoziatives Array beschrieben : 'host' => (string) : Der Name des
-                              Memcached Servers, 'port' => (int) : Der Port des Memcached Servers,
-                              'persistent' => (bool) : Persistente Verbindungen für diesen Memcached
-                              Server verwenden oder nicht 'weight' => (int) : Das Gewicht des
-                              Memcached Servers, 'timeout' => (int) : Das Timeout des Memcached
-                              Servers, 'retry_interval' => (int) : Das Wiederholungsintervall des
-                              Memcached Servers, 'status' => (bool) : Der Status des Memcached
-                              Servers, 'failure_callback' => (callback) : Der failure_callback des
-                              Memcached Servers
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>compression</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>FALSE</constant></entry>
-                          <entry>
-                             <constant>TRUE</constant> wenn on-the-fly Kompression verwendet werden
-                             soll
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>compatibility</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>FALSE</constant></entry>
-                          <entry>
-                             <constant>TRUE</constant> wenn man den Compatibility Modus mit alten
-                             Memcache Servern oder Erweiterungen verwenden will
-                          </entry>
-                      </row>
-                  </tbody>
-              </tgroup>
-          </table>
+                </thead>
+
+                <tbody>
+                    <row>
+                        <entry><emphasis>servers</emphasis></entry>
+                        <entry><type>Array</type></entry>
+
+                        <entry>
+                            <command>array(array('host' => 'localhost','port' => 11211,
+                                'persistent' => true, 'weight' => 1, 'timeout' => 5,
+                                'retry_interval' => 15, 'status' => true,
+                                'failure_callback' => '' ))</command>
+                        </entry>
+
+                        <entry>
+                            Ein Array von Memcached Servern; jeder Memcached Server wird durch ein
+                            assoziatives Array beschrieben : 'host' => (string) : Der Name des
+                            Memcached Servers, 'port' => (int) : Der Port des Memcached Servers,
+                            'persistent' => (bool) : Persistente Verbindungen für diesen Memcached
+                            Server verwenden oder nicht 'weight' => (int) : Das Gewicht des
+                            Memcached Servers, 'timeout' => (int) : Das Timeout des Memcached
+                            Servers, 'retry_interval' => (int) : Das Wiederholungsintervall des
+                            Memcached Servers, 'status' => (bool) : Der Status des Memcached
+                            Servers, 'failure_callback' => (callback) : Der failure_callback des
+                            Memcached Servers
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>compression</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>FALSE</constant></entry>
+
+                        <entry>
+                            <constant>TRUE</constant> wenn on-the-fly Kompression verwendet werden
+                            soll
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>compatibility</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>FALSE</constant></entry>
+
+                        <entry>
+                            <constant>TRUE</constant> wenn man den Compatibility Modus mit alten
+                            Memcache Servern oder Erweiterungen verwenden will
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
     </sect2>
+
     <sect2 id="zend.cache.backends.apc">
         <title>Zend_Cache_Backend_Apc</title>
+
         <para>
             Dieses (erweiterte) Backend speichert Cache Datensätze im Shared Memory durch die
             <ulink url="http://pecl.php.net/package/APC">APC</ulink> (Alternativer
             <acronym>PHP</acronym> Cache) Erweiterung (welche natürlich für die Verwendung dieses
             Backends benötigt wird).
         </para>
+
         <para>
             Vorsicht: mit diesem Backend werden "Marker" zur Zeit nicht unterstützt genauso wie das
             "doNotTestCacheValidity=true" Argument.
         </para>
+
         <para>
             Es gibt keine Optionen für dieses Backend.
         </para>
     </sect2>
+
     <sect2 id="zend.cache.backends.xcache">
         <title>Zend_Cache_Backend_Xcache</title>
+
         <para>
             Dieses Backend speichert Cache Einträge im Shared Memory durch die
             <ulink url="http://xcache.lighttpd.net/">XCache</ulink> Erweiterung (welche natürlich
             benötigt wird, damit dieses Backend verwendet werden kann).
         </para>
+
         <para>
             Achtung: Bei diesem Backend werden "tags" aktuell nicht unterstützt sowie das
             "doNotTestCacheValidity=true" Argument.
         </para>
+
         <para>
             Mögliche Optionen sind:
         </para>
+
         <table id="zend.cache.backends.xcache.table">
             <title>Xcache backend options</title>
+
             <tgroup cols="4">
                 <thead>
                     <row>
@@ -284,217 +330,486 @@
                         <entry>Beschreibung</entry>
                     </row>
                 </thead>
+
                 <tbody>
                     <row>
                         <entry><emphasis>user</emphasis></entry>
                         <entry><type>String</type></entry>
                         <entry><constant>NULL</constant></entry>
+
                         <entry>
-                              <filename>xcache.admin.user</filename>, notwendig für die
-                              <methodname>clean()</methodname> Methode
+                            <filename>xcache.admin.user</filename>, notwendig für die
+                            <methodname>clean()</methodname> Methode
                         </entry>
                     </row>
+
                     <row>
                         <entry><emphasis>password</emphasis></entry>
                         <entry><type>String</type></entry>
                         <entry><constant>NULL</constant></entry>
+
                         <entry>
-                              <filename>xcache.admin.pass</filename> (in offener Form, nicht
-                              <acronym>MD5</acronym>), notwendig für die
-                              <methodname>clean()</methodname> Methode
+                            <filename>xcache.admin.pass</filename> (in offener Form, nicht
+                            <acronym>MD5</acronym>), notwendig für die
+                            <methodname>clean()</methodname> Methode
                         </entry>
                     </row>
                 </tbody>
             </tgroup>
         </table>
     </sect2>
+
     <sect2 id="zend.cache.backends.platform">
         <title>Zend_Cache_Backend_ZendPlatform</title>
+
         <para>
             Dieses Backend verwendet die Content Caching <acronym>API</acronym> des
             <ulink url="http://www.zend.com/en/products/platform">Zend Platform</ulink> Produktes.
             Natürlich muss man die Zend Platform installiert haben, um dieses Backend verwenden zu
             können.
         </para>
+
         <para>
             Dieses Backend unterstützt Tags, aber nicht den
             <constant>CLEANING_MODE_NOT_MATCHING_TAG</constant> Löschmodus.
         </para>
+
         <para>
             Bei Definition dieses Backends muß ein Trennzeichen -- '-', '.', ' ', oder '_'
             -- zwischen den Wörtern 'Zend' und 'Platform' definiert sein wenn die
             <methodname>Zend_Cache::factory()</methodname> Methode verwendet wird:
         </para>
+
         <programlisting language="php"><![CDATA[
 $cache = Zend_Cache::factory('Core', 'Zend Platform');
 ]]></programlisting>
+
         <para>
             Es gibt keine Optionen für dieses Backend.
         </para>
     </sect2>
+
     <sect2 id="zend.cache.backends.twolevels">
         <title>Zend_Cache_Backend_TwoLevels</title>
+
         <para>
             Dieses (erweiterte) Backend ist ein Hybrides. Es speichert Cache Einträge in zwei
             anderen Backends: Ein schnelles (aber limitiertes) wie Apc, Memcache... und ein
             "langsames" wie File, Sqlite...
         </para>
+
         <para>
             Dieses Backend verwendet den Priority Parameter (der auf Frontend Level angegeben wird
             wenn ein Eintrag gespeichert wird) und den verbleibenden Platz im schnellen Backend um
             die Verwendung dieser zwei Backends zu optimieren.
         </para>
+
         <para>
             Dieses Backend sollte mit Verwendung eines Word Separators -- '-', '.', ' ', oder '_' --
             zwischen den Wörtern 'Two' und 'Levels' spezifiziert werden wenn die
             <methodname>Zend_Cache::factory()</methodname> Methode verwendet wird:
         </para>
+
         <programlisting language="php"><![CDATA[
 $cache = Zend_Cache::factory('Core', 'Two Levels');
 ]]></programlisting>
+
         <para>
             Vorhandene Optionen sind:
         </para>
+
         <table id="zend.cache.backends.twolevels.table">
             <title>TwoLevels Backend Optionen</title>
+
             <tgroup cols="4">
-                 <thead>
-                      <row>
+                <thead>
+                    <row>
                         <entry>Option</entry>
                         <entry>Datentyp</entry>
                         <entry>Standardwert</entry>
                         <entry>Beschreibung</entry>
                     </row>
-                 </thead>
-                 <tbody>
-                      <row>
-                          <entry><emphasis>slow_backend</emphasis></entry>
-                          <entry><type>String</type></entry>
-                          <entry>File</entry>
-                          <entry>
-                              Der "langsame" Backendname
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>fast_backend</emphasis></entry>
-                          <entry><type>String</type></entry>
-                          <entry>Apc</entry>
-                          <entry>
-                              Der "schnelle" Backendname
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>slow_backend_options</emphasis></entry>
-                          <entry><type>Array</type></entry>
-                          <entry><methodname>array()</methodname></entry>
-                          <entry>
-                              Die "langsamen" Backendoptionen
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>fast_backend_options</emphasis></entry>
-                          <entry><type>Array</type></entry>
-                          <entry><methodname>array()</methodname></entry>
-                          <entry>
-                              Die "schnellen" Backendoptionen
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>slow_backend_custom_naming</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>FALSE</constant></entry>
-                          <entry>
-                              Wenn <constant>TRUE</constant>, wird das slow_backend Argument als
-                              kompletter Klassenname verwendet; wenn <constant>FALSE</constant>,
-                              wird das frontend Argument als Ende des
-                              "<classname>Zend_Cache_Backend_</classname>[...]" Klassennamens
-                              verwendet
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>fast_backend_custom_naming</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>FALSE</constant></entry>
-                          <entry>
-                              Wenn <constant>TRUE</constant>, wird das fast_backend Argument als
-                              kompletter Klassenname verwendet; wenn <constant>FALSE</constant>,
-                              wird das frontend Argument als Ende des
-                              "<classname>Zend_Cache_Backend_</classname>[...]" Klassennamens
-                              verwendet
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>slow_backend_autoload</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>FALSE</constant></entry>
-                          <entry>
-                              Wenn <constant>TRUE</constant>, wird kein require_once für das
-                              langsame Backend verwendet (nur für eigene Backends nützlich)
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>fast_backend_autoload</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>FALSE</constant></entry>
-                          <entry>
-                              Wenn <constant>TRUE</constant>, wird kein require_once für das
-                              schnelle Backend verwendet (nur für eigene Backends nützlich)
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>auto_refresh_fast_cache</emphasis></entry>
-                          <entry><type>Boolean</type></entry>
-                          <entry><constant>TRUE</constant></entry>
-                          <entry>
-                              Wenn <constant>TRUE</constant>, wird der schnelle Cache automatisch
-                              refresht wenn ein Cache Eintrag getroffen wird
-                          </entry>
-                      </row>
-                      <row>
-                          <entry><emphasis>stats_update_factor</emphasis></entry>
-                          <entry><type>Integer</type></entry>
-                          <entry>10</entry>
-                          <entry>
-                              Ausschalten / Feintunen der Berechnung des Füll-Prozentsatzes des
-                              schnellen Backends (wenn ein Eintrag in den Cache gespeichert wird,
-                              die Berechnung des Füll-Prozentsatzes des schnellen Backends zufällig
-                              1 mal bei x Cache Schreibvorgängen)
-                          </entry>
-                      </row>
-                  </tbody>
-              </tgroup>
-          </table>
+                </thead>
+
+                <tbody>
+                    <row>
+                        <entry><emphasis>slow_backend</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>File</entry>
+                        <entry>Der "langsame" Backendname</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>fast_backend</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>Apc</entry>
+                        <entry>Der "schnelle" Backendname</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>slow_backend_options</emphasis></entry>
+                        <entry><type>Array</type></entry>
+                        <entry><methodname>array()</methodname></entry>
+                        <entry>Die "langsamen" Backendoptionen</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>fast_backend_options</emphasis></entry>
+                        <entry><type>Array</type></entry>
+                        <entry><methodname>array()</methodname></entry>
+                        <entry>Die "schnellen" Backendoptionen</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>slow_backend_custom_naming</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>FALSE</constant></entry>
+
+                        <entry>
+                            Wenn <constant>TRUE</constant>, wird das slow_backend Argument als
+                            kompletter Klassenname verwendet; wenn <constant>FALSE</constant>,
+                            wird das frontend Argument als Ende des
+                            "<classname>Zend_Cache_Backend_</classname>[...]" Klassennamens
+                            verwendet
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>fast_backend_custom_naming</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>FALSE</constant></entry>
+
+                        <entry>
+                            Wenn <constant>TRUE</constant>, wird das fast_backend Argument als
+                            kompletter Klassenname verwendet; wenn <constant>FALSE</constant>,
+                            wird das frontend Argument als Ende des
+                            "<classname>Zend_Cache_Backend_</classname>[...]" Klassennamens
+                            verwendet
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>slow_backend_autoload</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>FALSE</constant></entry>
+
+                        <entry>
+                            Wenn <constant>TRUE</constant>, wird kein require_once für das
+                            langsame Backend verwendet (nur für eigene Backends nützlich)
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>fast_backend_autoload</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>FALSE</constant></entry>
+
+                        <entry>
+                            Wenn <constant>TRUE</constant>, wird kein require_once für das
+                            schnelle Backend verwendet (nur für eigene Backends nützlich)
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>auto_refresh_fast_cache</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>TRUE</constant></entry>
+
+                        <entry>
+                            Wenn <constant>TRUE</constant>, wird der schnelle Cache automatisch
+                            refresht wenn ein Cache Eintrag getroffen wird
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>stats_update_factor</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>10</entry>
+
+                        <entry>
+                            Ausschalten / Feintunen der Berechnung des Füll-Prozentsatzes des
+                            schnellen Backends (wenn ein Eintrag in den Cache gespeichert wird,
+                            die Berechnung des Füll-Prozentsatzes des schnellen Backends zufällig
+                            1 mal bei x Cache Schreibvorgängen)
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
     </sect2>
+
     <sect2 id="zend.cache.backends.zendserver">
         <title>Zend_Cache_Backend_ZendServer_Disk und Zend_Cache_Backend_ZendServer_ShMem</title>
+
         <para>
             Diese Backends speichern Cacheeinträge indem Sie die Caching Funktionalitäten von <ulink
                 url="http://www.zend.com/en/products/server/downloads-all?zfs=zf_download">Zend
                 Server</ulink> verwenden.
         </para>
+
         <para>
             Achtung: mit diesen Backends werden für den Moment "Tags" nicht unterstützt, wegen dem
             "doNotTestCacheValidity=true" Argument.
         </para>
+
         <para>
             Diese Backends arbeiten nur in einer Zend Server Umgebung für Seiten die über
             <acronym>HTTP</acronym> oder <acronym>HTTPS</acronym> angefragt wurden und nicht für
             Kommandozeilen Ausführung.
         </para>
+
         <para>
             Dieses Backend muß durch Verwendung des <emphasis>customBackendNaming</emphasis>
             Parameter mit <constant>TRUE</constant> spezifiziert werden wenn die Methode
             <methodname>Zend_Cache::factory()</methodname> verwendet wird:
         </para>
+
         <programlisting language="php"><![CDATA[
 $cache = Zend_Cache::factory('Core', 'Zend_Cache_Backend_ZendServer_Disk',
                              $frontendOptions, $backendOptions, false, true);
 ]]></programlisting>
+
         <para>
             Es gibt keine Optionen für diese Backends.
         </para>
     </sect2>
+
+    <sect2 id="zend.cache.backends.static">
+        <title>Zend_Cache_Backend_Static</title>
+
+        <para>
+            Dieses Backend arbeitet in Verbindung mit
+            <classname>Zend_Cache_Frontend_Capture</classname> (diese zwei müssen zusammen verwendet
+            werden) um die Ausgabe von Anfragen als statische Dateien zu speichern. Dies bedeutet
+            das die statischen Dateien bei weiteren Anfragen direkt serviert werden ohne das PHP
+            oder sogar der Zend Framework involviert sind.
+        </para>
+
+        <para>
+            Der Vorteil dieses Caches besteht darin das eine starke Verbesserung des Durchsatzes
+            stattfindet weil statische Dateien zurückgegeben werden und keine weitere dynamische
+            Bearbeitung stattfindet. Natürlich gibt es auch einige Nachteile. Der einzige Weg um
+            dynamische Anfragen wieder zu haben besteht darin die gecachten Dateien von anderswo
+            in der Anwendung zu löschen (oder über einen Cronjob wenn das zeitlich abgestimmt werden
+            soll). Es ist auch auf Single-Server Anwendungen begrenzt begrenzt bei denen nur ein
+            Dateisystem verwendet wird. Trotzdem kann es eine große Bedeutung haben wenn man mehr
+            Geschwindigkeit haben will ohne auf Kosten eines Proxies auf einzelnen Maschinen zu
+            setzen.
+        </para>
+
+        <para>
+            Bevor die Optionen beschrieben werden sollte man beachten das dies einige Änderungen der
+            Standardwerte in der .htaccess Datei benötigt damit Anfrage auf die staischen Dateien
+            zeigen wenn diese existieren. Hier ist ein Beispiel einer einfachen Anwendung die etwas
+            Inhalt cacht, inklusive zwei spezifischer Feeds welche zusätzliche Behandlung benötigen
+            um einen korrekten Content-Type Header zu schicken:
+        </para>
+
+        <programlisting language="text"><![CDATA[
+AddType application/rss+xml .xml
+AddType application/atom+xml .xml
+
+RewriteEngine On
+
+RewriteCond %{REQUEST_URI} feed/rss$
+RewriteCond %{DOCUMENT_ROOT}/cached/%{REQUEST_URI}.xml -f
+RewriteRule .* cached/%{REQUEST_URI}.xml [L,T=application/rss+xml]
+
+RewriteCond %{REQUEST_URI} feed/atom$
+RewriteCond %{DOCUMENT_ROOT}/cached/%{REQUEST_URI}.xml -f
+RewriteRule .* cached/%{REQUEST_URI}.xml [L,T=application/atom+xml]
+
+RewriteCond %{DOCUMENT_ROOT}/cached/index.html -f
+RewriteRule ^/*$ cached/index.html [L]
+RewriteCond %{DOCUMENT_ROOT}/cached/%{REQUEST_URI}.(html|xml|json|opml|svg) -f
+RewriteRule .* cached/%{REQUEST_URI}.%1 [L]
+
+RewriteCond %{REQUEST_FILENAME} -s [OR]
+RewriteCond %{REQUEST_FILENAME} -l [OR]
+RewriteCond %{REQUEST_FILENAME} -d
+RewriteRule ^.*$ - [NC,L]
+
+RewriteRule ^.*$ index.php [NC,L]
+]]></programlisting>
+
+        <para>
+            Das obenstehende nimmt an das statische Dateien im Verzeichnis ./public/cached gecacht
+            werden. Wir betrachten die Einstellung dieses Ortes unter "public_dir" weiter unten.
+        </para>
+
+        <para>
+            Durch die Natur des Cachens von statischen Dateien bietet die Backend Klasse zwei
+            zusätzliche Methoden an: <methodname>remove()</methodname> und
+            <methodname>removeRecursively()</methodname>. Beide akzeptieren eine Anfrage URI
+            welche, wenn Sie mit dem "public_dir" in dem statische Dateien gecacht werden verknüpft
+            wird, und eine vor-gespeicherte Erweiterung angehängt wird, entweder den Namen einer
+            statischen Datei anbietet welche zu löschen ist, oder einen Verzeichnispfad welcher
+            rekursiv zu löschen ist. Durch die Einschränkung von
+            <classname>Zend_Cache_Backend_Interface</classname> akzeptieren alle anderen Methoden
+            wie <classname>save()</classname> eine ID welche durch Anwendung von bin2hex() auf eine
+            Anfrage URI berechnet wird.
+        </para>
+
+        <para>
+            Durch das Level an dem das statische Cachen arbeitet ist das statische Dateicaching
+            auf eine einfachere Verwendung mit
+            <classname>Zend_Controller_Action_Helper_Cache</classname> ausgelegt. Dieser Helfer
+            assistiert beim Einstellen welche Aktionen eines Controllers zu cachen sind, mit welchen
+            Tags, und mit welcher Erweiterung. Er bietet auch Methoden für das Entleeren des Caches
+            durch die Anfrage URI oder Tag. Statischen Dateicaching wird auch durch
+            <classname>Zend_Cache_Manager</classname> unterstützt welcher vorkonfigurierte
+            Konfigurationstemplates für den statischen Cache enthält (als
+            Zend_Cache_Manager::PAGECACHE oder "page"). Die Standardwerte können hierbei wie
+            benötigt konfiguriert werden um einen "public_dir" Ort für das Cachen zu setzen, usw.
+        </para>
+
+        <note>
+            <para>
+                Es sollte beachtet werden dass der statische Cache aktuell einen zweiten Cache
+                verwendet um Tags zu speichern (offensichtlich können wir Sie nicht anderswo
+                speichern da bei einem statischen Cache PHP nicht aufgerufen wird wenn er
+                richtig arbeitet). Das ist nur ein standardmäßiger Core Cache, und er sollte ein
+                persistentes Backend wie File oder TwoLevels verwenden (um die Vorteile des
+                Memory Speichers zu verwenden ohne die permanente Persistenz zu opfern). Das
+                Backend enthält die Option "tag_cache" um es zu konfigurieren (das ist
+                obligatorisch), oder die Methode <methodname>setInnerCache()</methodname>.
+            </para>
+        </note>
+
+        <table id="zend.cache.backends.static.table">
+            <title>Statische Backend Optionen</title>
+
+            <tgroup cols="4">
+                <thead>
+                    <row>
+                        <entry>Option</entry>
+                        <entry>Datentyp</entry>
+                        <entry>Standardwert</entry>
+                        <entry>Beschreibung</entry>
+                    </row>
+                </thead>
+
+                <tbody>
+                    <row>
+                        <entry><emphasis>public_dir</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>NULL</entry>
+
+                        <entry>
+                            Verzeichnis in dem statische Dateien zu speichern sind. Es muß im
+                            öffentlichen Verzeichnis existieren.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>file_locking</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>TRUE</constant></entry>
+
+                        <entry>
+                            file_locking aktivieren oder deaktivieren: Kann die Korruption des
+                            Caches unter schlechten Umständen verhindern hilft aber nicht bei
+                            Multithreaded Webservern oder bei <acronym>NFS</acronym> Dateisystemen.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>read_control</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry><constant>TRUE</constant></entry>
+
+                        <entry>
+                            Lesekontrolle aktivieren oder deaktivieren: Aktiviert wird ein
+                            Kontrollschlüssel in die Cachedatei eingebettet und dieser Schlüssel
+                            wird mit dem verglichen der nach dem Lesen berechnet wird.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>read_control_type</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>'crc32'</entry>
+
+                        <entry>
+                            Typ der Lesekontrolle (nur wenn die Lesekontrolle aktiviert ist).
+                            Mögliche Werte sind: 'md5' (am besten aber langsam), 'crc32' (etwas
+                            weniger sicher aber schneller, bessere Wahl), 'adler32' (neue Wahl,
+                            schneller als cec32), 'strlen' für einen reinen Längentest (am
+                            schnellsten).
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>cache_file_umask</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>0700</entry>
+                        <entry>Umask für gecachte Dateien.</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>cache_directory_umask</emphasis></entry>
+                        <entry><type>Integer</type></entry>
+                        <entry>0700</entry>
+                        <entry>Umask für Verzeichnisse welche im public_dir erstellt wurden.</entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>file_extension</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>'.html'</entry>
+
+                        <entry>
+                            Standardmäßige Dateierweiterung für erstellt statische Dateien. Diese
+                            kann im Fluge konfiguriert werden, siehe
+                            <methodname>Zend_Cache_Backend_Static::save()</methodname> obwohl
+                            generell empfohlen wird sich auf
+                            <classname>Zend_Controller_Action_Helper_Cache</classname> zu verlassen
+                            wenn man das macht, weil es ein einfacherer Weg ist als mit Arrays und
+                            der manuellen Serialisierung herumzuspielen.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>index_filename</emphasis></entry>
+                        <entry><type>String</type></entry>
+                        <entry>'index'</entry>
+
+                        <entry>
+                            Wenn eine Anfrage URI nicht genügend Informationen enthält um eine
+                            statische Datei zu erstellen (normalerweise bedeutet dies einen
+                            Indexaufruf, z.B. die URI von '/'), dann wir stattdessen
+                            index_filename verwendet. Deshalb würden '' oder '/' auf 'index.html'
+                            verweisen (in der Annahme das die standardmäßige file_extension '.html'
+                            ist).
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>tag_cache</emphasis></entry>
+                        <entry><type>Object</type></entry>
+                        <entry>NULL</entry>
+
+                        <entry>
+                            Wird verwendet um einen 'inner' Cache zu Setzen der verwendet wird um
+                            Tags zu speichern und Dateierweiterungen mit statischen Dateien zu
+                            verknüpfen. Das MUSS gesetzt sein, oder der statische Cache kann nicht
+                            verfolgt und gemanagt werden.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><emphasis>disable_caching</emphasis></entry>
+                        <entry><type>Boolean</type></entry>
+                        <entry>FALSE</entry>
+
+                        <entry>
+                            Wenn es auf TRUE gesetzt wird, werden statische Dateien nicht gecacht.
+                            Das zwingt alle Anfragen dynamisch zu sein, selbst wenn diese markiert
+                            und in den Controller gecacht sind. Dies ist für das Debuggen nützlich.
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+    </sect2>
 </sect1>
-<!--
-vim:se ts=4 sw=4 et:
-+-->

documentation/manual/de/module_specs/Zend_Cache-Frontends.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 17136 -->
+<!-- EN-Revision: 20725 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.cache.frontends">
     <title>Zend_Cache Frontends</title>
@@ -610,7 +610,23 @@ $res = $cache->foobar2('1', '2');
                 "<acronym>HTTP</acronym> 304 nicht geändert" schicken, wenn der Cache gefunden
                 wurde und wenn der Browser bereits eine gültige Version hat).
             </para>
+
+            <note>
+                <para>
+                    Dieses Frontend arbeitet indem es eine Callback Funktion registriert welche
+                    aufgerufen wird wenn das Buffern der Ausgabe welches es verwendet, gelöscht
+                    wird. Damit dies korrekt arbeitet muss es der letzte Ausgabebuffer in der
+                    Anfrage sein. Um dies zu garantieren muss der Ausgabebuffer, den der Dispatcher
+                    verwendet, deaktiviert sein indem die <methodname>setParam()</methodname>
+                    Methode von <classname>Zend_Controller_Front</classname> verwendet wird. Zum
+                    Beispiel $front->setParam('disableOutputBuffering', true) oder durch hinzufügen
+                    von "resources.frontcontroller.params.disableOutputBuffering = true" zum eigenen
+                    Konfigurationsdatei der Bootstrap (INI angenommen) wenn
+                    <classname>Zend_Application</classname> verwendet wird.
+                </para>
+            </note>
         </sect3>
+
         <sect3 id="zend.cache.frontends.page.options">
             <title>Mögliche Optionen</title>
             <table id="zend.cache.frontends.page.options.table">

documentation/manual/de/module_specs/Zend_Oauth-GettingStarted.xml

@@ -5,18 +5,18 @@
     <title>Beginnen</title>
 
     <para>
-        With the OAuth protocol explained, let's show a simple example of it with
-        source code. Our new Consumer will be handling Twitter Status submissions.
-        To do so, it will need to be registered with Twitter in order to receive
-        an OAuth Consumer Key and Consumer Secret. This are utilised to obtain
-        an Access Token before we use the Twitter API to post a status message.
+        Da das OAuth Protokoll jetzt erklärt wurde sehen wir uns ein einfaches Beispiel mit
+        Quellcode an. Unser neuer Konsument wird Twitter Statusübertragungen verwenden. Um das tun
+        zu können muss er bei Twitter registriert sein um einen OAuth Konsumentenschlüssel und ein
+        Konsumentengeheimnis zu empfangen. Diese werden verwendet um einen Zugriffstoken zu
+        erhalten bevor wir die Twitter API verwenden um eine Statusmeldung zu schicken.
     </para>
 
     <para>
-        Assuming we have obtained a key and secret, we can start the OAuth workflow
-        by setting up a <classname>Zend_Oauth_Consumer</classname> instance as
-        follows passing it a configuration (either an array or <classname>
-        Zend_Config</classname> object).
+        Angenommen wir haben einen Schlüssel und ein Geheimnis bekommen, dann können wir den OAuth
+        Workflow starten indem eine <classname>Zend_Oauth_Consumer</classname> Instanz wie folgt
+        eingerichtet und eine Konfiguration übergeben wird (entweder ein Array oder ein
+        <classname>Zend_Config</classname> Objekt).
     </para>
 
     <programlisting language="php"><![CDATA[
@@ -30,61 +30,61 @@ $consumer = new Zend_Oauth_Consumer($config);
 ]]></programlisting>
 
     <para>
-        The callbackUrl is the URI we want Twitter to request from our server
-        when sending information. We'll look at this later. The siteUrl is the
-        base URI of Twitter's OAuth API endpoints. The full list of endpoints include
-        http://twitter.com/oauth/request_token, http://twitter.com/oauth/access_token,
-        and http://twitter.com/oauth/authorize. The base siteUrl utilises a convention
-        which maps to these three OAuth endpoints (as standard) for requesting a
-        request token, access token or authorization. If the actual endpoints of
-        any service differ from the standard set, these three URIs can be separately
-        set using the methods <methodname>setRequestTokenUrl()</methodname>,
-        <methodname>setAccessTokenUrl()</methodname>,
-        and <methodname>setAuthorizeUrl()</methodname> or the configuration fields requestTokenUrl,
-        accessTokenUrl and authorizeUrl.
+        callbackUrl ist die URI von der wir wollen das Sie Twitter von unserem Server anfragt wenn
+        Informationen gesendet werden. Wir sehen uns das später an. siteUrl ist die Basis URL der
+        OAuth API Endpunkte von Twitter. Die komplette Liste der Endpunkt enthält
+        http://twitter.com/oauth/request_token, http://twitter.com/oauth/access_token und
+        http://twitter.com/oauth/authorize. Die grundsätzliche siteUrl verwendet eine Konvention
+        welche auf diese drei OAuth Endpunkte verweist (als Standard) um einen Anfragetoken, den
+        Zugriffstoken oder die Authorisierung zu erhalten. Wenn sich der aktuelle Endpunkt eines
+        beliebigen Services vom Standardset unterscheidet, dann können diese drei URIs separat
+        gesetzt werden indem die Methoden <methodname>setRequestTokenUrl()</methodname>,
+        <methodname>setAccessTokenUrl()</methodname>, und
+        <methodname>setAuthorizeUrl()</methodname>, oder die Konfigurationsfelder requestTokenUrl,
+        accessTokenUrl und authorizeUrl verwendet werden.
     </para>
 
     <para>
-        The consumerKey and consumerSecret are retrieved from Twitter when your
-        application is registered for OAuth access. These also apply to any OAuth
-        enabled service, so each one will provide a key and secret for your
-        application.
+        consumerKey und consumerSecret werden von Twitter empfangen wenn sich die eigene Anwendung
+        für den OAuth Zugriff registriert. Das wird auch bei jedem OAuth aktivierten Service so
+        angewendet, so dass jeder einen Schlüssel und ein Geheimnis für die eigene Anwendung
+        anbietet.
     </para>
 
     <para>
-        All of these configuration options may be set using method calls simply
-        by converting from, e.g. callbackUrl to setCallbackUrl().
+        Alle diese Konfigurationsoptionen müssen durch Verwendung von Methodenaufrufen gesetzt
+        werden indem Sie einfach von callbackUrl auf setCallbackUrl() konvertiert werden.
     </para>
 
     <para>
-        In addition, you should note several other configuration values not
-        explicitly used: requestMethod and requestScheme. By default, <classname>
-        Zend_Oauth_Consumer</classname> sends requests as POST (except for a
-        redirect which uses GET). The customised client (see later) also includes its
-        authorization by way of a header. Some services may, at their discretion,
-        require alternatives. You can reset the requestMethod (which defaults
-        to Zend_Oauth::POST) to Zend_Oauth::GET, for example, and reset the
-        requestScheme from its default of Zend_Oauth::REQUEST_SCHEME_HEADER to one
-        of Zend_Oauth::REQUEST_SCHEME_POSTBODY or
-        Zend_Oauth::REQUEST_SCHEME_QUERYSTRING. Typically the defaults should work
-        fine apart from some exceptional cases. Please refer to the service provider's
-        documentation for more details.
+        Zusätzlich sollte beachtet werden das verschiedene andere Konfigurationswerte nicht explizit
+        verwendet werden: requestMethod und requestScheme. Standardmäßig sendet
+        <classname>Zend_Oauth_Consumer</classname> Anfragen als POST (ausgenommen bei einer
+        Weiterleitung welche GET verwendet). Der konsumierende Client (siehe später) enthält auch
+        seine Authorisierung in Art eines Headers. Einige Services können, zu Ihrer Diskretion,
+        Alternativen benötigen. Man kann requestMethod (welche standardmäßig Zend_Oauth::POST ist)
+        zum Beispiel auf Zend_Oauth::GET resetieren, und requestScheme von seinem Standardwert
+        Zend_Oauth::REQUEST_SCHEME_HEADER entweder auf Zend_Oauth::REQUEST_SCHEME_POSTBODY oder auf
+        Zend_Oauth::REQUEST_SCHEME_QUERYSTRING. Typischerweise sollten die Standardwerte bis auf ein
+        paar bestimmte Ausnahmen problemlos funktionieren. Für Details sehen Sie bitte in die
+        Dokumentation des Service Providers.
     </para>
 
     <para>
-        The second area of customisation is how <acronym>HMAC</acronym> operates
-        when calculating/comparing them for all requests. This is configured using
-        the signatureMethod configuration field or <methodname>setSignatureMethod()
-        </methodname>. By default this is HMAC-SHA1. You can set it also to a provider's
-        preferred method including RSA-SHA1. For RSA-SHA1, you should also configure
-        RSA private and public keys via the rsaPrivateKey and rsaPublicKey configuration
-        fields or the <methodname>setRsaPrivateKey()</methodname> and
-        <methodname>setRsaPublicKey()</methodname> methods.
+        Der zweite Teil der Anpassung definiert wie <acronym>HMAC</acronym> arbeitet wenn es für
+        alle Anfragen berechnet und verglichen wird. Das wird durch Verwendung des
+        Konfigurationsfeldes signatureMethod oder durch
+        <methodname>setSignatureMethod()</methodname> konfiguriert. Standardmäßig ist es HMAC-SHA1.
+        Man kann es auch auf die vom Provider bevorzugte Methode setzen inklusive RSA-SHA1. Für
+        RSA-SHA1 sollte man die privaten und öffentlichen RSA Schlüssel über die
+        Konfigurationsfelder rsaPrivateKey und rsaPublicKey oder die Methoden
+        <methodname>setRsaPrivateKey()</methodname> und <methodname>setRsaPublicKey()</methodname>
+        konfigurieren.
     </para>
 
     <para>
-        The first part of the OAuth workflow is obtaining a request token. This
-        is accomplished using:
+        Der erste Teil des OAuth Workflows holt sich einen Anfragetoken. Das wird bewerkstelligt
+        indem folgendes verwendet wird:
     </para>
 
     <programlisting language="php"><![CDATA[
@@ -96,16 +96,15 @@ $config = array(
 );
 $consumer = new Zend_Oauth_Consumer($config);
 
-// fetch a request token
+// Holt den Anfragetoken
 $token = $consumer->getRequestToken();
 ]]></programlisting>
 
     <para>
-        The new request token (an instance of <classname>Zend_Oauth_Token_Request
-        </classname>) is unauthorized. In order to exchange it for an authorized
-        token with which we can access the Twitter API, we need the user to authorize
-        it. We accomplish this by redirecting the user to Twitter's authorize endpoint
-        via:
+        Der neue Anfragetoken (eine Instanz von <classname>Zend_Oauth_Token_Request</classname>)
+        ist nicht authorisiert. Um Ihn mit einem authorisierten Token zu wechseln mit dem wir auf
+        die Twitter API zugreifen können, muss Ihn der Benutzer authorisieren. Wir bewerkstelligen
+        das indem der Benutzer auf den Authorisierungsendpunkt von Twitter umgeleitet wird:
     </para>
 
     <programlisting language="php"><![CDATA[
@@ -117,39 +116,40 @@ $config = array(
 );
 $consumer = new Zend_Oauth_Consumer($config);
 
-// fetch a request token
+// Holt den Anfragetoken
 $token = $consumer->getRequestToken();
 
-// persist the token to storage
+// Den token im Speicher fixieren
 $_SESSION['TWITTER_REQUEST_TOKEN'] = serialize($token);
 
-// redirect the user
+// Den Benutzer umleiten
 $consumer->redirect();
 ]]></programlisting>
 
     <para>
-        The user will now be redirected to Twitter. They will be asked to authorize
-        the request token attached to the redirect URI's query string. Assuming they
-        agree, and complete the authorization, they will be again redirected, this
-        time to our Callback URL as previously set (note that the callback URL is
-        also registered with Twitter when we registered our application).
+        Der Benutzer wird jetzt auf Twitter umgeleitet. Er wird gefragt den Anfragetoken zu
+        authorisieren, welcher an den Anfragestring der umgeleiteten URI angehängt ist. Angenommen
+        er akzeptiert und vervollständigt die Authorisierung, dann wird er wieder umgeleitet. Dieses
+        Mal auf unsere Callback URL die vorher gesetzt wurde (Beachte das die Callback URL auch in
+        Twitter registriert wurde als wir unsere Anwendung registriert haben).
     </para>
 
     <para>
-        Before redirecting the user, we should persist the request token to storage.
-        For simplicity I'm just using the user's session, but you can easily use a
-        database for the same purpose, so long as you tie the request token to the
-        current user so it can be retrieved when they return to our application.
+        Bevor der Benutzer umgeleitet wird, sollten wir den Anfragetoken im Speicher fixieren. Der
+        Einfachheit halber verwenden wir nur die Session des Benutzer, aber man kann sehr einfach
+        eine Datenbank für den gleichen Zweck verwenden, solange der Anfragetoken mit dem aktuellen
+        Benutzer verbunden bleibt, damit er empfangen werden kann wenn dieser zu unserer Anwendung
+        zurückkommt.
     </para>
 
     <para>
-        The redirect URI from Twitter will contain an authorized Access Token. We
-        can include code to parse out this access token as follows - this source
-        code would exist within the executed code of our callback URI. Once parsed
-        we can discard the previous request token, and instead persist the access
-        token for future use with the Twitter API. Again, we're simply persisting
-        to the user session, but in reality an access token can have a long lifetime
-        so it should really be stored to a database.
+        Die umgeleitete URI von Twitter enthält einen authorisierten Zugriffstoken. Wir können Code
+        einbauen um diesen Zugriffstoken wie folgt herauszuschneiden - dieser Sourcecode würde im
+        ausgeführten Code unserer Callback URI existieren. Sobald er herausgeschnitten wurde können
+        wir den vorherigen Anfragetoken entfernen, und statt dessen den Zugriffstoken für die
+        zukünftige Verendung mit der API von Twitter fixieren. Nochmals, wir fixieren einfach die
+        Session des Benutzer, aber in Wirklichkeit kann ein Zugriffstoken eine lange Lebenszeit
+        haben, und sollte deshalb wirklich in einer Datenbank abgespeichert werden.
     </para>
 
     <programlisting language="php"><![CDATA[
@@ -165,23 +165,23 @@ if (!empty($_GET) && isset($_SESSION['TWITTER_REQUEST_TOKEN'])) {
     $token = $consumer->getAccessToken($_GET, unserialize($_SESSION['TWITTER_REQUEST_TOKEN']));
     $_SESSION['TWITTER_ACCESS_TOKEN'] = serialize($token);
 
-    // Now that we have an Access Token, we can discard the Request Token
+    // Jetzt da wir den Zugriffstoken haben können wir den Anfragetoken löschen
     $_SESSION['TWITTER_REQUEST_TOKEN'] = null;
 } else {
-    // Mistaken request? Some malfeasant trying something?
-    exit('Invalid callback request. Oops. Sorry.');
+    // Fehlgeschlagene Anfrage? Ein Gauner versucht etwas?
+    exit('Ungültige Callback Anfrage. Oops. Entschuldigung.');
 }
 ]]></programlisting>
 
     <para>
-        Success! We have an authorized access token - so it's time to actually
-        use the Twitter API. Since the access token must be included with every
-        single API request, Zend_Oauth_Consumer offers a ready-to-go HTTP client
-        (a subclass of <classname>Zend_Http_Client</classname>) to use either
-        by itself or by passing it as a custom HTTP Client to another library or
-        component. Here's an example of using it standalone. This can be done
-        from anywhere in your application, so long as you can access the OAuth
-        configuration and retrieve the final authorized access token.
+        Erfolg! Wir haben einen authorisierten Zugriffstoken - zu dieser Zeit verwenden wir schon
+        die API von Twitter. Da dieser Zugriffstoken bei jeder einzelnen API Anfrage enthalten sein
+        muss, bietet Zend_Oauth_Consumer einen fix-fertigen HTTP Client an (eine Subklasse von
+        <classname>Zend_Http_Client</classname>) welcher entweder für sich verwendet werden, oder
+        der als eigener HTTP Client an eine andere Bibliothek oder Komponente übergeben werden kann.
+        Hier ist ein Beispiel für die eigenständige Verwendung. Das kann von überall aus der
+        Anwendung heraus getan werden, solange man Zugriff auf die OAuth Konfiguration hat, und den
+        endgültigen authorisierten Zugriffstoken empfangen kann.
     </para>
 
     <programlisting language="php"><![CDATA[
@@ -192,7 +192,7 @@ $config = array(
     'consumerSecret' => 'tFB0fyWLSMf74lkEu9FTyoHXcazOWpbrAjTCCK48A'
 );
 
-$statusMessage = 'I\'m posting to Twitter using Zend_Oauth!';
+$statusMessage = 'Ich sende über Twitter und verwende Zend_Oauth!';
 
 $token = unserialize($_SESSION['TWITTER_ACCESS_TOKEN']);
 $client = $token->getHttpClient($configuration);
@@ -209,8 +209,10 @@ if (isset($data->text)) {
 echo $result;
 ]]></programlisting>
 
-    <para>As a note on the customised client, this can be passed to most
-    Zend Framework service or other classes using <classname>Zend_Http_Client
-    </classname> displacing the default client they would otherwise use.</para>
-
+    <para>
+        Als Notiz zum eigenen Client, kann dieser an den meisten Services von Zend Framework
+        übergeben werden, oder an andere Klassen welche <classname>Zend_Http_Client</classname>
+        verwenden um damit den Standardclient zu ersetzen welcher andernfalls verwendet werden
+        würde.
+    </para>
 </sect2>

documentation/manual/de/module_specs/Zend_Oauth-SecurityArchitecture.xml

@@ -5,76 +5,88 @@
     <title>Architektur der Sicherheit</title>
 
     <para>
-        OAuth was designed specifically to operate over an insecure HTTP connection and so the use
-        of HTTPS is not required though obviously it would be desireable if available. Should a
-        HTTPS connection be feasible, OAuth offers a signature method implementation called
-        PLAINTEXT which may be utilised. Over a typical unsecured HTTP connection, the use of
-        PLAINTEXT must be avoided and an alternate scheme using. The OAuth specification defines two
-        such signature methods: HMAC-SHA1 and RSA-SHA1. Both are fully supported by
-        <classname>Zend_Oauth</classname>.
+        OAuth wurde speziell designt um über eine unsichere HTTP Verbindung zu arbeiten und deshalb
+        ist die Verwendung von HTTPS nicht notwendig obwohl es natürlich wünschenswert wäre wenn es
+        vorhanden ist. Sollte eine HTTPS Verbindung möglich sein bietet OAuth die Implementation
+        einer Signaturmethode an welche PLAINTEXT heißt und verwendet werden kann. Über eine
+        typische unsichere HTTP Verbindung muss die Verwendung von PLAINTEXT verhindert werden und
+        ein alternatives Schema wird verwendet. Die OAuth Spezifikation definiert zwei solcher
+        Signaturmethoden: HMAC-SHA1 und RSA-SHA1. Beide werden von <classname>Zend_Oauth</classname>
+        vollständig unterstützt.
     </para>
 
     <para>
-        These signature methods are quite easy to understand. As you can imagine, a PLAINTEXT
-        signature method does nothing that bears mentioning since it relies on HTTPS. If you were to
-        use PLAINTEXT over HTTP, you are left with a significant problem: there's no way to be sure
-        that the content of any OAuth enabled request (which would include the OAuth Access Token)
-        was altered en route. This is because unsecured HTTP requests are always at risk of
-        eavesdropping, Man In The Middle (MITM) attacks, or other risks whereby a request can be
-        retooled so to speak to perform tasks on behalf of the attacker by masquerading as the
-        origin application without being noticed by the service provider.
+        Diese Signaturmethoden sind recht einfach zu verstehen. Wie man sich vorstellen kann macht
+        die PLAINTEXT Signaturmethode nichts das erwähnenswert wäre da Sie auf HTTPS aufsetzt. Wenn
+        man aber PLAINTEXT über HTTP verwenden würde, dann würde ein signifikantes Problem bestehen:
+        Es gibt keinen Weg um sicherzustellen das der Inhalt einer OAuth-aktivierten Anfrage (welche
+        einen OAuth Zugriffstoken enthalten würde) beim Routen verändert wurde. Das ist der Fall
+        weil unsichere HTTP Anfragen immer das Risiko des Lauschens, von Man In The Middle (MITM)
+        Attacken, oder andere Risiken haben können in denen eine Anfrage weiterbearbeitet werden
+        könnten und damit Arbeiten im Sinne des Angreifers ausgeführt werden indem sich dieser
+        als Originalanwendung maskiert ohne das dies vom Serviceprovider bemerkt wird.
     </para>
 
     <para>
-        HMAC-SHA1 and RSA-SHA1 alleviate this risk by digitally signing all OAuth requests with the
-        original application's registered Consumer Secret. Assuming only the Consumer and the
-        Provider know what this secret is, a middle-man can alter requests all they wish - but they
-        will not be able to validly sign them and unsigned or invalidly signed requests would be
-        discarded by both parties. Digital signatures therefore offer a guarantee that validly
-        signed requests do come from the expected party and have not been altered en route. This is
-        the core of why OAuth can operate over an unsecure connection.
+        HMAC-SHA1 und RSA-SHA1 vermindern dieses Risiko indem alle OAuth Anfragen mit dem originalen
+        von der Anwendung registrierten Konsumentengeheimnis digital signiert werden. Angenommen nur
+        der Konsument und der Provider wissen was das Geheimnis ist, dann kann ein Mann in der Mitte
+        soviele Anfragen verändern wie er will - aber er wird nicht in der Lage sein sie gültig zu
+        signieren und unsignierte oder ungültig signierte Anfragen würden von beiden Parteien
+        ausgeschieden werden. Digitale Signaturen bieten deshalb eine Garantie das gültig signierte
+        Anfragen von der erwarteten Partei kommen und beim Routen nicht verändert wurden. Das ist
+        der Kern warum OAuth über eine unsichere Verbindung arbeiten kann.
     </para>
 
     <para>
-        How these digital signatures operate depends on the method used, i.e. HMAC-SHA1, RSA-SHA1 or
-        perhaps another method defined by the service provider. HMAC-SHA1 is a simple mechanism
-        which generates a Message Authentication Code (MAC) using a cryptographic hash function
-        (i.e. SHA1) in combination with a secret key known only to the message sender and receiver
-        (i.e. the OAuth Consumer Secret and the authorized Access Key combined). This hashing
-        mechanism is applied to the parameters and content of any OAuth requests which are
-        concatenated into a "base signature string" as defined by the OAuth specification.
+        Wie diese digitalen Signaturen arbeiten hängt von der verwendeten Methode ab, z.B.
+        HMAC-SHA1, RSA-SHA1 oder möglicherweise eine andere Methode welche vom Serviceprovider
+        definiert wird. HMAC-SHA1 ist ein einfacher Mechanismus welcher einen Nachrichten
+        Authentifizierungscode (MAC) erzeugt indem eine kryptographische Hash Funktion (z.B. SHA1)
+        in Verbindung mit einem geheimen Schlüssel verwendet wird der nur dem Sender und dem
+        Empfänger der Nachricht bekannt sind (z.b. das Konsumentengeheimnis von OAuth kombiniert
+        mit dem authorisierten Zugriffsschlüssel). Dieser Hashing Mechanismus wird den Parametern
+        und dem Inhalt aller OAuth Anfragen angehängt und zu einem "Basissignatur String"
+        zusammengefügt wie es von der OAuth Spezifikation definiert ist.
     </para>
 
     <para>
-        RSA-SHA1 operates on similar principles except that the shared secret is, as you would
-        expect, each parties' RSA private key. Both sides would have the other's public key with
-        which to verify digital signatures. This does pose a level of risk compared to HMAC-SHA1
-        since the RSA method does not use the Access Key as part of the shared secret.  This means
-        that if the RSA private key of any Consumer is compromised, then all Access Tokens assigned
-        to that Consumer are also. RSA imposes an all or nothing scheme. In general, the majority of
-        service providers offering OAuth authorization have therefore tended to use HMAC-SHA1 by
-        default, and those who offer RSA-SHA1 may offer fallback support to HMAC-SHA1.
+        RSA-SHA1 operiert auf ähnlichen Prinzipien ausser dass das Geheimnis welches geteilt wird,
+        wie man es erwarten würde, der private RSA Schlüssel jeder Partei ist. Beide Seiten haben
+        den öffentlichen Schlüssel des anderen mit dem die digitalen Signaturen geprüft werden. Das
+        führt verglichen mit HMAC-SHA1 zu einem Riskolevel da die RSA Methode keinen
+        Zugriffsschlüssel als teil des geteilten Geheimnisses verwendet. Dies bedeutet dass wenn
+        der private RSA Schlüssel eines Konsumenten kompromitiert ist, sind es alle zugeordneten
+        Zugriffstoken dieses Konsumenten auch. RSA führt zu einem alles oder gar nichts Schema.
+        Generell tendiert die Mehrheit der Serviceprovider welche OAuth Authorisierung anbieten
+        dazu HMAC-SHA1 standardmäßig zu verwenden, und jene welche RSA-SHA1 anbieten können eine
+        Fallback Unterstützung für HMAC-SHA1 anbieten.
     </para>
 
     <para>
-        While digital signatures add to OAuth's security they are still vulnerable to other forms of
-        attack, such as replay attacks which copy earlier requests which were intercepted and
-        validly signed at that time.  An attacker can now resend the exact same request to a
-        Provider at will at any time and intercept its results. This poses a significant risk but it
-        is quiet simple to defend against - add a unique string (i.e. a nonce) to all requests which
-        changes per request (thus continually changing the signature string) but which can never be
-        reused because Providers actively track used nonces within the a certain window defined by
-        the timestamp also attached to a request. You might first suspect that once you stop
-        tracking a particular nonce, the replay could work but this ignore the timestamp which can
-        be used to determine a request's age at the time it was validly signed. One can assume that
-        a week old request used in an attempted replay should be summarily discarded!
+        Wärend digitale Signaturen zur Sicherheit von OAuth beitragen sind Sie trotzdem für andere
+        Formen von Attacken angreifbar, wie Replay Attacken welche vorhergehende Anfragen
+        aufgezeichnet und zu einer Zeit geprüft und signiert wurden. Ein Angreifen können jetzt
+        exakt die gleiche Anfrage zum Provider wie er will und zu jeder Zeit senden und seine
+        Ergebnisse auffangen. Das führt zu einem signifikanten Risiko aber es ist recht einfach
+        sich davor zu schützen - einen eindeutigen String (z.b. eine Nonce) bei allen Anfragen
+        hinzufügen welcher sich bei jeder Anfrage ändert (dies verändert laufend den Signaturstring)
+        kann aber niemals wiederverwendet werden weil Provider verwendete Nonces zusammen mit einem
+        bestimmten Fenster aktiv verfolgen welches vom Timestamp definiert wird der einer Anfrage
+        auch angehängt wird. Man würde erwarten das wenn die Verfolgung einer bestimmten Nonce
+        gestoppt wird, das wiederabspielen funktionieren würde, aber das ignoriert den Timestamp
+        der verwendet werden kann um das Alter einer Anfrage zu ermitteln zu welcher Sie digital
+        signiert wurde. Man kann also annehmen dass die eine Woche alte Anfrage in einem
+        Wiederholungsversuch abgespielt wird, auf ähnliche Weise verworfen wird.
     </para>
 
     <para>
-        As a final point, this is not an exhaustive look at the security architecture in OAuth. For
-        example, what if HTTP requests which contain both the Access Token and the Consumer Secret
-        are eavesdropped? The system relies on at one in the clear transmission of each unless HTTPS
-        is active, so the obvious conclusion is that where feasible HTTPS is to be preferred leaving
-        unsecured HTTP in place only where it is not possible or affordable to do so.
+        Als letzter Punkt erwähnt, ist dies keine exzessive Ansicht der Sicherheitsarchitektur in
+        OAuth. Was passiert zum Beispiel wenn HTTP Anfragen welche sowohl den Zugriffstoken als auch
+        das Geheimnis des Konsumenten enthalten abgehört werden? Das System ist auf der einen Seite
+        von einer klaren Übermittlung von allem abhängig solange HTTPS nicht aktiv ist. Deshalb ist
+        die naheliegende Feststellung das HTTPS, dort wo es möglich ist zu bevorzugen ist und HTTP
+        nur an solchen Orten eingesetzt wird so es nicht anders möglich oder nicht erschwinglich
+        ist.
     </para>
 </sect2>

documentation/manual/de/module_specs/Zend_Queue-Adapters.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 20115 -->
+<!-- EN-Revision: 20714 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.queue.adapters">
     <title>Adapter</title>
@@ -419,7 +419,7 @@ $queue = new Zend_Queue('Db', $options);
             <para>
                 Das Datenbank <acronym>SQL</acronym> Statement
                 <emphasis>CREATE TABLE ( ... )</emphasis> kann in
-                <filename>Zend/Queue/Adapter/Db/queue.sql</filename> gefunden werden.
+                <filename>Zend/Queue/Adapter/Db/mysql.sql</filename> gefunden werden.
             </para>
         </sect3>
 

documentation/manual/de/module_specs/Zend_Serializer-Adapter.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 20533 -->
+<!-- EN-Revision: 20686 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.serializer.adapter">
     <title>Zend_Serializer_Adapter</title>
@@ -85,7 +85,7 @@
             Vorhandene Optionen sind:
         </para>
 
-        <table>
+        <table id="zend.serializer.adapter.wddx.table.options">
             <title>Optionen für Zend_Serializer_Adapter_Wddx</title>
 
             <tgroup cols="4">
@@ -132,7 +132,7 @@
             Vorhandene Optionen sind:
         </para>
 
-        <table>
+        <table id="zend.serializer.adapter.json.table.options">
             <title>Optionen für Zend_Serializer_Adapter_Json</title>
 
             <tgroup cols="4">
@@ -219,7 +219,7 @@
             Vorhandene Optionen sind:
         </para>
 
-        <table>
+        <table id="zend.serializer.adapter.pythonpickle.table.options">
             <title>Optionen für Zend_Serializer_Adapter_PythonPickle</title>
 
             <tgroup cols="4">
@@ -256,7 +256,7 @@
             Der Wechsel von Datentypen (PHP zu Python) findet wie folgt statt:
         </para>
 
-        <table>
+        <table id="zend.serializer.adapter.pythonpickle.table.php2python">
             <title>Wechseln des Datentyps (PHP zu Python)</title>
 
             <tgroup cols="2">
@@ -324,7 +324,7 @@
             Der Wechsel von Datentypen (Python zu PHP) findet wie folgt statt:
         </para>
 
-        <table>
+        <table id="zend.serializer.adapter.pythonpickle.table.python2php">
             <title>Wechseln des Datentyps (PHP zu Python)</title>
 
             <tgroup cols="2">

documentation/manual/de/module_specs/Zend_Serializer-Introduction.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 20225 -->
+<!-- EN-Revision: 20733 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.serializer.introduction">
     <title>Einführung</title>
@@ -81,7 +81,7 @@ try {
         übergeben werden.
     </para>
 
-    <sect2 id="zend.serializer.introduction.example.static.php">
+    <example id="zend.serializer.introduction.example.static.php">
         <title>Das statische Interface von Zend_Serializer verwenden</title>
 
         <para>
@@ -105,5 +105,5 @@ try {
     echo $e;
 }
 ]]></programlisting>
-    </sect2>
+    </example>
 </sect1>

documentation/manual/de/module_specs/Zend_Service_WindowsAzure.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 20657 -->
+<!-- EN-Revision: 20675 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.service.windowsazure" xmlns:xi="http://www.w3.org/2001/XInclude">
     <title>Zend_Service_WindowsAzure</title>
@@ -113,5 +113,9 @@
             Windows Azure zugreifen, unabhängig davon ob Sie auf der Windows Azure Plattform oder
             auf einem unabhängigen Web Server gehostet wird.
         </para>
-  </sect2>
+    </sect2>
+
+    <xi:include href="Zend_Service_WindowsAzure_Blob.xml" />
+    <xi:include href="Zend_Service_WindowsAzure_Table.xml" />
+    <xi:include href="Zend_Service_WindowsAzure_Queue.xml" />
 </sect1>

documentation/manual/de/module_specs/Zend_Service_WindowsAzure_Blob.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19991 -->
+<!-- EN-Revision: 20679 -->
 <!-- Reviewed: no -->
-<sect1 id="zend.service.windowsazure.storage.blob">
+<sect2 id="zend.service.windowsazure.storage.blob">
     <title>Zend_Service_WindowsAzure_Storage_Blob</title>
 
     <para>
@@ -16,7 +16,7 @@
         natives PHP Interface zum Speicher Account zu bieten.
     </para>
 
-    <sect2 id="zend.service.windowsazure.storage.blob.api">
+    <sect3 id="zend.service.windowsazure.storage.blob.api">
         <title>API Beispiele</title>
 
         <para>
@@ -25,7 +25,7 @@
             Download Paket vorhanden sowie in der detailierten API Dokumentation dieser Features.
         </para>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.api.create-container">
+        <sect4 id="zend.service.windowsazure.storage.blob.api.create-container">
             <title>Erstellung einer Speicher Containers</title>
 
             <para>
@@ -33,7 +33,7 @@
                 Speicher erstellt werden.
             </para>
 
-            <example id="zend.service.windowsazure.storage.blob.api.create-container">
+            <example id="zend.service.windowsazure.storage.blob.api.create-container.example">
                 <title>Erstellung eines Speicher Containers</title>
 
                 <programlisting language="php"><![CDATA[
@@ -43,9 +43,9 @@ $result = $storageClient->createContainer('testcontainer');
 echo 'Der Name des Containers ist: ' . $result->Name;
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.api.delete-container">
+        <sect4 id="zend.service.windowsazure.storage.blob.api.delete-container">
             <title>Löschen eines Speicher Containers</title>
 
             <para>
@@ -53,7 +53,7 @@ echo 'Der Name des Containers ist: ' . $result->Name;
                 Speicher entfernt werden.
             </para>
 
-            <example id="zend.service.windowsazure.storage.blob.api.delete-container">
+            <example id="zend.service.windowsazure.storage.blob.api.delete-container.example">
                 <title>Löschen eines Speicher Containers</title>
 
                 <programlisting role="php"><![CDATA[
@@ -61,9 +61,9 @@ $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
 $storageClient->deleteContainer('testcontainer');
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.api.storing-blob">
+        <sect4 id="zend.service.windowsazure.storage.blob.api.storing-blob">
             <title>Speichern eines Blobs</title>
 
             <para>
@@ -86,9 +86,9 @@ $result = $storageClient->putBlob(
 echo 'Der Name des Blobs ist: ' . $result->Name;
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.api.copy-blob">
+        <sect4 id="zend.service.windowsazure.storage.blob.api.copy-blob">
             <title>Kopieren eines Blobs</title>
 
             <para>
@@ -99,7 +99,7 @@ echo 'Der Name des Blobs ist: ' . $result->Name;
                 erstellt worden sein muss.
             </para>
 
-            <example id="zend.service.windowsazure.storage.blob.api.copy-blob">
+            <example id="zend.service.windowsazure.storage.blob.api.copy-blob.example">
                 <title>Kopieren eines Blobs</title>
 
                 <programlisting language="php"><![CDATA[
@@ -113,9 +113,9 @@ $result = $storageClient->copyBlob(
 echo 'Der Name des kopierten Blobs ist: ' . $result->Name;
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.api.download-blob">
+        <sect4 id="zend.service.windowsazure.storage.blob.api.download-blob">
             <title>Herunterladen eines Blobs</title>
 
             <para>
@@ -125,7 +125,7 @@ echo 'Der Name des kopierten Blobs ist: ' . $result->Name;
                 hochgeladen sein muss.
             </para>
 
-            <example id="zend.service.windowsazure.storage.blob.api.download-blob">
+            <example id="zend.service.windowsazure.storage.blob.api.download-blob.example">
                 <title>Herunterladen eines Blobs</title>
 
                 <programlisting language="php"><![CDATA[
@@ -137,9 +137,9 @@ $storageClient->getBlob(
 );
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.api.public-blob">
+        <sect4 id="zend.service.windowsazure.storage.blob.api.public-blob">
             <title>Einen Blob öffentlich verfügbar machen</title>
 
             <para>
@@ -156,7 +156,7 @@ $storageClient->getBlob(
                 hierfür bereits vorher erstellt worden sein muss.
             </para>
 
-            <example id="zend.service.windowsazure.storage.blob.api.public-blob">
+            <example id="zend.service.windowsazure.storage.blob.api.public-blob.example">
                 <title>Einen Blob öffentlich zugänglich machen</title>
 
                 <programlisting language="php"><![CDATA[
@@ -166,10 +166,10 @@ $storageClient = new Zend_Service_WindowsAzure_Storage_Blob();
 $storageClient->setContainerAcl('testcontainer', Zend_Service_WindowsAzure_Storage_Blob::ACL_PUBLIC);
 ]]></programlisting>
             </example>
-        </sect3>
-    </sect2>
+        </sect4>
+    </sect3>
 
-    <sect2 id="zend.service.windowsazure.storage.blob.root">
+    <sect3 id="zend.service.windowsazure.storage.blob.root">
         <title>Stamm Container</title>
 
         <para>
@@ -186,9 +186,9 @@ $storageClient->setContainerAcl('testcontainer', Zend_Service_WindowsAzure_Stora
             Stamm Container sollten ausgeführt werden indem der Containernamen auf
             <varname>$root</varname> gesetzt wird.
         </para>
-    </sect2>
+    </sect3>
 
-    <sect2 id="zend.service.windowsazure.storage.blob.wrapper">
+    <sect3 id="zend.service.windowsazure.storage.blob.wrapper">
         <title>Blob Speicher Stream Wrapper</title>
 
         <para>
@@ -196,7 +196,7 @@ $storageClient->setContainerAcl('testcontainer', Zend_Service_WindowsAzure_Stora
             Speicher Clients als PHP File Stream Wrapper. Der Blob Speicher Stream Wrapper bietet
             Unterstützung für die Verwendung von regulären Datei Operationen auf dem Windows Azure
             Blob Speicher. Zum Beispiel kan eine Datei vom Windows Azure Blob Speicher aus mit der
-            Funktion <functionname>fopen()</functionname> geöffnet werden:
+            Funktion <methodname>fopen()</methodname> geöffnet werden:
         </para>
 
         <example id="zend.service.windowsazure.storage.blob.wrapper.sample">
@@ -236,9 +236,9 @@ $storageClient->registerStreamWrapper('blob://');
             Um den Stream Wrapper zu deregistrieren kann die Methode
             <methodname>unregisterStreamWrapper()</methodname> verwendet werden.
         </para>
-    </sect2>
+    </sect3>
 
-    <sect2 id="zend.service.windowsazure.storage.blob.sharedaccesssig">
+    <sect3 id="zend.service.windowsazure.storage.blob.sharedaccesssig">
         <title>Shared Access Signaturen</title>
 
         <para>
@@ -264,7 +264,7 @@ http://phpstorage.blob.core.windows.net/phpazuretestshared1?st=2009-08-17T09%3A0
             Accounts "phpstorage".
         </para>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.sharedaccesssig.generate">
+        <sect4 id="zend.service.windowsazure.storage.blob.sharedaccesssig.generate">
             <title>Erstellen einer Shared Access Signature</title>
 
             <para>
@@ -319,9 +319,9 @@ $sharedAccessUrl = storageClient->generateSharedAccessUrl(
 );
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.blob.sharedaccesssig.consume">
+        <sect4 id="zend.service.windowsazure.storage.blob.sharedaccesssig.consume">
             <title>Arbeiten mit Shared Access Signaturen von anderen</title>
 
             <para>
@@ -369,6 +369,6 @@ $storageClient->putBlob(
                 vorhanden war, hat die Windows Azure SDK für PHP diese Zugriffsrechte ausgewählt um
                 die Anfrage auf den Windows Azure Blob Speicher durchzuführen.
             </para>
-        </sect3>
-    </sect2>
-</sect1>
+        </sect4>
+    </sect3>
+</sect2>

documentation/manual/de/module_specs/Zend_Service_WindowsAzure_Queue.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19992 -->
+<!-- EN-Revision: 20679 -->
 <!-- Reviewed: no -->
-<sect1 id="zend.service.windowsazure.storage.queue">
+<sect2 id="zend.service.windowsazure.storage.queue">
     <title>Zend_Service_WindowsAzure_Storage_Queue</title>
 
     <para>
@@ -24,7 +24,7 @@
         um ein natives PHP Interface zum Speicher Account zu bieten.
     </para>
 
-    <sect2 id="zend.service.windowsazure.storage.queue.api">
+    <sect3 id="zend.service.windowsazure.storage.queue.api">
         <title>API Beispiele</title>
 
         <para>
@@ -34,7 +34,7 @@
             dieser Features.
         </para>
 
-        <sect3 id="zend.service.windowsazure.storage.queue.api.create-queue">
+        <sect4 id="zend.service.windowsazure.storage.queue.api.create-queue">
             <title>Erstellung einer Queue</title>
 
             <para>
@@ -52,9 +52,9 @@ $result = $storageClient->createQueue('testqueue');
 echo 'Der Name der Queue ist: ' . $result->Name;
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.queue.api.delete-queue">
+        <sect4 id="zend.service.windowsazure.storage.queue.api.delete-queue">
             <title>Löschen einer Queue</title>
 
             <para>
@@ -70,9 +70,9 @@ $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
 $storageClient->deleteQueue('testqueue');
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.queue.api.storing-queue">
+        <sect4 id="zend.service.windowsazure.storage.queue.api.storing-queue">
             <title>Hinzufügen einer Nachricht zu einer Queue</title>
 
             <para>
@@ -92,9 +92,9 @@ $storageClient = new Zend_Service_WindowsAzure_Storage_Queue();
 $storageClient->putMessage('testqueue', 'Das ist eine Testnachricht', 3600);
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.queue.api.read-queue">
+        <sect4 id="zend.service.windowsazure.storage.queue.api.read-queue">
             <title>Lesen einer Nachricht von einer Queue</title>
 
             <para>
@@ -143,9 +143,9 @@ foreach ($messages as $message) {
 }
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.queue.api.peek-queue">
+        <sect4 id="zend.service.windowsazure.storage.queue.api.peek-queue">
             <title>Prüfen ob es Nachrichten in der Queue gibt</title>
 
             <para>
@@ -177,6 +177,6 @@ foreach ($messages as $message) {
                 können. Um das zu tun sollte stattdessen <methodname>getMessages()</methodname>
                 verwendet werden.
             </para>
-        </sect3>
-    </sect2>
-</sect1>
+        </sect4>
+    </sect3>
+</sect2>

documentation/manual/de/module_specs/Zend_Service_WindowsAzure_Table.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19993 -->
+<!-- EN-Revision: 20679 -->
 <!-- Reviewed: no -->
-<sect1 id="zend.service.windowsazure.storage.table">
+<sect2 id="zend.service.windowsazure.storage.table">
     <title>Zend_Service_WindowsAzure_Storage_Table</title>
 
     <para>
@@ -27,7 +27,7 @@
         Produktions Tabellen Speichern verwendet zu werden.
     </para>
 
-    <sect2 id="zend.service.windowsazure.storage.table.api">
+    <sect3 id="zend.service.windowsazure.storage.table.api">
         <title>Operationen auf Tabellen</title>
 
         <para>
@@ -35,7 +35,7 @@
             werden können.
         </para>
 
-        <sect3 id="zend.service.windowsazure.storage.table.api.create">
+        <sect4 id="zend.service.windowsazure.storage.table.api.create">
             <title>Erstellung einer Tabelle</title>
 
             <para>
@@ -55,9 +55,9 @@ $result = $storageClient->createTable('testtable');
 echo 'Der neue Name der Tabelle ist: ' . $result->Name;
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.table.api.list">
+        <sect4 id="zend.service.windowsazure.storage.table.api.list">
             <title>Ausgeben aller Tabellen</title>
 
             <para>
@@ -78,10 +78,10 @@ foreach ($result as $table) {
 }
 ]]></programlisting>
             </example>
-        </sect3>
-    </sect2>
+        </sect4>
+    </sect3>
 
-    <sect2 id="zend.service.windowsazure.storage.table.entities">
+    <sect3 id="zend.service.windowsazure.storage.table.entities">
         <title>Operationen auf Entitäten</title>
 
         <para>
@@ -150,7 +150,7 @@ class SampleEntity extends Zend_Service_WindowsAzure_Storage_TableEntity
             <classname>Zend_Service_WindowsAzure_Storage_DynamicTableEntity</classname> arbeitet.
         </para>
 
-        <sect3 id="zend.service.windowsazure.storage.table.entities.enforced">
+        <sect4 id="zend.service.windowsazure.storage.table.entities.enforced">
             <title>Erzwungene Schema Entitäten</title>
 
             <para>
@@ -330,9 +330,9 @@ public $Age;
                     </para>
                 </listitem>
             </itemizedlist>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.table.entities.dynamic">
+        <sect4 id="zend.service.windowsazure.storage.table.entities.dynamic">
             <title>Entitäten ohne erzwungenes Schema (a.k.a. DynamicEntity)</title>
 
             <para>
@@ -430,10 +430,10 @@ $target->setAzurePropertyType('Age', 'Edm.Int64');
             </para>
         </sect3>
 
-        <sect3 id="zend.service.windowsazure.storage.table.entities.api">
+        <sect4 id="zend.service.windowsazure.storage.table.entities.api">
             <title>API Beispiele für Entitäten</title>
 
-            <sect4 id="zend.service.windowsazure.storage.table.entities.api.insert">
+            <sect5 id="zend.service.windowsazure.storage.table.entities.api.insert">
                 <title>Eine Entität hinzufügen</title>
 
                 <para>
@@ -461,9 +461,9 @@ echo 'Zeitpunkt: ' . $result->getTimestamp() . "\n";
 echo 'Etag: ' . $result->getEtag() . "\n";
 ]]></programlisting>
                 </example>
-            </sect4>
+            </sect5>
 
-            <sect4 id="zend.service.windowsazure.storage.table.entities.api.retrieve-by-id">
+            <sect5 id="zend.service.windowsazure.storage.table.entities.api.retrieve-by-id">
                 <title>Empfangen einer Entität durch Partitionsschlüssel und Zeilenschlüssel</title>
 
                 <para>
@@ -486,9 +486,9 @@ $entity= $storageClient->retrieveEntityById(
 );
 ]]></programlisting>
                 </example>
-            </sect4>
+            </sect5>
 
-            <sect4 id="zend.service.windowsazure.storage.table.entities.api.updating">
+            <sect5 id="zend.service.windowsazure.storage.table.entities.api.updating">
                 <title>Eine Entität aktualisieren</title>
 
                 <para>
@@ -537,9 +537,9 @@ $entity->Name = 'Neuer Name';
 $result = $storageClient->updateEntity('testtable', $entity, true);
 ]]></programlisting>
                 </example>
-            </sect4>
+            </sect5>
 
-            <sect4 id="zend.service.windowsazure.storage.table.entities.api.delete">
+            <sect5 id="zend.service.windowsazure.storage.table.entities.api.delete">
                 <title>Löschen einer Entität</title>
 
                 <para>
@@ -561,10 +561,10 @@ $entity = $storageClient->retrieveEntityById(
 $result = $storageClient->deleteEntity('testtable', $entity);
 ]]></programlisting>
                 </example>
-            </sect4>
-        </sect3>
+            </sect5>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.table.entities.querying">
+        <sect4 id="zend.service.windowsazure.storage.table.entities.querying">
             <title>Durchführen von Abfragen</title>
 
             <para>
@@ -641,9 +641,9 @@ foreach ($entities as $entity) {
 }
 ]]></programlisting>
             </example>
-        </sect3>
+        </sect4>
 
-        <sect3 id="zend.service.windowsazure.storage.table.entities.batch">
+        <sect4 id="zend.service.windowsazure.storage.table.entities.batch">
             <title>Batch Operationen</title>
 
             <para>
@@ -681,10 +681,10 @@ foreach ($entities as $entity) {
 $batch->commit();
 ]]></programlisting>
             </example>
-        </sect3>
-    </sect2>
+        </sect4>
+    </sect3>
 
-    <sect2 id="zend.service.windowsazure.storage.table.sessionhandler">
+    <sect3 id="zend.service.windowsazure.storage.table.sessionhandler">
         <title>Session Handler für Tabellen Speicher</title>
 
         <para>
@@ -757,8 +757,8 @@ if (!isset($_SESSION['firstVisit'])) {
             <para>
                 Der <classname>Zend_Service_WindowsAzure_SessionHandler</classname> Session Handler
                 sollte registriert werden bevor ein Aufruf zu
-                <functionname>session_start()</functionname> durchgeführt wird!
+                <methodname>session_start()</methodname> durchgeführt wird!
             </para>
         </warning>
-    </sect2>
-</sect1>
+    </sect3>
+</sect2>

documentation/manual/de/module_specs/Zend_Tool-Extending.xml

@@ -2,7 +2,7 @@
 <!-- EN-Revision: 19778 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.tool.extending">
-    <title>Extending Zend_Tool</title>
+    <title>Zend_Tool erweitern</title>
 
     <sect2 id="zend.tool.extending.overview">
         <title>Übersicht über Zend_Tool</title>