1. sfConfigCache.class.php
  2. /**
 * sfConfigCache allows you to customize the format of a configuration file to
 * make it easy-to-use, yet still provide a PHP formatted result for direct
 * inclusion into your modules.
 *
 * @package    symfony
 * @subpackage config
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfConfigCache.class.php 23810 2009-11-12 11:07:44Z Kris.Wallsmith $
 */
  3. class sfConfigCache
  4. {
  5.   protected
  6.     $configuration = null,
  7.     $handlers      = array(),
  8.     $userHandlers  = array();
  10.   /**
  11.    * Constructor
  12.    *
  13.    * @param sfApplicationConfiguration $configuration A sfApplicationConfiguration instance
  14.    */
  15.   public function __construct(sfApplicationConfiguration $configuration)
  16.   {
  17.     $this->configuration = $configuration;
  18.   }
  20.   /**
  21.    * Loads a configuration handler.
  22.    *
  23.    * @param string $handler The handler to use when parsing a configuration file
  24.    * @param array  $configs An array of absolute filesystem paths to configuration files
  25.    * @param string $cache   An absolute filesystem path to the cache file that will be written
  26.    *
  27.    * @throws <b>sfConfigurationException</b> If a requested configuration file does not have an associated configuration handler
  28.    */
  29.   protected function callHandler($handler, $configs, $cache)
  30.   {
  31.     if (count($this->handlers) == 0)
  32.     {
  33.       // we need to load the handlers first
  34.       $this->loadConfigHandlers();
  35.     }
  37.     if (count($this->userHandlers) != 0)
  38.     {
  39.       // we load user defined handlers
  40.       $this->mergeUserConfigHandlers();
  41.     }
  43.     // handler instance to call for this configuration file
  44.     $handlerInstance = null;
  46.     $handler = str_replace(DIRECTORY_SEPARATOR, '/', $handler);
  48.     // grab the base name of the handler
  49.     $basename = basename($handler);
  50.     if (isset($this->handlers[$handler]))
  51.     {
  52.       // we have a handler associated with the full configuration path
  53.       $handlerInstance = $this->getHandler($handler);
  54.     }
  55.     else if (isset($this->handlers[$basename]))
  56.     {
  57.       // we have a handler associated with the configuration base name
  58.       $handlerInstance = $this->getHandler($basename);
  59.     }
  60.     else
  61.     {
  62.       // let's see if we have any wildcard handlers registered that match this basename
  63.       foreach (array_keys($this->handlers) as $key)
  64.       {
  65.         // replace wildcard chars in the configuration
  66.         $pattern = strtr($key, array('.' => '\.', '*' => '(.*?)'));
  67.         $matches = array();
  69.         // create pattern from config
  70.         if (preg_match('#'.$pattern.'$#', $handler, $matches))
  71.         {
  72.           $handlerInstance = $this->getHandler($key);
  73.           array_shift($matches);
  74.           $handlerInstance->getParameterHolder()->set('wildcardValues', $matches);
  76.           break;
  77.         }
  78.       }
  79.     }
  81.     if (!$handlerInstance)
  82.     {
  83.       // we do not have a registered handler for this file
  84.       throw new sfConfigurationException(sprintf('Configuration file "%s" does not have a registered handler.', implode(', ', $configs)));
  85.     }
  87.     // call the handler and retrieve the cache data
  88.     $data = $handlerInstance->execute($configs);
  90.     $this->writeCacheFile($handler, $cache, $data);
  91.   }
  93.   /**
  94.    * Returns the config handler configured for the given name
  95.    *
  96.    * @param string $name The config handler name
  97.    *
  98.    * @return sfConfigHandler A sfConfigHandler instance
  99.    */
  100.   protected function getHandler($name)
  101.   {
  102.     if (is_array($this->handlers[$name]))
  103.     {
  104.       $class = $this->handlers[$name][0];
  105.       $this->handlers[$name] = new $class($this->handlers[$name][1]);
  106.     }
  108.     return $this->handlers[$name];
  109.   }
  111.   /**
  112.    * Checks to see if a configuration file has been modified and if so
  113.    * recompile the cache file associated with it.
  114.    *
  115.    * The recompilation only occurs in a non debug environment.
  116.    *
  117.    * If the configuration file path is relative, symfony will look in directories 
  118.    * defined in the sfConfiguration::getConfigPaths() method.
  119.    *
  120.    * @param string  $configPath A filesystem path to a configuration file
  121.    * @param boolean $optional   If true, config path does not need to exist
  122.    *
  123.    * @return string An absolute filesystem path to the cache filename associated with this specified configuration file
  124.    *
  125.    * @throws <b>sfConfigurationException</b> If a requested configuration file does not exist
  126.    *
  127.    * @see sfConfiguration::getConfigPaths()
  128.    */
  129.   public function checkConfig($configPath, $optional = false)
  130.   {
  131.     if (sfConfig::get('sf_debug') && sfConfig::get('sf_logging_enabled'))
  132.     {
  133.       $timer = sfTimerManager::getTimer('Configuration');
  134.     }
  136.     // the cache filename we'll be using
  137.     $cache = $this->getCacheName($configPath);
  139.     if (!sfConfig::get('sf_debug') && !sfConfig::get('sf_test') && is_readable($cache))
  140.     {
  141.       return $cache;
  142.     }
  144.     if (!sfToolkit::isPathAbsolute($configPath))
  145.     {
  146.       $files = $this->configuration->getConfigPaths($configPath);
  147.     }
  148.     else
  149.     {
  150.       $files = is_readable($configPath) ? array($configPath) : array();
  151.     }
  153.     if (!isset($files[0]))
  154.     {
  155.       if ($optional)
  156.       {
  157.         return null;
  158.       }
  160.       // configuration does not exist
  161.       throw new sfConfigurationException(sprintf('Configuration "%s" does not exist or is unreadable.', $configPath));
  162.     }
  164.     // find the more recent configuration file last modification time
  165.     $mtime = 0;
  166.     foreach ($files as $file)
  167.     {
  168.       if (filemtime($file) > $mtime)
  169.       {
  170.         $mtime = filemtime($file);
  171.       }
  172.     }
  174.     if (!is_readable($cache) || $mtime > filemtime($cache))
  175.     {
  176.       // configuration has changed so we need to reparse it
  177.       $this->callHandler($configPath, $files, $cache);
  178.     }
  180.     if (sfConfig::get('sf_debug') && sfConfig::get('sf_logging_enabled'))
  181.     {
  182.       $timer->addTime();
  183.     }
  185.     return $cache;
  186.   }
  188.   /**
  189.    * Clears all configuration cache files.
  190.    */
  191.   public function clear()
  192.   {
  193.     sfToolkit::clearDirectory(sfConfig::get('sf_config_cache_dir'));
  194.   }
  196.   /**
  197.    * Converts a normal filename into a cache filename.
  198.    *
  199.    * @param string $config A normal filename
  200.    *
  201.    * @return string An absolute filesystem path to a cache filename
  202.    */
  203.   public function getCacheName($config)
  204.   {
  205.     if (strlen($config) > 3 && ctype_alpha($config[0]) && $config[1] == ':' && ($config[2] == '\\' || $config[2] == '/'))
  206.     {
  207.       // file is a windows absolute path, strip off the drive letter
  208.       $config = substr($config, 3);
  209.     }
  211.     // replace unfriendly filename characters with an underscore
  212.     $config  = str_replace(array('\\', '/', ' '), '_', $config);
  213.     $config .= '.php';
  215.     return sfConfig::get('sf_config_cache_dir').'/'.$config;
  216.   }
  218.   /**
  219.    * Imports a configuration file.
  220.    *
  221.    * @param string $config   A filesystem path to a configuration file
  222.    * @param bool   $once     Only allow this configuration file to be included once per request?
  223.    * @param bool   $optional Only include if true
  224.    *
  225.    * @see checkConfig()
  226.    */
  227.   public function import($config, $once = true, $optional = false)
  228.   {
  229.     $cache = $this->checkConfig($config, $optional);
  231.     if ($optional && !$cache)
  232.     {
  233.       return;
  234.     }
  236.     // include cache file
  237.     if ($once)
  238.     {
  239.       include_once($cache);
  240.     }
  241.     else
  242.     {
  243.       include($cache);
  244.     }
  245.   }
  247.   /**
  248.    * Loads all configuration application and module level handlers.
  249.    *
  250.    * @throws <b>sfConfigurationException</b> If a configuration related error occurs.
  251.    */
  252.   protected function loadConfigHandlers()
  253.   {
  254.     // manually create our config_handlers.yml handler
  255.     $this->handlers['config_handlers.yml'] = new sfRootConfigHandler();
  257.     // application configuration handlers
  259.     require $this->checkConfig('config/config_handlers.yml');
  261.     // module level configuration handlers
  263.     // checks modules directory exists
  264.     if (!is_readable($sf_app_modules_dir = sfConfig::get('sf_app_modules_dir')))
  265.     {
  266.       return;
  267.     }
  269.     // ignore names
  270.     $ignore = array('.', '..', 'CVS', '.svn');
  272.     // create a file pointer to the module dir
  273.     $fp = opendir($sf_app_modules_dir);
  275.     // loop through the directory and grab the modules
  276.     while (($directory = readdir($fp)) !== false)
  277.     {
  278.       if (in_array($directory, $ignore))
  279.       {
  280.         continue;
  281.       }
  283.       $configPath = $sf_app_modules_dir.'/'.$directory.'/config/config_handlers.yml';
  285.       if (is_readable($configPath))
  286.       {
  287.         // initialize the root configuration handler with this module name
  288.         $params = array('module_level' => true, 'module_name' => $directory);
  290.         $this->handlers['config_handlers.yml']->initialize($params);
  292.         // replace module dir path with a special keyword that
  293.         // checkConfig knows how to use
  294.         $configPath = 'modules/'.$directory.'/config/config_handlers.yml';
  296.         require $this->checkConfig($configPath);
  297.       }
  298.     }
  300.     // close file pointer
  301.     closedir($fp);
  302.   }
  304.   /**
  305.    * Writes a cache file.
  306.    *
  307.    * @param string $config An absolute filesystem path to a configuration file
  308.    * @param string $cache  An absolute filesystem path to the cache file that will be written
  309.    * @param string $data   Data to be written to the cache file
  310.    *
  311.    * @throws sfCacheException If the cache file cannot be written
  312.    */
  313.   protected function writeCacheFile($config, $cache, $data)
  314.   {
  315.     $current_umask = umask(0000);
  316.     if (!is_dir(dirname($cache)))
  317.     {
  318.       if (false === @mkdir(dirname($cache), 0777, true))
  319.       {
  320.         throw new sfCacheException(sprintf('Failed to make cache directory "%s" while generating cache for configuration file "%s".', dirname($cache), $config));
  321.       }
  322.     }
  324.     $tmpFile = tempnam(dirname($cache), basename($cache));
  326.     if (!$fp = @fopen($tmpFile, 'wb'))
  327.     {
  328.       throw new sfCacheException(sprintf('Failed to write cache file "%s" generated from configuration file "%s".', $tmpFile, $config));
  329.     }
  331.     @fwrite($fp, $data);
  332.     @fclose($fp);
  334.     // Hack from Agavi (http://trac.agavi.org/changeset/3979)
  335.     // With php < 5.2.6 on win32, renaming to an already existing file doesn't work, but copy does,
  336.     // so we simply assume that when rename() fails that we are on win32 and try to use copy()
  337.     if (!@rename($tmpFile, $cache))
  338.     {
  339.       if (copy($tmpFile, $cache))
  340.       {
  341.         unlink($tmpFile);
  342.       }
  343.     }
  345.     chmod($cache, 0666);
  346.     umask($current_umask);
  347.   }
  349.   /**
  350.    * Registers a configuration handler.
  351.    *
  352.    * @param string $handler The handler to use when parsing a configuration file
  353.    * @param class  $class   A configuration handler class
  354.    * @param string $params  An array of options for the handler class initialization
  355.    */
  356.   public function registerConfigHandler($handler, $class, $params = array())
  357.   {
  358.     $this->userHandlers[$handler] = new $class($params);
  359.   }
  361.   /**
  362.    * Merges configuration handlers from the config_handlers.yml  
  363.    * and the ones defined with registerConfigHandler()
  364.    *
  365.    */
  366.   protected function mergeUserConfigHandlers()
  367.   {
  368.     // user defined configuration handlers
  369.     $this->handlers = array_merge($this->handlers, $this->userHandlers);
  371.     $this->userHandlers = array();
  372.   }
  373. }
Debug toolbar