eZ publish: eztemplatecachefunction.php Source File

00001 <?php
00002 //
00003 // Definition of eZTemplateCacheFunction class
00004 //
00005 // Created on: <28-Feb-2003 15:06:33 bf>
00006 //
00007 // ## BEGIN COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
00008 // SOFTWARE NAME: eZ publish
00009 // SOFTWARE RELEASE: 3.9.x
00010 // COPYRIGHT NOTICE: Copyright (C) 1999-2006 eZ systems AS
00011 // SOFTWARE LICENSE: GNU General Public License v2.0
00012 // NOTICE: >
00013 //   This program is free software; you can redistribute it and/or
00014 //   modify it under the terms of version 2.0  of the GNU General
00015 //   Public License as published by the Free Software Foundation.
00016 //
00017 //   This program is distributed in the hope that it will be useful,
00018 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
00019 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020 //   GNU General Public License for more details.
00021 //
00022 //   You should have received a copy of version 2.0 of the GNU General
00023 //   Public License along with this program; if not, write to the Free
00024 //   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
00025 //   MA 02110-1301, USA.
00026 //
00027 //
00028 // ## END COPYRIGHT, LICENSE AND WARRANTY NOTICE ##
00029 //
00030 
00031 /*!
00032   \class eZTemplateCacheFunction eztemplatecachefunction.php
00033   \ingroup eZTemplateFunctions
00034   \brief Advanced cache handling
00035 
00036 */
00037 
00038 define( 'eZTemplateCacheFunction_FileGenerateTimeout', 5 );
00039 
00040 class eZTemplateCacheFunction
00041 {
00042     /*!
00043      Initializes the object with names.
00044     */
00045     function eZTemplateCacheFunction( $blockName = 'cache-block' )
00046     {
00047         $this->BlockName = $blockName;
00048     }
00049 
00050     /*!
00051      Returns an array containing the name of the block function, default is "block".
00052      The name is specified in the constructor.
00053     */
00054     function functionList()
00055     {
00056         return array( $this->BlockName );
00057     }
00058 
00059     function functionTemplateHints()
00060     {
00061         return array( $this->BlockName => array( 'parameters' => true,
00062                                                  'static' => false,
00063                                                  'transform-children' => true,
00064                                                  'tree-transformation' => true,
00065                                                  'transform-parameters' => true ) );
00066     }
00067 
00068     function templateNodeTransformation( $functionName, &$node,
00069                                          &$tpl, $parameters, $privateData )
00070     {
00071         $ini =& eZINI::instance();
00072         $children = eZTemplateNodeTool::extractFunctionNodeChildren( $node );
00073         if ( $ini->variable( 'TemplateSettings', 'TemplateCache' ) != 'enabled' )
00074         {
00075             return $children;
00076         }
00077 
00078         $functionPlacement = eZTemplateNodeTool::extractFunctionNodePlacement( $node );
00079         $placementKeyString  = $functionPlacement[0][0] . "_";
00080         $placementKeyString .= $functionPlacement[0][1] . "_";
00081         $placementKeyString .= $functionPlacement[1][0] . "_";
00082         $placementKeyString .= $functionPlacement[1][1] . "_";
00083         $placementKeyString .= $functionPlacement[2] . "_";
00084 
00085         $newNodes = array();
00086         $ignoreExpiry = false;
00087         $ignoreContentExpiry = false;
00088 
00089         $expiry = 60*60*2;
00090         if ( isset( $parameters['expiry'] ) )
00091         {
00092             if ( eZTemplateNodeTool::isStaticElement( $parameters['expiry'] ) )
00093             {
00094                 $expiryValue = eZTemplateNodeTool::elementStaticValue( $parameters['expiry'] );
00095 
00096                 if ( $expiryValue )
00097                 {
00098                     $expiryText = eZPHPCreator::variableText( $expiryValue , 0, 0, false );
00099                 }
00100                 else
00101                 {
00102                     $ignoreExpiry = true;
00103                 }
00104             }
00105             else
00106             {
00107                 $newNodes[] = eZTemplateNodeTool::createVariableNode( false, $parameters['expiry'], false, array(), 'localExpiry' );
00108                 $expiryText = "\$localExpiry";
00109             }
00110         }
00111         else
00112         {
00113             $expiryText = eZPHPCreator::variableText( $expiry , 0, 0, false );
00114         }
00115 
00116         if ( isset( $parameters['ignore_content_expiry'] ) )
00117         {
00118             $ignoreContentExpiry = eZTemplateNodeTool::elementStaticValue( $parameters['ignore_content_expiry'] );
00119         }
00120 
00121         $keysData = false;
00122         $keyValue = false;
00123         $keyValueText = false;
00124         $useDynamicKeys = false;
00125         $subtreeExpiryData = false;
00126         if ( isset( $parameters['keys'] ) )
00127         {
00128             $keysData = $parameters['keys'];
00129             if ( !eZTemplateNodeTool::isStaticElement( $keysData ) )
00130             {
00131                 $useDynamicKeys = true;
00132             }
00133             else
00134             {
00135                 $keyValue = eZTemplateNodeTool::elementStaticValue( $keysData );
00136                 $keyValueText = $keyValue . '_';
00137             }
00138         }
00139         if ( isset( $parameters['subtree_expiry'] ) )
00140         {
00141             $subtreeExpiryData = $parameters['subtree_expiry'];
00142             if ( !eZTemplateNodeTool::isStaticElement( $subtreeExpiryData ) )
00143                 $useDynamicKeys = true;
00144             else
00145                 $subtreeValue = eZTemplateNodeTool::elementStaticValue( $subtreeExpiryData );
00146 
00147             $ignoreContentExpiry = true;
00148         }
00149         if ( $useDynamicKeys )
00150         {
00151             $accessName = false;
00152             if ( isset( $GLOBALS['eZCurrentAccess']['name'] ) )
00153                 $accessName = $GLOBALS['eZCurrentAccess']['name'];
00154             $extraKeyString = $placementKeyString . $accessName;
00155             $extraKeyText = eZPHPCreator::variableText( $extraKeyString, 0, 0, false );
00156             $newNodes[] = eZTemplateNodeTool::createVariableNode( false, $keysData, false, array(), 'cacheKeys' );
00157             $newNodes[] = eZTemplateNodeTool::createVariableNode( false, $subtreeExpiryData, false, array(), 'subtreeExpiry' );
00158             $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "if ( is_array( \$cacheKeys ) )\n    \$cacheKeys = implode( '_', \$cacheKeys ) . '_';\nelse\n    \$cacheKeys .= '_';" );
00159             $cacheDir = eZTemplateCacheFunction::templateBlockCacheDir();
00160             $cachePathText = eZPHPCreator::variableText( "$cacheDir", 0, 0, false );
00161             $code = ( "include_once( 'lib/ezutils/classes/ezsys.php' );\n" .
00162                       "\$keyString = eZSys::ezcrc32( \$cacheKeys . $extraKeyText );\n" .
00163                       "\$cacheFilename = \$keyString . '.cache';\n" .
00164                       "if ( isset( \$subtreeExpiry ) && \$subtreeExpiry !== false )\n" .
00165                       "{\n" .
00166                       "    include_once( 'lib/eztemplate/classes/eztemplatecachefunction.php' );\n" .
00167                       "    \$cacheDir = $cachePathText . eZTemplateCacheFunction::subtreeCacheSubDir( \$subtreeExpiry, \$cacheFilename );\n" .
00168                       "}\n" .
00169                       "else\n" .
00170                       "{\n" .
00171                       "    \$cacheDir = $cachePathText . \$keyString[0] . '/' . \$keyString[1] . '/' . \$keyString[2];\n" .
00172                       "}\n" .
00173                       "\$cachePath = \$cacheDir . '/' . \$cacheFilename;" );
00174         }
00175         else
00176         {
00177             $accessName = false;
00178             if ( isset( $GLOBALS['eZCurrentAccess']['name'] ) )
00179                 $accessName = $GLOBALS['eZCurrentAccess']['name'];
00180 
00181             include_once( 'lib/ezutils/classes/ezsys.php' );
00182             $keyString = eZSys::ezcrc32( $keyValueText . $placementKeyString . $accessName );
00183             $cacheFilename = $keyString . '.cache';
00184             $cacheDir = eZTemplateCacheFunction::templateBlockCacheDir();
00185             if ( isset( $subtreeValue ) )
00186                 $cacheDir = "$cacheDir" . eZTemplateCacheFunction::subtreeCacheSubDir( $subtreeValue, $cacheFilename );
00187             else
00188                 $cacheDir = "$cacheDir" . $keyString[0] . '/' . $keyString[1] . '/' . $keyString[2];
00189 
00190             $cachePath = "$cacheDir" . '/' . $cacheFilename;
00191             $code = ( "\$keyString = '$keyString';\n" .
00192                       "\$cacheDir = '$cacheDir';\n" .
00193                       "\$cachePath = '$cachePath';" );
00194         }
00195 
00196         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( $code );
00197         $filedirText = "\$cacheDir";
00198         $filepathText = "\$cachePath";
00199 
00200         $code = '';
00201 
00202         if ( !$ignoreContentExpiry )
00203         {
00204             $code .= <<<ENDADDCODE
00205 include_once( 'lib/ezutils/classes/ezexpiryhandler.php' );
00206 \$handler =& eZExpiryHandler::instance();
00207 \$globalExpiryTime = -1;
00208 if ( \$handler->hasTimestamp( 'template-block-cache' ) )
00209 {
00210     \$globalExpiryTime = \$handler->timestamp( 'template-block-cache' );
00211 }
00212 
00213 ENDADDCODE;
00214         }
00215 
00216         // VS-DBFILE
00217 
00218         $code .=
00219             "require_once( 'kernel/classes/ezclusterfilehandler.php' );\n" .
00220             "\$cacheFile = eZClusterFileHandler::instance( $filepathText );\n" .
00221             "if ( \$cacheFile->exists()";
00222 
00223         if ( !$ignoreExpiry ) {
00224             $code .= "\n    and \$cacheFile->mtime() >= ( time() - $expiryText )";
00225         }
00226         if ( !$ignoreContentExpiry ) {
00227             $code .= "\n    and ( ( \$cacheFile->mtime() > \$globalExpiryTime ) or ( \$globalExpiryTime == -1 ) )";
00228         }
00229         $code .= " )\n" .
00230                  "{\n" .
00231                  "    \$contentData = \$cacheFile->size() ? \$cacheFile->fetchContents() : '';\n";
00232 
00233         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( $code, array( 'spacing' => 0 ) );
00234         $newNodes[] = eZTemplateNodeTool::createWriteToOutputVariableNode( 'contentData', array( 'spacing' => 4 ) );
00235         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "    unset( \$contentData );\n" .
00236                                                                "}\n" .
00237                                                                "else\n" .
00238                                                                "{" );
00239 
00240         // Check if cache gen file exists, and wait
00241         // for eZTemplateFunction_FileGenerateTimeout seconds if it does.
00242 
00243 
00244         $myRndVal = md5( mt_rand() );
00245         $code =
00246             "\$phpPathGen = $filepathText . '.gen';\n" .
00247             "\$cacheGenFile$myRndVal = eZClusterFileHandler::instance( \$phpPathGen );\n" .
00248             "while( \$cacheGenFile$myRndVal"."->fileExists( \$cacheGenFile$myRndVal"."->name() ) &&\n" .
00249             "\$cacheGenFile$myRndVal"."->mtime() + " . eZTemplateCacheFunction_FileGenerateTimeout . " > mktime() )\n" .
00250             "{\n" .
00251             "sleep( 1 );\n" .
00252             "\$cacheGenFile$myRndVal"."->loadMetaData();\n" .
00253             "}\n";
00254         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( $code, array( 'spacing' => 0 ) );
00255 
00256 
00257         // Cache file might have been generated by now.
00258         $code = "\$cacheFile->loadMetaData();\n".
00259             "if ( \$cacheFile->fileExists( \$cacheFile->name() )";
00260         if ( !$ignoreExpiry ) {
00261             $code .= "\n    and \$cacheFile->mtime() >= ( time() - $expiryText )";
00262         }
00263         if ( !$ignoreContentExpiry ) {
00264             $code .= "\n    and ( ( \$cacheFile->mtime() > \$globalExpiryTime ) or ( \$globalExpiryTime == -1 ) )";
00265         }
00266         $code .= " )\n" .
00267                  "{\n" .
00268                  "    \$contentData = \$cacheFile->size() ? \$cacheFile->fetchContents() : '';\n";
00269         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( $code );
00270         $newNodes[] = eZTemplateNodeTool::createWriteToOutputVariableNode( 'contentData', array( 'spacing' => 4 ) );
00271         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "    unset( \$contentData );\n" .
00272                                                                "}\n" .
00273                                                                "else\n" .
00274                                                                "{" );
00275 
00276         // Create tmp cache file
00277         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "\$cacheGenFile$myRndVal"."->storeContents( '1' );" );
00278 
00279 
00280         $newNodes[] = eZTemplateNodeTool::createOutputVariableIncreaseNode( array( 'spacing' => 4 ) );
00281         $newNodes[] = eZTemplateNodeTool::createSpacingIncreaseNode( 4 );
00282         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "if ( !isset( \$cacheStack ) )\n" .
00283                                                                "    \$cacheStack = array();\n" .
00284                                                                "\$cacheEntry = array( \$cacheDir, \$cachePath, \$keyString, false );\n" .
00285                                                                "if ( isset( \$subtreeExpiry ) )\n" .
00286                                                                "    \$cacheEntry[3] = \$subtreeExpiry;\n" .
00287                                                                "\$cacheStack[] = \$cacheEntry;" );
00288         $newNodes = array_merge( $newNodes, $children );
00289         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "list( \$cacheDir, \$cachePath, \$keyString, \$subtreeExpiry ) = array_pop( \$cacheStack );" );
00290         $newNodes[] = eZTemplateNodeTool::createSpacingDecreaseNode( 4 );
00291         $newNodes[] = eZTemplateNodeTool::createAssignFromOutputVariableNode( 'cachedText', array( 'spacing' => 4 ) );
00292         $ini =& eZINI::instance();
00293         $perm = octdec( $ini->variable( 'FileSettings', 'StorageDirPermissions' ) );
00294         $code = ( "include_once( 'lib/ezfile/classes/ezdir.php' );\n" .
00295                   "\$uniqid = md5( uniqid( 'ezpcache'. getmypid(), true ) );\n" .
00296                   "eZDir::mkdir( $filedirText, $perm, true );\n" .
00297                   "\$fd = fopen( $filedirText. '/'. \$uniqid, 'w' );\n" .
00298                   "fwrite( \$fd, \$cachedText );\n" .
00299                   "fclose( \$fd );\n" );
00300         /* On windows we need to unlink the destination file first */
00301         if ( strtolower( substr( PHP_OS, 0, 3 ) ) == 'win' )
00302         {
00303             $code .= "@unlink( $filepathText );\n";
00304         }
00305         $code .= "rename( $filedirText. '/'. \$uniqid, $filepathText );\n" .
00306             "if ( isset( \$cacheGenFile$myRndVal ) and is_object( \$cacheGenFile$myRndVal ) )\n" .
00307             "{\n" .
00308             "   \$cacheGenFile$myRndVal"."->delete();\n" .
00309             "   unset( \$cacheGenFile$myRndVal );\n" .
00310             "}\n";
00311 
00312         // VS-DBFILE
00313 
00314         $code .=
00315             "require_once( 'kernel/classes/ezclusterfilehandler.php' );\n" .
00316             "\$fileHandler = eZClusterFileHandler::instance();\n" .
00317             "\$fileHandler->fileStore( $filepathText, 'template-block', true );\n";
00318 
00319         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( $code, array( 'spacing' => 4 ) );
00320         $newNodes[] = eZTemplateNodeTool::createOutputVariableDecreaseNode( array( 'spacing' => 4 ) );
00321         $newNodes[] = eZTemplateNodeTool::createWriteToOutputVariableNode( 'cachedText', array( 'spacing' => 4 ) );
00322         $newNodes[] = eZTemplateNodeTool::createCodePieceNode( "    unset( \$cachedText );\n}}" );
00323         return $newNodes;
00324     }
00325 
00326     /*!
00327      Processes the function with all it's children.
00328     */
00329     function process( &$tpl, &$textElements, $functionName, $functionChildren, $functionParameters, $functionPlacement, $rootNamespace, $currentNamespace )
00330     {
00331         switch ( $functionName )
00332         {
00333             case $this->BlockName:
00334             {
00335                 // Check for disabled cache.
00336                 $ini =& eZINI::instance();
00337                 if ( $ini->variable( 'TemplateSettings', 'TemplateCache' ) != 'enabled' )
00338                 {
00339                     $children = $functionChildren;
00340 
00341                     $childTextElements = array();
00342                     foreach ( array_keys( $children ) as $childKey )
00343                     {
00344                         $child =& $children[$childKey];
00345                         $tpl->processNode( $child, $childTextElements, $rootNamespace, $currentNamespace );
00346                     }
00347                     $text = implode( '', $childTextElements );
00348                     $textElements[] = $text;
00349                 }
00350                 else
00351                 {
00352                     $keyString = "";
00353                     // Get cache keys
00354                     if ( isset( $functionParameters["keys"] ) )
00355                     {
00356                         $keys = $tpl->elementValue( $functionParameters["keys"], $rootNamespace, $currentNamespace, $functionPlacement );
00357 
00358                         if ( is_array( $keys ) )
00359                         {
00360                             foreach ( $keys as $key )
00361                             {
00362                                 $keyString .= $key . "_";
00363                             }
00364                         }
00365                         else
00366                         {
00367                             $keyString .= $keys . "_";
00368                         }
00369                     }
00370 
00371                     // Append keys from position in template
00372                     $keyString .= $functionPlacement[0][0] . "_";
00373                     $keyString .= $functionPlacement[0][1] . "_";
00374                     $keyString .= $functionPlacement[1][0] . "_";
00375                     $keyString .= $functionPlacement[1][1] . "_";
00376                     $keyString .= $functionPlacement[2] . "_";
00377 
00378                     // Fetch the current siteaccess
00379                     $accessName = false;
00380                     if ( isset( $GLOBALS['eZCurrentAccess']['name'] ) )
00381                         $accessName = $GLOBALS['eZCurrentAccess']['name'];
00382                     $keyString .= $accessName;
00383 
00384                     include_once( 'lib/ezutils/classes/ezsys.php' );
00385                     $hashedKey = eZSys::ezcrc32( $keyString );
00386 
00387                     $cacheFilename = $hashedKey . ".cache";
00388 
00389                     $phpDir = eZTemplateCacheFunction::templateBlockCacheDir();
00390                     if ( isset( $functionParameters['subtree_expiry'] ) )
00391                         $phpDir .= eZTemplateCacheFunction::subtreeCacheSubDir( $tpl->elementValue( $functionParameters["subtree_expiry"], $rootNamespace, $currentNamespace, $functionPlacement ), $cacheFilename );
00392                     else
00393                         $phpDir .= $hashedKey[0] . '/' . $hashedKey[1] . '/' . $hashedKey[2];
00394 
00395                     $phpPath = $phpDir . '/' . $cacheFilename;
00396 
00397                     // Check if a custom expiry time is defined
00398                     if ( isset( $functionParameters["expiry"] ) )
00399                     {
00400                         $expiry = $tpl->elementValue( $functionParameters["expiry"], $rootNamespace, $currentNamespace, $functionPlacement );
00401                     }
00402                     else
00403                     {
00404                         // Default expiry time is set to two hours
00405                         $expiry = 60*60*2;
00406                     }
00407 
00408                     $localExpiryTime = 0;
00409                     if ( $expiry > 0 )
00410                         $localExpiryTime = time() - $expiry;
00411 
00412                     $ignoreContentExpiry = false;
00413                     if ( isset( $functionParameters["ignore_content_expiry"] ) )
00414                     {
00415                         $ignoreContentExpiry = $tpl->elementValue( $functionParameters["ignore_content_expiry"], $rootNamespace, $currentNamespace, $functionPlacement ) === true;
00416                     }
00417                     if ( isset( $functionParameters['subtree_expiry'] ) )
00418                     {
00419                         $ignoreContentExpiry = true;
00420                     }
00421 
00422                     $expiryTime = $localExpiryTime;
00423                     if ( $ignoreContentExpiry == false )
00424                     {
00425                         include_once( 'lib/ezutils/classes/ezexpiryhandler.php' );
00426                         $handler =& eZExpiryHandler::instance();
00427                         if ( $handler->hasTimestamp( 'template-block-cache' ) )
00428                         {
00429                             $globalExpiryTime = $handler->timestamp( 'template-block-cache' );
00430                             $expiryTime = max( $localExpiryTime, $globalExpiryTime );
00431                         }
00432                     }
00433 
00434                     // Check if we can restore
00435                     require_once( 'kernel/classes/ezclusterfilehandler.php' );
00436                     $cacheFile = eZClusterFileHandler::instance( $phpPath );
00437                     if ( $cacheFile->exists() &&
00438                          $cacheFile->mtime() >= $expiryTime )
00439                     {
00440                         $textElements[] = $cacheFile->fetchContents();
00441                         return;
00442                     }
00443 
00444                     // Check if cache gen file exists, and wait
00445                     // for eZTemplateFunction_FileGenerateTimeout seconds if it does.
00446                     $phpPathGen = $phpPath . '.gen';
00447                     $cacheGenFile = eZClusterFileHandler::instance( $phpPathGen );
00448                     while( $cacheGenFile->fileExists( $cacheGenFile->name() ) &&
00449                            $cacheGenFile->mtime() + eZTemplateCacheFunction_FileGenerateTimeout > mktime() )
00450                     {
00451                         sleep( 1 );
00452                         $cacheGenFile->loadMetaData();
00453                     }
00454 
00455                     // Cache file might have been generated by now.
00456                     $cacheFile->loadMetaData();
00457                     if ( $cacheFile->fileExists( $cacheFile->name() ) &&
00458                          $cacheFile->mtime() >= $expiryTime )
00459                     {
00460                         $textElements[] = $cacheFile->fetchContents();
00461                         return;
00462                     }
00463 
00464                     $cacheGenFile->storeContents( '1' );
00465 
00466                     // If no cache or expired cache, load data
00467                     $children = $functionChildren;
00468 
00469                     $childTextElements = array();
00470                     if ( is_array( $children ) )
00471                     {
00472                         foreach ( array_keys( $children ) as $childKey )
00473                         {
00474                             $child =& $children[$childKey];
00475                             $tpl->processNode( $child, $childTextElements, $rootNamespace, $currentNamespace );
00476                         }
00477                     }
00478                     $text = implode( '', $childTextElements );
00479                     $textElements[] = $text;
00480 
00481                     include_once( 'lib/ezfile/classes/ezfile.php' );
00482                     $ini =& eZINI::instance();
00483                     $perm = octdec( $ini->variable( 'FileSettings', 'StorageDirPermissions' ) );
00484                     $uniqid = md5( uniqid( 'ezpcache'. getmypid(), true ) );
00485                     eZDir::mkdir( $phpDir, $perm, true );
00486                     $fd = fopen( "$phpDir/$uniqid", 'w' );
00487                     fwrite( $fd, $text );
00488                     fclose( $fd );
00489                     eZFile::rename( "$phpDir/$uniqid", $phpPath );
00490 
00491                     // VS-DBFILE
00492                     require_once( 'kernel/classes/ezclusterfilehandler.php' );
00493                     $fileHandler = eZClusterFileHandler::instance();
00494                     $fileHandler->fileStore( $phpPath, 'template-block', true );
00495 
00496                     // Clean up "lock" file.
00497                     $cacheGenFile->delete();
00498                 }
00499             } break;
00500         }
00501     }
00502 
00503     /*!
00504      Returns true.
00505     */
00506     function hasChildren()
00507     {
00508         return true;
00509     }
00510 
00511     /*!
00512      \static
00513      Returns base directory where 'subtree_expiry' caches are stored.
00514     */
00515     function subtreeCacheBaseSubDir()
00516     {
00517         return 'subtree';
00518     }
00519 
00520     /*!
00521      \static
00522      Returns base directory where expired 'subtree_expiry' caches are stored.
00523     */
00524     function expiryTemplateBlockCacheDir()
00525     {
00526         $expiryCacheDir = eZSys::cacheDirectory() . '/' . 'template-block-expiry';
00527         return $expiryCacheDir;
00528     }
00529 
00530     /*!
00531      \static
00532      Returns base directory where template block caches are stored.
00533     */
00534     function templateBlockCacheDir()
00535     {
00536         $cacheDir = eZSys::cacheDirectory() . '/template-block/' ;
00537         return $cacheDir;
00538     }
00539 
00540     /*!
00541      \static
00542      Returns path of the directory where 'subtree_expiry' caches are stored.
00543     */
00544     function subtreeCacheSubDir( $subtreeExpiryParameter, $cacheFilename )
00545     {
00546         $nodePathString = '';
00547 
00548         include_once( 'lib/ezdb/classes/ezdb.php' );
00549         $db =& eZDB::instance();
00550 
00551         // clean up $subtreeExpiryParameter
00552         $subtreeExpiryParameter = trim( $subtreeExpiryParameter, '/' );
00553 
00554         // get 'path_stirng' attribute for node.
00555         $nodeID = false;
00556         $subtree = $db->escapeString( $subtreeExpiryParameter );
00557 
00558         if ( $subtree == '' )
00559         {
00560             // 'subtree_expiry' is empty => use root node.
00561             $nodeID = 2;
00562         }
00563         else
00564         {
00565             $nonAliasPath = 'content/view/full/';
00566 
00567             if ( strpos( $subtree, $nonAliasPath ) === 0 )
00568             {
00569                 // 'subtree_expiry' is like 'content/view/full/2'
00570                 $nodeID = substr( $subtree, strlen( $nonAliasPath ) );
00571             }
00572             else
00573             {
00574                 // 'subtree_expiry' is url_alias
00575                 $nodePathStringSQL = "SELECT node_id FROM ezcontentobject_tree WHERE path_identification_string='$subtree'";
00576                 $nodes = $db->arrayQuery( $nodePathStringSQL );
00577                 if ( count( $nodes ) != 1 )
00578                 {
00579                     eZDebug::writeError( 'Could not find path_string for \'subtree_expiry\' node.', 'eZTemplateCacheFunction::subtreeExpiryCacheDir()' );
00580                 }
00581                 else
00582                 {
00583                     $nodeID = $nodes[0]['node_id'];
00584                 }
00585             }
00586         }
00587 
00588         $cacheDir = eZTemplateCacheFunction::subtreeCacheSubDirForNode( $nodeID );
00589         $cacheDir .= '/' . $cacheFilename[0] . '/' . $cacheFilename[1] . '/' . $cacheFilename[2];
00590 
00591         return $cacheDir;
00592     }
00593 
00594     /*!
00595      \static
00596      Builds and returns path from $nodeID, e.g. if $nodeID = 23 then path = subtree/2/3
00597     */
00598     function subtreeCacheSubDirForNode( $nodeID )
00599     {
00600         $cacheDir = eZTemplateCacheFunction::subtreeCacheBaseSubDir();
00601 
00602         if ( is_numeric( $nodeID ) )
00603         {
00604             $nodeID = (string)$nodeID;
00605             $length = strlen( $nodeID );
00606             $pos = 0;
00607             while ( $pos < $length )
00608             {
00609                 $cacheDir .= '/' . $nodeID[$pos];
00610                 ++$pos;
00611             }
00612         }
00613         else
00614         {
00615             eZDebug::writeWarning( "Unable to determine cacheDir for nodeID = $nodeID", 'eZtemplateCacheFunction::subtreeCacheSubDirForNode' );
00616         }
00617 
00618         $cacheDir .= '/cache';
00619         return $cacheDir;
00620     }
00621 
00622     /// \privatesection
00623     /// Name of the function
00624     var $BlockName;
00625 }
00626 
00627 ?>