1. sfApplicationConfiguration.class.php
  2. /**
 * sfConfiguration represents a configuration for a symfony application.
 *
 * @package    symfony
 * @subpackage config
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfApplicationConfiguration.class.php 24042 2009-11-16 18:07:52Z Kris.Wallsmith $
 */
  3. abstract class sfApplicationConfiguration extends ProjectConfiguration
  4. {
  5.   static protected
  6.     $coreLoaded    = false,
  7.     $loadedHelpers = array();
  9.   protected
  10.     $configCache = null,
  11.     $application = null,
  12.     $environment = null,
  13.     $debug       = false,
  14.     $config      = array(),
  15.     $cache       = null;
  17.   /**
  18.    * Constructor.
  19.    *
  20.    * @param string            $environment    The environment name
  21.    * @param Boolean           $debug          true to enable debug mode
  22.    * @param string            $rootDir        The project root directory
  23.    * @param sfEventDispatcher $dispatcher     An event dispatcher
  24.    */
  25.   public function __construct($environment, $debug, $rootDir = null, sfEventDispatcher $dispatcher = null)
  26.   {
  27.     $this->environment = $environment;
  28.     $this->debug       = (boolean) $debug;
  29.     $this->application = str_replace('Configuration', '', get_class($this));
  31.     parent::__construct($rootDir, $dispatcher);
  33.     $this->configure();
  35.     $this->initConfiguration();
  37.     if (sfConfig::get('sf_check_lock'))
  38.     {
  39.       $this->checkLock();
  40.     }
  42.     if (file_exists($file = sfConfig::get('sf_app_cache_dir').'/config/configuration.php'))
  43.     {
  44.       $this->cache = require $file;
  45.     }
  47.     $this->initialize();
  49.     // store current sfConfig values
  50.     $this->config = sfConfig::getAll();
  51.   }
  53.   /**
  54.    * Configures the current configuration.
  55.    *
  56.    * Override this method if you want to customize your application configuration.
  57.    */
  58.   public function configure()
  59.   {
  60.   }
  62.   /**
  63.    * Initialized the current configuration.
  64.    *
  65.    * Override this method if you want to customize your application initialization.
  66.    */
  67.   public function initialize()
  68.   {
  69.   }
  71.   public function activate()
  72.   {
  73.     sfConfig::clear();
  74.     sfConfig::add($this->config);
  75.   }
  77.   /**
  78.    * Various initializations.
  79.    */
  80.   public function initConfiguration()
  81.   {
  82.     $configCache = $this->getConfigCache();
  84.     // in debug mode, start global timer
  85.     if ($this->isDebug() && !sfWebDebugPanelTimer::isStarted())
  86.     {
  87.       sfWebDebugPanelTimer::startTime();
  88.     }
  90.     // required core classes for the framework
  91.     if (!$this->isDebug() && !sfConfig::get('sf_test') && !self::$coreLoaded)
  92.     {
  93.       $configCache->import('config/core_compile.yml', false);
  94.     }
  96.     // autoloader(s)
  97.     $this->dispatcher->connect('autoload.filter_config', array($this, 'filterAutoloadConfig'));
  98.     sfAutoload::getInstance()->register();
  99.     if ($this->isDebug())
  100.     {
  101.       sfAutoloadAgain::getInstance()->register();
  102.     }
  104.     // load base settings
  105.     include($configCache->checkConfig('config/settings.yml'));
  106.     if ($file = $configCache->checkConfig('config/app.yml', true))
  107.     {
  108.       include($file);
  109.     }
  111.     if (false !== sfConfig::get('sf_csrf_secret'))
  112.     {
  113.       sfForm::enableCSRFProtection(sfConfig::get('sf_csrf_secret'));
  114.     }
  116.     sfWidget::setCharset(sfConfig::get('sf_charset'));
  117.     sfValidatorBase::setCharset(sfConfig::get('sf_charset'));
  119.     // force setting default timezone if not set
  120.     if ($default_timezone = sfConfig::get('sf_default_timezone'))
  121.     {
  122.       date_default_timezone_set($default_timezone);
  123.     }
  124.     else if (sfConfig::get('sf_force_default_timezone', true))
  125.     {
  126.       date_default_timezone_set(@date_default_timezone_get());
  127.     }
  129.     // error settings
  130.     ini_set('display_errors', $this->isDebug() ? 'on' : 'off');
  131.     error_reporting(sfConfig::get('sf_error_reporting'));
  133.     // initialize plugin configuration objects
  134.     $this->initializePlugins();
  136.     // compress output
  137.     if (!self::$coreLoaded)
  138.     {
  139.       ob_start(sfConfig::get('sf_compressed') ? 'ob_gzhandler' : '');
  140.     }
  142.     self::$coreLoaded = true;
  143.   }
  145.   /**
  146.    * Initializes plugin configuration objects.
  147.    */
  148.   protected function initializePlugins()
  149.   {
  150.     foreach ($this->pluginConfigurations as $name => $configuration)
  151.     {
  152.       if (
  153.         false === $configuration->initialize()
  154.         &&
  155.         is_readable($config = $configuration->getRootDir().'/config/config.php')
  156.       )
  157.       {
  158.         require $config;
  159.       }
  160.     }
  161.   }
  163.   /**
  164.    * Adds enabled plugins to autoload config.
  165.    * 
  166.    * @param   sfEvent $event
  167.    * @param   array   $config
  168.    * 
  169.    * @return  array
  170.    */
  171.   public function filterAutoloadConfig(sfEvent $event, array $config)
  172.   {
  173.     foreach ($this->pluginConfigurations as $name => $configuration)
  174.     {
  175.       $config = $configuration->filterAutoloadConfig($event, $config);
  176.     }
  178.     return $config;
  179.   }
  181.   /**
  182.    * Returns a configuration cache object for the current configuration.
  183.    *
  184.    * @return sfConfigCache A sfConfigCache instance
  185.    */
  186.   public function getConfigCache()
  187.   {
  188.     if (null === $this->configCache)
  189.     {
  190.       $this->configCache = new sfConfigCache($this);
  191.     }
  193.     return $this->configCache;
  194.   }
  196.   /**
  197.    * Check lock files to see if we're not in a cache cleaning process.
  198.    *
  199.    * @return void
  200.    */
  201.   public function checkLock()
  202.   {
  203.     if (
  204.       $this->hasLockFile(sfConfig::get('sf_data_dir').DIRECTORY_SEPARATOR.$this->getApplication().'_'.$this->getEnvironment().'-cli.lck', 5)
  205.       ||
  206.       $this->hasLockFile(sfConfig::get('sf_data_dir').DIRECTORY_SEPARATOR.$this->getApplication().'_'.$this->getEnvironment().'.lck')
  207.     )
  208.     {
  209.       // application is not available - we'll find the most specific unavailable page...
  210.       $files = array(
  211.         sfConfig::get('sf_app_config_dir').'/unavailable.php',
  212.         sfConfig::get('sf_config_dir').'/unavailable.php',
  213.         sfConfig::get('sf_web_dir').'/errors/unavailable.php',
  214.         $this->getSymfonyLibDir().'/exception/data/unavailable.php',
  215.       );
  217.       foreach ($files as $file)
  218.       {
  219.         if (is_readable($file))
  220.         {
  221.           include $file;
  222.           break;
  223.         }
  224.       }
  226.       die(1);
  227.     }
  228.   }
  230.   /**
  231.    * Determines if a lock file is present.
  232.    *
  233.    * @param  string  $lockFile             Name of the lock file.
  234.    * @param  integer $maxLockFileLifeTime  A max amount of life time for the lock file.
  235.    *
  236.    * @return bool true, if the lock file is present, otherwise false.
  237.    */
  238.   protected function hasLockFile($lockFile, $maxLockFileLifeTime = 0)
  239.   {
  240.     $isLocked = false;
  241.     if (is_readable($lockFile) && ($last_access = fileatime($lockFile)))
  242.     {
  243.       $now = time();
  244.       $timeDiff = $now - $last_access;
  246.       if (!$maxLockFileLifeTime || $timeDiff < $maxLockFileLifeTime)
  247.       {
  248.         $isLocked = true;
  249.       }
  250.       else
  251.       {
  252.         $isLocked = @unlink($lockFile) ? false : true;
  253.       }
  254.     }
  256.     return $isLocked;
  257.   }
  259.   /**
  260.    * Sets the project root directory.
  261.    *
  262.    * @param string $rootDir The project root directory
  263.    */
  264.   public function setRootDir($rootDir)
  265.   {
  266.     parent::setRootDir($rootDir);
  268.     sfConfig::add(array(
  269.       'sf_app'         => $this->getApplication(),
  270.       'sf_environment' => $this->getEnvironment(),
  271.       'sf_debug'       => $this->isDebug(),
  272.     ));
  274.     $this->setAppDir(sfConfig::get('sf_apps_dir').DIRECTORY_SEPARATOR.$this->getApplication());
  275.   }
  277.   /**
  278.    * Sets the app directory.
  279.    *
  280.    * @param string $appDir The absolute path to the app dir.
  281.    */
  282.   public function setAppDir($appDir)
  283.   {
  284.     sfConfig::add(array(
  285.       'sf_app_dir' => $appDir,
  287.       // SF_APP_DIR directory structure
  288.       'sf_app_config_dir'   => $appDir.DIRECTORY_SEPARATOR.'config',
  289.       'sf_app_lib_dir'      => $appDir.DIRECTORY_SEPARATOR.'lib',
  290.       'sf_app_module_dir'   => $appDir.DIRECTORY_SEPARATOR.'modules',
  291.       'sf_app_template_dir' => $appDir.DIRECTORY_SEPARATOR.'templates',
  292.       'sf_app_i18n_dir'     => $appDir.DIRECTORY_SEPARATOR.'i18n',
  293.     ));
  294.   }
  296.   /**
  297.    * @see sfProjectConfiguration
  298.    */
  299.   public function setCacheDir($cacheDir)
  300.   {
  301.     parent::setCacheDir($cacheDir);
  303.     sfConfig::add(array(
  304.       'sf_app_base_cache_dir' => $cacheDir.DIRECTORY_SEPARATOR.$this->getApplication(),
  305.       'sf_app_cache_dir'      => $appCacheDir = $cacheDir.DIRECTORY_SEPARATOR.$this->getApplication().DIRECTORY_SEPARATOR.$this->getEnvironment(),
  307.       // SF_CACHE_DIR directory structure
  308.       'sf_template_cache_dir' => $appCacheDir.DIRECTORY_SEPARATOR.'template',
  309.       'sf_i18n_cache_dir'     => $appCacheDir.DIRECTORY_SEPARATOR.'i18n',
  310.       'sf_config_cache_dir'   => $appCacheDir.DIRECTORY_SEPARATOR.'config',
  311.       'sf_test_cache_dir'     => $appCacheDir.DIRECTORY_SEPARATOR.'test',
  312.       'sf_module_cache_dir'   => $appCacheDir.DIRECTORY_SEPARATOR.'modules',
  313.     ));
  314.   }
  316.   /**
  317.    * Gets directories where controller classes are stored for a given module.
  318.    *
  319.    * @param string $moduleName The module name
  320.    *
  321.    * @return array An array of directories
  322.    */
  323.   public function getControllerDirs($moduleName)
  324.   {
  325.     if (!isset($this->cache['getControllerDirs'][$moduleName]))
  326.     {
  327.       $dirs = array();
  329.       $dirs[sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/actions'] = false; // application
  331.       foreach ($this->getPluginPaths() as $path)
  332.       {
  333.         if (is_dir($dir = $path.'/modules/'.$moduleName.'/actions'))
  334.         {
  335.           $dirs[$dir] = true; // plugins
  336.         }
  337.       }
  339.       if (is_dir($dir = $this->getSymfonyLibDir().'/controller/'.$moduleName.'/actions'))
  340.       {
  341.         $dirs[$dir] = true; // core modules
  342.       }
  344.       $this->cache['getControllerDirs'][$moduleName] = $dirs;
  345.     }
  347.     return $this->cache['getControllerDirs'][$moduleName];
  348.   }
  350.   /**
  351.    * Gets directories where lib files are stored for a given module.
  352.    *
  353.    * @param string $moduleName The module name
  354.    *
  355.    * @return array An array of directories
  356.    */
  357.   public function getLibDirs($moduleName)
  358.   {
  359.     $dirs = array();
  361.     $dirs[] = sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/lib';                  // application
  362.     $dirs = array_merge($dirs, $this->getPluginSubPaths('/modules/'.$moduleName.'/lib')); // plugins
  363.     $dirs[] = $this->getSymfonyLibDir().'/controller/'.$moduleName.'/lib';                // core modules
  364.     $dirs[] = sfConfig::get('sf_module_cache_dir').'/auto'.ucfirst($moduleName.'/lib');   // generated templates in cache
  366.     return $dirs;
  367.   }
  369.   /**
  370.    * Gets directories where template files are stored for a given module.
  371.    *
  372.    * @param string $moduleName The module name
  373.    *
  374.    * @return array An array of directories
  375.    */
  376.   public function getTemplateDirs($moduleName)
  377.   {
  378.     $dirs = array();
  380.     $dirs[] = sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/templates';                  // application
  381.     $dirs = array_merge($dirs, $this->getPluginSubPaths('/modules/'.$moduleName.'/templates')); // plugins
  382.     $dirs[] = $this->getSymfonyLibDir().'/controller/'.$moduleName.'/templates';                // core modules
  383.     $dirs[] = sfConfig::get('sf_module_cache_dir').'/auto'.ucfirst($moduleName.'/templates');   // generated templates in cache
  385.     return $dirs;
  386.   }
  388.   /**
  389.    * Gets the helper directories for a given module name.
  390.    *
  391.    * @param  string $moduleName The module name
  392.    *
  393.    * @return array  An array of directories
  394.    */
  395.   public function getHelperDirs($moduleName = '')
  396.   {
  397.     $dirs = array();
  399.     if ($moduleName)
  400.     {
  401.       $dirs[] = sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/lib/helper'; // module
  403.       $dirs = array_merge($dirs, $this->getPluginSubPaths('/modules/'.$moduleName.'/lib/helper'));
  404.     }
  406.     return array_merge(
  407.       $dirs,
  408.       array(
  409.         sfConfig::get('sf_app_lib_dir').'/helper',         // application
  410.         sfConfig::get('sf_lib_dir').'/helper',             // project
  411.       ),
  412.       $this->getPluginSubPaths('/lib/helper'),             // plugins
  413.       array($this->getSymfonyLibDir().'/helper')           // symfony
  414.     );
  415.   }
  417.   /**
  418.    * Gets the template directory to use for a given module and template file.
  419.    *
  420.    * @param string $moduleName    The module name
  421.    * @param string $templateFile  The template file
  422.    *
  423.    * @return string A template directory
  424.    */
  425.   public function getTemplateDir($moduleName, $templateFile)
  426.   {
  427.     if (!isset($this->cache['getTemplateDir'][$moduleName][$templateFile]))
  428.     {
  429.       $this->cache['getTemplateDir'][$moduleName][$templateFile] = null;
  430.       foreach ($this->getTemplateDirs($moduleName) as $dir)
  431.       {
  432.         if (is_readable($dir.'/'.$templateFile))
  433.         {
  434.           $this->cache['getTemplateDir'][$moduleName][$templateFile] = $dir;
  435.           break;
  436.         }
  437.       }
  438.     }
  440.     return $this->cache['getTemplateDir'][$moduleName][$templateFile];
  441.   }
  443.   /**
  444.    * Gets the template to use for a given module and template file.
  445.    *
  446.    * @param string $moduleName    The module name
  447.    * @param string $templateFile  The template file
  448.    *
  449.    * @return string A template path
  450.    */
  451.   public function getTemplatePath($moduleName, $templateFile)
  452.   {
  453.     $dir = $this->getTemplateDir($moduleName, $templateFile);
  455.     return $dir ? $dir.'/'.$templateFile : null;
  456.   }
  457.   /**
  458.    * @see sfProjectConfiguration
  459.    */
  460.   public function getPluginPaths()
  461.   {
  462.     if (!isset($this->cache['getPluginPaths']))
  463.     {
  464.       $this->cache['getPluginPaths'] = parent::getPluginPaths();
  465.     }
  467.     return $this->cache['getPluginPaths'];
  468.   }
  470.   /**
  471.    * Gets the decorator directories.
  472.    *
  473.    * @return array  An array of the decorator directories
  474.    */
  475.   public function getDecoratorDirs()
  476.   {
  477.     return array(sfConfig::get('sf_app_template_dir'));
  478.   }
  480.   /**
  481.    * Gets the decorator directory for a given template.
  482.    *
  483.    * @param  string $template The template file
  484.    *
  485.    * @return string A template directory
  486.    */
  487.   public function getDecoratorDir($template)
  488.   {
  489.     foreach ($this->getDecoratorDirs() as $dir)
  490.     {
  491.       if (is_readable($dir.'/'.$template))
  492.       {
  493.         return $dir;
  494.       }
  495.     }
  496.   }
  498.   /**
  499.    * Gets the i18n directories to use globally.
  500.    *
  501.    * @return array An array of i18n directories
  502.    */
  503.   public function getI18NGlobalDirs()
  504.   {
  505.     $dirs = array();
  507.     // application
  508.     if (is_dir($dir = sfConfig::get('sf_app_i18n_dir')))
  509.     {
  510.       $dirs[] = $dir;
  511.     }
  513.     // plugins
  514.     return array_merge($dirs, $this->getPluginSubPaths('/i18n'));
  515.   }
  517.   /**
  518.    * Gets the i18n directories to use for a given module.
  519.    *
  520.    * @param string $moduleName The module name
  521.    *
  522.    * @return array An array of i18n directories
  523.    */
  524.   public function getI18NDirs($moduleName)
  525.   {
  526.     $dirs = array();
  528.     // module
  529.     if (is_dir($dir = sfConfig::get('sf_app_module_dir').'/'.$moduleName.'/i18n'))
  530.     {
  531.       $dirs[] = $dir;
  532.     }
  534.     // application
  535.     if (is_dir($dir = sfConfig::get('sf_app_i18n_dir')))
  536.     {
  537.       $dirs[] = $dir;
  538.     }
  540.     return array_merge(
  541.       $dirs,
  542.       $this->getPluginSubPaths('/modules/'.$moduleName.'/i18n'), // module in plugins
  543.       $this->getPluginSubPaths('/i18n')                          // plugins
  544.     );
  545.   }
  547.   /**
  548.    * Gets the configuration file paths for a given relative configuration path.
  549.    *
  550.    * @param string $configPath The configuration path
  551.    *
  552.    * @return array An array of paths
  553.    */
  554.   public function getConfigPaths($configPath)
  555.   {
  556.     $globalConfigPath = basename(dirname($configPath)).'/'.basename($configPath);
  558.     $files = array(
  559.       $this->getSymfonyLibDir().'/config/'.$globalConfigPath, // symfony
  560.     );
  562.     foreach ($this->getPluginPaths() as $path)
  563.     {
  564.       if (is_file($file = $path.'/'.$globalConfigPath))
  565.       {
  566.         $files[] = $file;                                     // plugins
  567.       }
  568.     }
  570.     $files = array_merge($files, array(
  571.       $this->getRootDir().'/'.$globalConfigPath,              // project
  572.       $this->getRootDir().'/'.$configPath,                    // project
  573.       sfConfig::get('sf_app_dir').'/'.$globalConfigPath,      // application
  574.       sfConfig::get('sf_app_cache_dir').'/'.$configPath,      // generated modules
  575.     ));
  577.     foreach ($this->getPluginPaths() as $path)
  578.     {
  579.       if (is_file($file = $path.'/'.$configPath))
  580.       {
  581.         $files[] = $file;                                     // plugins
  582.       }
  583.     }
  585.     $files[] = sfConfig::get('sf_app_dir').'/'.$configPath;   // module
  587.     $configs = array();
  588.     foreach (array_unique($files) as $file)
  589.     {
  590.       if (is_readable($file))
  591.       {
  592.         $configs[] = $file;
  593.       }
  594.     }
  596.     return $configs;
  597.   }
  599.   /**
  600.    * Loads helpers.
  601.    *
  602.    * @param array  $helpers     An array of helpers to load
  603.    * @param string $moduleName  A module name (optional)
  604.    */
  605.   public function loadHelpers($helpers, $moduleName = '')
  606.   {
  607.     foreach ((array) $helpers as $helperName)
  608.     {
  609.       if (isset(self::$loadedHelpers[$helperName]))
  610.       {
  611.         continue;
  612.       }
  614.       if (isset($this->cache['loadedHelpers'][$moduleName][$helperName]))
  615.       {
  616.         include_once $this->cache['loadedHelpers'][$moduleName][$helperName];
  617.       }
  618.       else if (isset($this->cache['loadedHelpers'][''][$helperName]))
  619.       {
  620.         include_once $this->cache['loadedHelpers'][''][$helperName];
  621.       }
  622.       else
  623.       {
  624.         $fileName = $helperName.'Helper.php';
  626.         if (!isset($dirs))
  627.         {
  628.           $dirs = $this->getHelperDirs($moduleName);
  629.         }
  631.         foreach ($dirs as $dir)
  632.         {
  633.           $included = false;
  634.           if (is_readable($dir.'/'.$fileName))
  635.           {
  636.             include_once $dir.'/'.$fileName;
  637.             $included = true;
  638.             break;
  639.           }
  640.         }
  642.         if (!$included)
  643.         {
  644.           throw new InvalidArgumentException(sprintf('Unable to load "%sHelper.php" helper in: %s.', $helperName, implode(', ', array_map(array('sfDebug', 'shortenFilePath'), $dirs))));
  645.         }
  646.       }
  648.       self::$loadedHelpers[$helperName] = true;
  649.     }
  650.   }
  652.   /**
  653.    * Returns the application name.
  654.    *
  655.    * @return string The application name
  656.    */
  657.   public function getApplication()
  658.   {
  659.     return $this->application;
  660.   }
  662.   /**
  663.    * Returns the environment name.
  664.    *
  665.    * @return string The environment name
  666.    */
  667.   public function getEnvironment()
  668.   {
  669.     return $this->environment;
  670.   }
  672.   /**
  673.    * Returns true if this configuration has debug enabled.
  674.    *
  675.    * @return Boolean true if the configuration has debug enabled, false otherwise
  676.    */
  677.   public function isDebug()
  678.   {
  679.     return $this->debug;
  680.   }
  681. }
Debug toolbar