[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Page view caching in the file system.
   4   *
   5   * This program is free software; you can redistribute it and/or modify
   6   * it under the terms of the GNU General Public License as published by
   7   * the Free Software Foundation; either version 2 of the License, or
   8   * (at your option) any later version.
   9   *
  10   * This program is distributed in the hope that it will be useful,
  11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13   * GNU General Public License for more details.
  14   *
  15   * You should have received a copy of the GNU General Public License along
  16   * with this program; if not, write to the Free Software Foundation, Inc.,
  17   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18   * http://www.gnu.org/copyleft/gpl.html
  19   *
  20   * @file
  21   * @ingroup Cache
  22   */
  23  
  24  /**
  25   * Page view caching in the file system.
  26   * The only cacheable actions are "view" and "history". Also special pages
  27   * will not be cached.
  28   *
  29   * @ingroup Cache
  30   */
  31  class HTMLFileCache extends FileCacheBase {
  32      /**
  33       * Construct an ObjectFileCache from a Title and an action
  34       * @param Title|string $title Title object or prefixed DB key string
  35       * @param string $action
  36       * @throws MWException
  37       * @return HTMLFileCache
  38       *
  39       * @deprecated Since 1.24, instantiate this class directly
  40       */
  41  	public static function newFromTitle( $title, $action ) {
  42          return new self( $title, $action );
  43      }
  44  
  45      /**
  46       * @param Title|string $title Title object or prefixed DB key string
  47       * @param string $action
  48       * @throws MWException
  49       */
  50  	public function __construct( $title, $action ) {
  51          $allowedTypes = self::cacheablePageActions();
  52          if ( !in_array( $action, $allowedTypes ) ) {
  53              throw new MWException( 'Invalid file cache type given.' );
  54          }
  55          $this->mKey = ( $title instanceof Title )
  56              ? $title->getPrefixedDBkey()
  57              : (string)$title;
  58          $this->mType = (string)$action;
  59          $this->mExt = 'html';
  60      }
  61  
  62      /**
  63       * Cacheable actions
  64       * @return array
  65       */
  66  	protected static function cacheablePageActions() {
  67          return array( 'view', 'history' );
  68      }
  69  
  70      /**
  71       * Get the base file cache directory
  72       * @return string
  73       */
  74  	protected function cacheDirectory() {
  75          return $this->baseCacheDirectory(); // no subdir for b/c with old cache files
  76      }
  77  
  78      /**
  79       * Get the cache type subdirectory (with the trailing slash) or the empty string
  80       * Alter the type -> directory mapping to put action=view cache at the root.
  81       *
  82       * @return string
  83       */
  84  	protected function typeSubdirectory() {
  85          if ( $this->mType === 'view' ) {
  86              return ''; //  b/c to not skip existing cache
  87          } else {
  88              return $this->mType . '/';
  89          }
  90      }
  91  
  92      /**
  93       * Check if pages can be cached for this request/user
  94       * @param IContextSource $context
  95       * @return bool
  96       */
  97  	public static function useFileCache( IContextSource $context ) {
  98          global $wgUseFileCache, $wgShowIPinHeader, $wgDebugToolbar, $wgContLang;
  99          if ( !$wgUseFileCache ) {
 100              return false;
 101          }
 102          if ( $wgShowIPinHeader || $wgDebugToolbar ) {
 103              wfDebug( "HTML file cache skipped. Either \$wgShowIPinHeader and/or \$wgDebugToolbar on\n" );
 104  
 105              return false;
 106          }
 107  
 108          // Get all query values
 109          $queryVals = $context->getRequest()->getValues();
 110          foreach ( $queryVals as $query => $val ) {
 111              if ( $query === 'title' || $query === 'curid' ) {
 112                  continue; // note: curid sets title
 113              // Normal page view in query form can have action=view.
 114              } elseif ( $query === 'action' && in_array( $val, self::cacheablePageActions() ) ) {
 115                  continue;
 116              // Below are header setting params
 117              } elseif ( $query === 'maxage' || $query === 'smaxage' ) {
 118                  continue;
 119              }
 120  
 121              return false;
 122          }
 123          $user = $context->getUser();
 124          // Check for non-standard user language; this covers uselang,
 125          // and extensions for auto-detecting user language.
 126          $ulang = $context->getLanguage()->getCode();
 127          $clang = $wgContLang->getCode();
 128  
 129          // Check that there are no other sources of variation
 130          if ( $user->getId() || $user->getNewtalk() || $ulang != $clang ) {
 131              return false;
 132          }
 133          // Allow extensions to disable caching
 134          return wfRunHooks( 'HTMLFileCache::useFileCache', array( $context ) );
 135      }
 136  
 137      /**
 138       * Read from cache to context output
 139       * @param IContextSource $context
 140       * @return void
 141       */
 142  	public function loadFromFileCache( IContextSource $context ) {
 143          global $wgMimeType, $wgLanguageCode;
 144  
 145          wfDebug( __METHOD__ . "()\n" );
 146          $filename = $this->cachePath();
 147  
 148          $context->getOutput()->sendCacheControl();
 149          header( "Content-Type: $wgMimeType; charset=UTF-8" );
 150          header( "Content-Language: $wgLanguageCode" );
 151          if ( $this->useGzip() ) {
 152              if ( wfClientAcceptsGzip() ) {
 153                  header( 'Content-Encoding: gzip' );
 154                  readfile( $filename );
 155              } else {
 156                  /* Send uncompressed */
 157                  wfDebug( __METHOD__ . " uncompressing cache file and sending it\n" );
 158                  readgzfile( $filename );
 159              }
 160          } else {
 161              readfile( $filename );
 162          }
 163          $context->getOutput()->disable(); // tell $wgOut that output is taken care of
 164      }
 165  
 166      /**
 167       * Save this cache object with the given text.
 168       * Use this as an ob_start() handler.
 169       * @param string $text
 170       * @return bool Whether $wgUseFileCache is enabled
 171       */
 172  	public function saveToFileCache( $text ) {
 173          global $wgUseFileCache;
 174  
 175          if ( !$wgUseFileCache || strlen( $text ) < 512 ) {
 176              // Disabled or empty/broken output (OOM and PHP errors)
 177              return $text;
 178          }
 179  
 180          wfDebug( __METHOD__ . "()\n", 'log' );
 181  
 182          $now = wfTimestampNow();
 183          if ( $this->useGzip() ) {
 184              $text = str_replace(
 185                  '</html>', '<!-- Cached/compressed ' . $now . " -->\n</html>", $text );
 186          } else {
 187              $text = str_replace(
 188                  '</html>', '<!-- Cached ' . $now . " -->\n</html>", $text );
 189          }
 190  
 191          // Store text to FS...
 192          $compressed = $this->saveText( $text );
 193          if ( $compressed === false ) {
 194              return $text; // error
 195          }
 196  
 197          // gzip output to buffer as needed and set headers...
 198          if ( $this->useGzip() ) {
 199              // @todo Ugly wfClientAcceptsGzip() function - use context!
 200              if ( wfClientAcceptsGzip() ) {
 201                  header( 'Content-Encoding: gzip' );
 202  
 203                  return $compressed;
 204              } else {
 205                  return $text;
 206              }
 207          } else {
 208              return $text;
 209          }
 210      }
 211  
 212      /**
 213       * Clear the file caches for a page for all actions
 214       * @param Title $title
 215       * @return bool Whether $wgUseFileCache is enabled
 216       */
 217  	public static function clearFileCache( Title $title ) {
 218          global $wgUseFileCache;
 219  
 220          if ( !$wgUseFileCache ) {
 221              return false;
 222          }
 223  
 224          foreach ( self::cacheablePageActions() as $type ) {
 225              $fc = new self( $title, $type );
 226              $fc->clearCache();
 227          }
 228  
 229          return true;
 230      }
 231  }