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

   1 <?xml version="1.0" encoding="utf-8"?>
   2 <!-- EN-Revision: 22140 -->
   3 <!-- Reviewed: no -->
   4 <sect1 id="zend.cache.backends">
   5     <title>Les backends Zend_Cache</title>
   6
   7     <para>
   8         Il existe deux types de backends&#160;: les standards et les étendus. Bien sûr, les
   9         backends étendus offrent des fonctionnalités supplémentaires.
  10     </para>
  11
  12     <sect2 id="zend.cache.backends.file">
  13         <title>Zend_Cache_Backend_File</title>
  14
  15         <para>
  16             Ces backends (étendus) stockent les enregistrements de cache dans des fichiers
  17             (dans un dossier choisi).
  18         </para>
  19
  20         <para>Les options disponibles sont&#160;:</para>
  21
  22         <table id="zend.cache.backends.file.table">
  23             <title>Options du backend File</title>
  24
  25             <tgroup cols="4">
  26                 <thead>
  27                     <row>
  28                         <entry>Option</entry>
  29                         <entry>Type de données</entry>
  30                         <entry>Valeur par défaut</entry>
  31                         <entry>Description</entry>
  32                     </row>
  33                 </thead>
  34                 <tbody>
  35                     <row>
  36                         <entry><emphasis>cache_dir</emphasis></entry>
  37                         <entry><type>String</type></entry>
  38                         <entry><filename>/tmp/</filename></entry>
  39                         <entry>Répertoire où stocker les fichiers de cache</entry>
  40                     </row>
  41                     <row>
  42                         <entry><emphasis>file_locking</emphasis></entry>
  43                         <entry><type>Boolean</type></entry>
  44                         <entry><constant>TRUE</constant></entry>
  45                         <entry>
  46                             Active / désactive le verrou de fichier&#160;: peut éviter la
  47                             corruption du cache dans de mauvaises circonstances, mais il n'aide en
  48                             rien sur des serveur multithreadés ou sur des systèmes de fichier
  49                             <acronym>NFS</acronym>...
  50                         </entry>
  51                     </row>
  52                     <row>
  53                         <entry><emphasis>read_control</emphasis></entry>
  54                         <entry><type>Boolean</type></entry>
  55                         <entry><constant>TRUE</constant></entry>
  56                         <entry>
  57                             Active / désactive le contrôle de lecture&#160;: si activé, une clé
  58                             de contrôle est embarquée dans le fichier de cache et cette clé est
  59                             comparée avec celle calculée après la lecture.
  60                         </entry>
  61                     </row>
  62                     <row>
  63                         <entry><emphasis>read_control_type</emphasis></entry>
  64                         <entry><type>String</type></entry>
  65                         <entry>'crc32'</entry>
  66                         <entry>
  67                             Type de contrôle de lecture (seulement si le contrôle de lecture
  68                             est activé). Les valeurs disponibles sont&#160;: "md5" (meilleur mais
  69                             plus lent), "crc32" (un peu moins sécurisé, mais plus rapide, c'est un
  70                             meilleur choix), "adler32" (nouveau choix, plus rapide que
  71                             crc32),"strlen" pour un test de longueur uniquement (le plus
  72                             rapide).
  73                         </entry>
  74                     </row>
  75                     <row>
  76                         <entry><emphasis>hashed_directory_level</emphasis></entry>
  77                         <entry><type>Integer</type></entry>
  78                         <entry>0</entry>
  79                         <entry>
  80                             Niveau de structure du hash du répertoire&#160;: 0 signifie "pas de
  81                             hashage de la structure du répertoire", 1 signifie "un niveau de
  82                             répertoire", 2 signifie "deux niveaux"... Cette option peut accélérer
  83                             le cache seulement lorsque vous avez plusieurs centaines de fichiers de
  84                             cache. Seuls des tests de performance spécifiques peuvent vous aider à
  85                             choisir la meilleure valeur pour vous. 1 ou 2, peut-être un bon
  86                             départ.
  87                         </entry>
  88                     </row>
  89                     <row>
  90                         <entry><emphasis>hashed_directory_umask</emphasis></entry>
  91                         <entry><type>Integer</type></entry>
  92                         <entry>0700</entry>
  93                         <entry>Umask pour l'arborescence</entry>
  94                     </row>
  95                     <row>
  96                         <entry><emphasis>file_name_prefix</emphasis></entry>
  97                         <entry><type>String</type></entry>
  98                         <entry>'zend_cache'</entry>
  99                         <entry>
 100                             Préfixe pour les fichiers mis en cache&#160;; faîtes très attention
 101                             avec cette option, en cas de valeur trop générique dans le dossier de
 102                             cache (comme <filename>/tmp</filename>), ceci peut causer des désastres
 103                             lors du nettoyage du cache.
 104                         </entry>
 105                     </row>
 106                     <row>
 107                         <entry><emphasis>cache_file_umask</emphasis></entry>
 108                         <entry><type>Integer</type></entry>
 109                         <entry>0700</entry>
 110                         <entry>umask des fichiers de cache.</entry>
 111                     </row>
 112                     <row>
 113                         <entry><emphasis>metatadatas_array_max_size</emphasis></entry>
 114                         <entry><type>Integer</type></entry>
 115                         <entry>100</entry>
 116                         <entry>
 117                             Taille maximale interne pour les tableaux de métadonnées (ne
 118                             changez pas cette valeur à moins de bien savoir ce que vous
 119                             faîtes).
 120                         </entry>
 121                     </row>
 122                 </tbody>
 123             </tgroup>
 124         </table>
 125     </sect2>
 126
 127     <sect2 id="zend.cache.backends.sqlite">
 128         <title>Zend_Cache_Backend_Sqlite</title>
 129
 130         <para>
 131             Ce backend (étendu) stocke les enregistrements de cache dans une base de donnée
 132             SQLite.
 133         </para>
 134
 135         <para>Les options disponibles sont&#160;:</para>
 136
 137         <table id="zend.cache.backends.sqlite.table">
 138             <title>Options du backend Sqlite</title>
 139
 140             <tgroup cols="4">
 141                 <thead>
 142                     <row>
 143                         <entry>Option</entry>
 144                         <entry>Type de données</entry>
 145                         <entry>Valeur par défaut</entry>
 146                         <entry>Description</entry>
 147                     </row>
 148                 </thead>
 149                 <tbody>
 150                     <row>
 151                         <entry><emphasis>cache_db_complete_path (obligatoire)</emphasis></entry>
 152                         <entry><type>String</type></entry>
 153                         <entry><constant>NULL</constant></entry>
 154                         <entry>
 155                             Le chemin complet (nom du fichier inclus) de la base de donnée
 156                             SQLite
 157                         </entry>
 158                     </row>
 159                     <row>
 160                         <entry><emphasis>automatic_vacuum_factor</emphasis></entry>
 161                         <entry><type>Integer</type></entry>
 162                         <entry>10</entry>
 163                         <entry>
 164                             Désactive / Active le processus de vidange automatique. Celui-ci
 165                             défragmente le fichier de base de données (et diminue sa taille) quand
 166                             <methodname>clean()</methodname> ou <methodname>delete()</methodname>
 167                             est appelé&#160;: 0 pour une vidange automatique&#160;; 1
 168                             pour une vidange systématique (quand <methodname>clean()</methodname>
 169                             ou <methodname>delete()</methodname> est
 170                             appelé)&#160;; x (entier) &gt; 1 pour une vidange automatique
 171                             aléatoirement 1 fois sur x <methodname>clean()</methodname> ou
 172                             <methodname>delete()</methodname>.
 173                         </entry>
 174                     </row>
 175                 </tbody>
 176             </tgroup>
 177         </table>
 178     </sect2>
 179
 180     <sect2 id="zend.cache.backends.memcached">
 181         <title>Zend_Cache_Backend_Memcached</title>
 182
 183         <para>
 184             Ce backend (étendu) stocke les enregistrements de cache dans un serveur memcached.
 185             <ulink url="http://www.danga.com/memcached/">Memcached</ulink> est un système de cache
 186             en mémoire distribuée, de haute performance. Pour utiliser ce backend, vous devez avoir
 187             un démon memcached et l'extension
 188             <ulink url="http://pecl.php.net/package/memcache"><acronym>PECL</acronym>
 189             memcache</ulink>.
 190         </para>
 191
 192         <para>
 193             Attention : avec ce backend, les balises ("tags") ne sont pas supportées pour le
 194             moment comme l'argument "doNotTestCacheValidity=true".
 195         </para>
 196
 197         <para>Les options disponibles sont&#160;:</para>
 198
 199         <table id="zend.cache.backends.memcached.table">
 200             <title>Options du backend Memcached</title>
 201
 202             <tgroup cols="4">
 203                 <thead>
 204                     <row>
 205                         <entry>Option</entry>
 206                         <entry>Type de données</entry>
 207                         <entry>Valeur par défaut</entry>
 208                         <entry>Description</entry>
 209                     </row>
 210                 </thead>
 211                 <tbody>
 212                     <row>
 213                         <entry><emphasis>servers</emphasis></entry>
 214                         <entry><type>Array</type></entry>
 215                         <entry>
 216                             <command>array(array('host' => 'localhost', 'port' => 11211,
 217                                 'persistent' => true, 'weight' => 1, 'timeout' => 5,
 218                                 'retry_interval' => 15, 'status' => true,
 219                                 'failure_callback' => '' ))</command>
 220                         </entry>
 221                         <entry>
 222                             Un tableau de serveurs memcached&#160;; chaque serveur memcached est
 223                             décrit par un tableau associatif&#160;: 'host' =&gt; (string)&#160;: le
 224                             nom du serveur memcached, 'port' =&gt; (int)&#160;: le port du serveur
 225                             memcached, 'persistent' =&gt; (bool)&#160;: utilisation ou pas des
 226                             connexions persistantes pour ce serveur memcached, 'weight' =&gt;
 227                             (int)&#160;: le poids du serveur memcached, 'timeout' =&gt;
 228                             (int)&#160;: le time out du serveur memcached, 'retry_interval' =&gt;
 229                             (int)&#160;: l'intervalle avant réexécution du serveur memcached,
 230                             'status' =&gt; (bool)&#160;: le statut du serveur memcached,
 231                             'failure_callback' =&gt; (callback)&#160;: le failure_callback d'échec
 232                             du serveur memcached.
 233                         </entry>
 234                     </row>
 235                     <row>
 236                         <entry><emphasis>compression</emphasis></entry>
 237                         <entry><type>Boolean</type></entry>
 238                         <entry><constant>FALSE</constant></entry>
 239                         <entry>
 240                             <constant>TRUE</constant>, si vous voulez utiliser la compression à la
 241                             volée
 242                         </entry>
 243                     </row>
 244                     <row>
 245                         <entry><emphasis>compatibility</emphasis></entry>
 246                         <entry><type>Boolean</type></entry>
 247                         <entry><constant>FALSE</constant></entry>
 248                         <entry>
 249                             <constant>TRUE</constant>, si vous voulez utiliser le mode de
 250                             compatibilité avec les anciens serveurs&#160;/&#160;extensions memcache
 251                         </entry>
 252                     </row>
 253                 </tbody>
 254             </tgroup>
 255         </table>
 256     </sect2>
 257
 258     <sect2 id="zend.cache.backends.apc">
 259         <title>Zend_Cache_Backend_Apc</title>
 260
 261         <para>
 262             Ce backend (étendu) stocke les enregistrements de cache en mémoire partagée grâce
 263             à l'extension <ulink url="http://pecl.php.net/package/APC">APC</ulink>
 264             (Alternative <acronym>PHP</acronym> Cache) qui est requise pour utiliser ce backend.
 265         </para>
 266
 267         <para>
 268             Attention: avec ce backend, les balises ("tags") ne sont pas supportées pour le
 269             moment comme l'argument "doNotTestCacheValidity=true".
 270         </para>
 271
 272         <para>Il n'y a pas d'options pour ce backend.</para>
 273     </sect2>
 274
 275     <sect2 id="zend.cache.backends.xcache">
 276         <title>Zend_Cache_Backend_Xcache</title>
 277
 278         <para>
 279             Ce backend stocke ces enregistrements de cache dans la mémoire partagée à travers
 280             l'extension <ulink url="http://xcache.lighttpd.net/">XCache</ulink>(qui est bien sûr
 281             nécessaire pour utiliser ce backend).
 282         </para>
 283
 284         <para>
 285             Attention : avec ce backend, les balises ("tags") ne sont pas supportées pour le
 286             moment comme l'argument "doNotTestCacheValidity=true".
 287         </para>
 288
 289         <para>Les options disponibles sont&#160;:</para>
 290
 291         <table id="zend.cache.backends.xcache.table">
 292             <title>Options du backend Xcache</title>
 293
 294             <tgroup cols="4">
 295                 <thead>
 296                     <row>
 297                         <entry>Option</entry>
 298                         <entry>Type de données</entry>
 299                         <entry>Valeur par défaut</entry>
 300                         <entry>Description</entry>
 301                     </row>
 302                 </thead>
 303                 <tbody>
 304                     <row>
 305                         <entry><emphasis>user</emphasis></entry>
 306                         <entry><type>String</type></entry>
 307                         <entry><constant>NULL</constant></entry>
 308                         <entry>
 309                             <filename>xcache.admin.user</filename>, nécessaire pour la
 310                             méthode <methodname>clean()</methodname>.
 311                         </entry>
 312                     </row>
 313                     <row>
 314                         <entry><emphasis>password</emphasis></entry>
 315                         <entry><type>String</type></entry>
 316                         <entry><constant>NULL</constant></entry>
 317                         <entry>
 318                             <filename>xcache.admin.pass</filename> (en texte clair non
 319                             <acronym>MD5</acronym>), nécessaire pour la méthode
 320                             <methodname>clean()</methodname>.
 321                         </entry>
 322                     </row>
 323                 </tbody>
 324             </tgroup>
 325         </table>
 326     </sect2>
 327
 328     <sect2 id="zend.cache.backends.platform">
 329         <title>Zend_Cache_Backend_ZendPlatform</title>
 330
 331         <para>
 332             Ce backend utilise l'<acronym>API</acronym> de cache de contenu de la
 333             <ulink url="http://www.zend.com/fr/products/platform">Zend Platform</ulink>.
 334             Naturellement, pour utiliser ce backend, vous devez avoir installé une Zend Platorm.
 335         </para>
 336
 337         <para>
 338             Ce backend supporte les balises ("tags") mais ne supporte pas le mode de
 339             nettoyage <constant>CLEANING_MODE_NOT_MATCHING_TAG</constant>.
 340         </para>
 341
 342         <para>
 343             Spécifiez ce backend en utilisant un séparateur de mot - "-", ".", " " ou "_" -
 344             entre les mots "Zend" et "Platform" quand vous utilisez la méthode
 345             <methodname>Zend_Cache::factory()</methodname>&#160;:
 346         </para>
 347
 348         <programlisting language="php"><![CDATA[
 349 $cache = Zend_Cache::factory('Core', 'Zend Platform');
 350 ]]></programlisting>
 351
 352         <para>Il n'y a pas d'options pour ce backend.</para>
 353     </sect2>
 354
 355     <sect2 id="zend.cache.backends.twolevels">
 356         <title>Zend_Cache_Backend_TwoLevels</title>
 357
 358         <para>
 359             Ce backend (étendu) est un hybride. Il stocke les enregistrements de cache dans
 360             deux autres backends&#160;: un rapide (mais limité) comme Apc, Memcache... et un plus
 361             "lent" comme File, Sqlite...
 362         </para>
 363
 364         <para>
 365             Ce backend utilise le paramètre priorité (fourni au niveau du frontend au moment
 366             d'un enregistrement) et l'espace restant dans le backend rapide pour optimiser
 367             l'utilisation de ces deux backends.
 368         </para>
 369
 370          <para>
 371             Spécifiez ce backend avec un séparateur de mots - "-", ".", " ", ou "_" - entre les
 372             mots "Two" et "Levels" quand vous utilisez la méthode
 373             <methodname>Zend_Cache::factory()</methodname>&#160;:
 374         </para>
 375
 376         <programlisting language="php"><![CDATA[
 377 $cache = Zend_Cache::factory('Core', 'Two Levels');
 378 ]]></programlisting>
 379
 380         <para>Les options disponibles sont :</para>
 381
 382         <table id="zend.cache.backends.twolevels.table">
 383             <title>Options du backend TwoLevels</title>
 384
 385             <tgroup cols="4">
 386                 <thead>
 387                     <row>
 388                         <entry>Option</entry>
 389                         <entry>Type de données</entry>
 390                         <entry>Valeur par défaut</entry>
 391                         <entry>Description</entry>
 392                     </row>
 393                 </thead>
 394                 <tbody>
 395                     <row>
 396                         <entry><emphasis>slow_backend</emphasis></entry>
 397                         <entry><type>String</type></entry>
 398                         <entry>File</entry>
 399                         <entry>le nom du backend "lent"</entry>
 400                     </row>
 401                     <row>
 402                         <entry><emphasis>fast_backend</emphasis></entry>
 403                         <entry><type>String</type></entry>
 404                         <entry>Apc</entry>
 405                         <entry>le nom du backend "rapide"</entry>
 406                     </row>
 407                     <row>
 408                         <entry><emphasis>slow_backend_options</emphasis></entry>
 409                         <entry><type>Array</type></entry>
 410                         <entry><methodname>array()</methodname></entry>
 411                         <entry>les options du backend "lent"</entry>
 412                     </row>
 413                     <row>
 414                         <entry><emphasis>fast_backend_options</emphasis></entry>
 415                         <entry><type>Array</type></entry>
 416                         <entry><methodname>array()</methodname></entry>
 417                         <entry>les options du backend "rapide"</entry>
 418                     </row>
 419                     <row>
 420                         <entry><emphasis>slow_backend_custom_naming</emphasis></entry>
 421                         <entry><type>Boolean</type></entry>
 422                         <entry><constant>FALSE</constant></entry>
 423                         <entry>
 424                             si <constant>TRUE</constant>, l'argument "slow_backend" est
 425                             utilisé en tant que nom complet de classe&#160;; si
 426                             <constant>FALSE</constant>, l'argument frontend est utilisé concaténé à
 427                             "<classname>Zend_Cache_Backend_&lt;...&gt;</classname>"
 428                         </entry>
 429                     </row>
 430                     <row>
 431                         <entry><emphasis>fast_backend_custom_naming</emphasis></entry>
 432                         <entry><type>Boolean</type></entry>
 433                         <entry><constant>FALSE</constant></entry>
 434                         <entry>
 435                             si <constant>TRUE</constant>, l'argument "fast_backend" est
 436                             utilisé en tant que nom complet de classe&#160;; si
 437                             <constant>FALSE</constant>, l'argument frontend est utilisé concaténé à
 438                             "<classname>Zend_Cache_Backend_&lt;...&gt;</classname>"
 439                         </entry>
 440                     </row>
 441                     <row>
 442                         <entry><emphasis>slow_backend_autoload</emphasis></entry>
 443                         <entry><type>Boolean</type></entry>
 444                         <entry><constant>FALSE</constant></entry>
 445                         <entry>
 446                             si <constant>TRUE</constant>, il n'y aura pas de require_once pour le
 447                             "slow_backend" (utile seulement pour les backends
 448                             personnalisés)
 449                         </entry>
 450                     </row>
 451                     <row>
 452                         <entry><emphasis>fast_backend_autoload</emphasis></entry>
 453                         <entry><type>Boolean</type></entry>
 454                         <entry><constant>FALSE</constant></entry>
 455                         <entry>
 456                             si <constant>TRUE</constant>, il n'y aura pas de require_once pour le
 457                             "fast_backend" (utile seulement pour les backends
 458                             personnalisés)
 459                         </entry>
 460                     </row>
 461                     <row>
 462                         <entry><emphasis>auto_refresh_fast_cache</emphasis></entry>
 463                         <entry><type>Boolean</type></entry>
 464                         <entry><constant>TRUE</constant></entry>
 465                         <entry>
 466                             si <constant>TRUE</constant>, rafraîchissement automatique du cache
 467                             rapide quand un enregistrement est appelé
 468                         </entry>
 469                     </row>
 470                     <row>
 471                         <entry><emphasis>stats_update_factor</emphasis></entry>
 472                         <entry><type>Integer</type></entry>
 473                         <entry>10</entry>
 474                         <entry>
 475                             désactive&#160;/&#160;personnalise le calcul du pourcentage de
 476                             remplissage du backend rapide (lors d'une sauvegarde d'un enregistrement
 477                             dans le cache, le calcul du remplissage est effectué aléatoirement
 478                             1 fois sur x écritures de cache)
 479                         </entry>
 480                     </row>
 481                 </tbody>
 482             </tgroup>
 483         </table>
 484     </sect2>
 485
 486     <sect2 id="zend.cache.backends.zendserver">
 487         <title> Zend_Cache_Backend_ZendServer_Disk et Zend_Cache_Backend_ZendServer_ShMem </title>
 488
 489         <para>
 490             Ces backends utilisent les fonctionnalités de mise en cache de
 491             <ulink url="http://www.zend.com/en/products/server/downloads-all?zfs=zf_download">Zend
 492             Server</ulink>pour stocker les données.
 493         </para>
 494
 495         <para>
 496             Attention : avec ces backends ne supportent pas les balises ("tags") pour le
 497             moment de même que l'argument "doNotTestCacheValidity=true".
 498         </para>
 499
 500         <para>
 501             Ces backends fonctionnent seulement dans l'environnement de Zend Server pour les
 502             pages requêtées à travers <acronym>HTTP</acronym> ou <acronym>HTTPS</acronym> et ne
 503             fonctionnent pas pour les scripts exécutés en ligne de commande.
 504         </para>
 505
 506         <para>
 507             Spécifiez ce backend en utilisant le paramètre <emphasis>customBackendNaming</emphasis>
 508             à <constant>TRUE</constant> quand vous utilisez la méthode
 509             <methodname>Zend_Cache::factory()</methodname>&#160;:
 510         </para>
 511
 512         <programlisting language="php"><![CDATA[
 513 $cache = Zend_Cache::factory('Core', 'Zend_Cache_Backend_ZendServer_Disk',
 514                              $frontendOptions, $backendOptions, false, true);
 515 ]]></programlisting>
 516
 517         <para>Il n'y a pas d'options pour ce backend.</para>
 518     </sect2>
 519
 520     <sect2 id="zend.cache.backends.static">
 521         <title>Zend_Cache_Backend_Static</title>
 522
 523         <para>
 524             This backend works in concert with <classname>Zend_Cache_Frontend_Capture</classname>
 525             (the two must be used together) to save the output from requests as static files. This
 526             means the static files are served directly on subsequent requests without any
 527             involvement of <acronym>PHP</acronym> or Zend Framework at all.
 528         </para>
 529
 530         <note>
 531             <para>
 532                 <classname>Zend_Cache_Frontend_Capture</classname> operates
 533                 by registering a callback function to be called
 534                 when the output buffering it uses is cleaned. In order for this to operate
 535                 correctly, it must be the final output buffer in the request. To guarantee
 536                 this, the output buffering used by the Dispatcher <emphasis>must</emphasis> be
 537                 disabled by calling <classname>Zend_Controller_Front</classname>'s
 538                 <methodname>setParam()</methodname> method, for example,
 539                 <command>$front->setParam('disableOutputBuffering', true);</command> or adding
 540                 "resources.frontcontroller.params.disableOutputBuffering = true"
 541                 to your bootstrap configuration file (assumed <acronym>INI</acronym>) if using
 542                 <classname>Zend_Application</classname>.
 543             </para>
 544         </note>
 545
 546         <para>
 547             The benefits of this cache include a large throughput increase since
 548             all subsequent requests return the static file and don't need any
 549             dynamic processing. Of course this also has some disadvantages. The
 550             only way to retry the dynamic request is to purge the cached file
 551             from elsewhere in the application (or via a cronjob if timed). It
 552             is also restricted to single-server applications where only one
 553             filesystem is used. Nevertheless, it can be a powerful means of
 554             getting more performance without incurring the cost of a proxy on
 555             single machines.
 556         </para>
 557
 558         <para>
 559             Before describing its options, you should note this needs some
 560             changes to the default <filename>.htaccess</filename> file in order for requests to be
 561             directed to the static files if they exist. Here's an example of
 562             a simple application caching some content, including two specific
 563             feeds which need additional treatment to serve a correct
 564             Content-Type header:
 565         </para>
 566
 567         <programlisting language="text"><![CDATA[
 568 AddType application/rss+xml .xml
 569 AddType application/atom+xml .xml
 570
 571 RewriteEngine On
 572
 573 RewriteCond %{REQUEST_URI} feed/rss$
 574 RewriteCond %{DOCUMENT_ROOT}/cached/%{REQUEST_URI}.xml -f
 575 RewriteRule .* cached/%{REQUEST_URI}.xml [L,T=application/rss+xml]
 576
 577 RewriteCond %{REQUEST_URI} feed/atom$
 578 RewriteCond %{DOCUMENT_ROOT}/cached/%{REQUEST_URI}.xml -f
 579 RewriteRule .* cached/%{REQUEST_URI}.xml [L,T=application/atom+xml]
 580
 581 RewriteCond %{DOCUMENT_ROOT}/cached/index.html -f
 582 RewriteRule ^/*$ cached/index.html [L]
 583 RewriteCond %{DOCUMENT_ROOT}/cached/%{REQUEST_URI}.(html|xml|json|opml|svg) -f
 584 RewriteRule .* cached/%{REQUEST_URI}.%1 [L]
 585
 586 RewriteCond %{REQUEST_FILENAME} -s [OR]
 587 RewriteCond %{REQUEST_FILENAME} -l [OR]
 588 RewriteCond %{REQUEST_FILENAME} -d
 589 RewriteRule ^.*$ - [NC,L]
 590
 591 RewriteRule ^.*$ index.php [NC,L]
 592 ]]></programlisting>
 593
 594         <para>
 595             The above assumes static files are cached to the directory
 596             <filename>./public/cached</filename>. We'll cover the option setting this location,
 597             "public_dir", below.
 598         </para>
 599
 600         <para>
 601             Due to the nature of static file caching, the backend class offers two additional
 602             methods: <methodname>remove()</methodname> and
 603             <methodname>removeRecursively()</methodname>. Both accept a request
 604             <acronym>URI</acronym>, which when mapped to the "public_dir" where static files are
 605             cached, and has a pre-stored extension appended, provides the name of either a static
 606             file to delete, or a directory path to delete recursively. Due to the
 607             restraints of <classname>Zend_Cache_Backend_Interface</classname>, all
 608             other methods such as <methodname>save()</methodname> accept an ID which
 609             is calculated by applying <methodname>bin2hex()</methodname> to a request
 610             <acronym>URI</acronym>.
 611         </para>
 612
 613         <para>
 614             Given the level at which static caching operates, static file caching is addressed for
 615             simpler use with the <classname>Zend_Controller_Action_Helper_Cache</classname> action
 616             helper. This helper assists in setting which actions of a controller to cache, with what
 617             tags, and with which extension. It also offers methods for purging the cache by request
 618             <acronym>URI</acronym> or tag. Static file caching is also assisted by
 619             <classname>Zend_Cache_Manager</classname> which includes pre-configured configuration
 620             templates for a static cache (as <constant>Zend_Cache_Manager::PAGECACHE</constant> or
 621             "page"). The defaults therein can be configured as needed to set up a "public_dir"
 622             location for caching, etc.
 623         </para>
 624
 625         <note>
 626             <para>
 627                 It should be noted that the static cache actually uses a secondary cache to store
 628                 tags (obviously we can't store them elsewhere since a static cache does not invoke
 629                 <acronym>PHP</acronym> if working correctly). This is just a standard Core cache,
 630                 and should use a persistent backend such as File or TwoLevels (to take advantage of
 631                 memory storage without sacrificing permanent persistance). The backend includes the
 632                 option "tag_cache" to set this up (it is obligatory), or the
 633                 <methodname>setInnerCache()</methodname> method.
 634             </para>
 635         </note>
 636
 637         <table id="zend.cache.backends.static.table">
 638             <title>Static Backend Options</title>
 639
 640             <tgroup cols="4">
 641                 <thead>
 642                     <row>
 643                         <entry>Option</entry>
 644                         <entry>Data Type</entry>
 645                         <entry>Default Value</entry>
 646                         <entry>Description</entry>
 647                     </row>
 648                 </thead>
 649
 650                 <tbody>
 651                     <row>
 652                         <entry><emphasis>public_dir</emphasis></entry>
 653                         <entry><type>String</type></entry>
 654                         <entry><constant>NULL</constant></entry>
 655                         <entry>
 656                             Directory where to store static files. This must exist
 657                             in your public directory.
 658                         </entry>
 659                     </row>
 660
 661                     <row>
 662                         <entry><emphasis>file_locking</emphasis></entry>
 663                         <entry><type>Boolean</type></entry>
 664                         <entry><constant>TRUE</constant></entry>
 665
 666                         <entry>
 667                             Enable or disable file_locking : Can avoid cache corruption under
 668                             bad circumstances but it doesn't help on multithread webservers
 669                             or on <acronym>NFS</acronym> filesystems...
 670                         </entry>
 671                     </row>
 672
 673                     <row>
 674                         <entry><emphasis>read_control</emphasis></entry>
 675                         <entry><type>Boolean</type></entry>
 676                         <entry><constant>TRUE</constant></entry>
 677
 678                         <entry>
 679                             Enable / disable read control : if enabled, a control key is
 680                             embedded in the cache file and this key is compared with the
 681                             one calculated after the reading.
 682                         </entry>
 683                     </row>
 684
 685                     <row>
 686                         <entry><emphasis>read_control_type</emphasis></entry>
 687                         <entry><type>String</type></entry>
 688                         <entry>'crc32'</entry>
 689
 690                         <entry>
 691                             Type of read control (only if read control is enabled). Available values
 692                             are : 'md5' (best but slowest), 'crc32' (lightly less safe but faster,
 693                             better choice), 'adler32' (new choice, faster than crc32),
 694                             'strlen' for a length only test (fastest).
 695                         </entry>
 696                     </row>
 697
 698                     <row>
 699                         <entry><emphasis>cache_file_umask</emphasis></entry>
 700                         <entry><type>Integer</type></entry>
 701                         <entry>0700</entry>
 702                         <entry>umask for cached files.</entry>
 703                     </row>
 704
 705                     <row>
 706                         <entry><emphasis>cache_directory_umask</emphasis></entry>
 707                         <entry><type>Integer</type></entry>
 708                         <entry>0700</entry>
 709                         <entry>Umask for directories created within public_dir.</entry>
 710                     </row>
 711
 712                     <row>
 713                         <entry><emphasis>file_extension</emphasis></entry>
 714                         <entry><type>String</type></entry>
 715                         <entry>'<filename>.html</filename>'</entry>
 716
 717                         <entry>
 718                             Default file extension for static files created. This can be
 719                             configured on the fly, see
 720                             <methodname>Zend_Cache_Backend_Static::save()</methodname> though
 721                             generally it's recommended to rely on
 722                             <classname>Zend_Controller_Action_Helper_Cache</classname> when
 723                             doing so since it's simpler that way than messing with
 724                             arrays or serialization manually.
 725                         </entry>
 726                     </row>
 727
 728                     <row>
 729                         <entry><emphasis>index_filename</emphasis></entry>
 730                         <entry><type>String</type></entry>
 731                         <entry>'index'</entry>
 732
 733                         <entry>
 734                             If a request <acronym>URI</acronym> does not contain sufficient
 735                             information to construct a static file (usually this means an index
 736                             call, e.g. <acronym>URI</acronym> of '/'), the index_filename is used
 737                             instead. So '' or '/' would map to '<filename>index.html</filename>'
 738                             (assuming the default file_extension is '<filename>.html</filename>').
 739                         </entry>
 740                     </row>
 741
 742                     <row>
 743                         <entry><emphasis>tag_cache</emphasis></entry>
 744                         <entry><type>Object</type></entry>
 745                         <entry><constant>NULL</constant></entry>
 746
 747                         <entry>
 748                             Used to set an 'inner' cache utilised to store tags
 749                             and file extensions associated with static files. This
 750                             <emphasis>must</emphasis> be set or the static cache cannot be tracked
 751                             and managed.
 752                         </entry>
 753                     </row>
 754
 755                     <row>
 756                         <entry><emphasis>disable_caching</emphasis></entry>
 757                         <entry><type>Boolean</type></entry>
 758                         <entry><constant>FALSE</constant></entry>
 759
 760                         <entry>
 761                             If set to <constant>TRUE</constant>, static files will not be cached.
 762                             This will force all requests to be dynamic even if marked
 763                             to be cached in Controllers. Useful for debugging.
 764                         </entry>
 765                     </row>
 766                 </tbody>
 767             </tgroup>
 768         </table>
 769     </sect2>
 770 </sect1>