/**
* Executes this task.
*/
public function main()
{
if ($this->path === null) {
throw new BuildException('The path attribute must be specified');
}
$check = new AgaviModuleFilesystemCheck();
$check->setConfigDirectory($this->project->getProperty('module.config.directory'));
$check->setPath($this->path->getAbsolutePath());
if (!$check->check()) {
throw new BuildException('The path attribute must be a valid module base directory');
}
/* We don't know whether the module is configured or not here, so load the
* values we want properly. */
$this->tryLoadAgavi();
$this->tryBootstrapAgavi();
require_once AgaviConfigCache::checkConfig(sprintf('%s/%s/module.xml', $this->path->getAbsolutePath(), (string) $this->project->getProperty('module.config.directory')));
$actionPath = AgaviToolkit::expandVariables(AgaviToolkit::expandDirectives(AgaviConfig::get(sprintf('modules.%s.agavi.action.path', strtolower($this->path->getName())), '%core.module_dir%/${moduleName}/actions/${actionName}Action.class.php')), array('moduleName' => $this->path->getName()));
$pattern = '#^' . AgaviToolkit::expandVariables(str_replace('\\$\\{actionName\\}', '${actionName}', preg_quote($actionPath, '#')), array('actionName' => '(?P<action_name>.*?)')) . '$#';
$iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->path->getAbsolutePath()));
for (; $iterator->valid(); $iterator->next()) {
$rdi = $iterator->getInnerIterator();
if ($rdi->isDot() || !$rdi->isFile()) {
continue;
}
$file = $rdi->getPathname();
if (preg_match($pattern, $file, $matches)) {
$this->log(str_replace(DIRECTORY_SEPARATOR, '.', $matches['action_name']));
}
}
}
public static function dispatch($arguments = array())
{
$GLOBALS['__PHPUNIT_BOOTSTRAP'] = dirname(__FILE__) . '/templates/AgaviBootstrap.tpl.php';
$suites = (include AgaviConfigCache::checkConfig(AgaviConfig::get('core.testing_dir') . '/config/suites.xml'));
$master_suite = new AgaviTestSuite('Master');
if (!empty($arguments['include-suite'])) {
$names = explode(',', $arguments['include-suite']);
unset($arguments['include-suite']);
foreach ($names as $name) {
if (empty($suites[$name])) {
throw new InvalidArgumentException(sprintf('Invalid suite name %1$s.', $name));
}
$master_suite->addTest(self::createSuite($name, $suites[$name]));
}
} else {
$excludes = array();
if (!empty($arguments['exclude-suite'])) {
$excludes = explode(',', $arguments['exclude-suite']);
unset($arguments['exclude-suite']);
}
foreach ($suites as $name => $suite) {
if (!in_array($name, $excludes)) {
$master_suite->addTest(self::createSuite($name, $suite));
}
}
}
$runner = new PHPUnit_TextUI_TestRunner();
$runner->doRun($master_suite, $arguments);
}
/**
* Handles autoloading of classes
*
* @param string A class name.
*
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
public static function __autoload($class)
{
if (self::$autoloads === null) {
self::$autoloads = array();
// catch parse errors of autoload.xml
try {
$cfg = AgaviConfig::get('core.config_dir') . '/autoload.xml';
if (!is_readable($cfg)) {
$cfg = AgaviConfig::get('core.system_config_dir') . '/autoload.xml';
if (!is_readable($cfg)) {
return;
}
}
self::$autoloads = (include AgaviConfigCache::checkConfig($cfg));
// if(class_exists($class, false)) {
// return;
// }
} catch (Exception $e) {
trigger_error($e->getMessage(), E_USER_ERROR);
}
}
if (isset(self::$autoloads[$class])) {
// class exists, let's include it
require self::$autoloads[$class];
}
/*
If the class doesn't exist in autoload.xml there's not a lot we can do. Because
PHP's class_exists resorts to __autoload we cannot throw exceptions
for this might break some 3rd party lib autoloading mechanism.
*/
}
public function initialize(AgaviContext $ctx, array $parameters = array())
{
parent::initialize($ctx, $parameters);
$this->dqlViews = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.module_dir%/Api/config/views.xml')));
$this->view = $parameters["view"];
$this->viewParameters = isset($parameters["parameters"]) ? $parameters["parameters"] : array();
$this->validateTarget();
$connection = $this->defaultConnection;
if (isset($parameters["connection"])) {
$connection = $parameters["connection"];
}
if ($this->view["connection"]) {
$connection = $this->view["connection"];
}
AppKitLogger::verbose("Switching to connection %s", $connection);
$db = $this->getContext()->getDatabaseManager()->getDatabase($connection);
$this->useRetained = $db->useRetained();
$this->connection = $ctx->getDatabaseConnection($connection);
if ($this->connection != "icinga") {
$ctx->getModel("DBALMetaManager", "Api")->switchIcingaDatabase($connection);
}
$this->user = $this->getContext()->getUser()->getNsmUser();
$this->parseBaseDQL();
$this->parseCustomVariables();
$this->parseDQLExtensions();
$this->parseDependencies();
}
private function importModuleXML($accessLocation)
{
$config = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives($accessLocation)));
$this->instances = array_merge_recursive($this->instances, $config["instances"]);
$this->defaults = array_merge_recursive($this->defaults, $config["defaults"]);
$this->hosts = array_merge_recursive($this->hosts, $config["hosts"]);
}
public static function loadConfig()
{
if (self::$configLoaded) {
return;
}
self::$config = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.module_dir%/Api/config/access.xml')));
self::$configLoaded = true;
}
public function initialize(AgaviContext $context, array $parameters = array())
{
parent::initialize($context, $parameters);
$this->config = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.module_dir%/Api/config/icingaCommands.xml')));
$this->user = $context->getUser();
if ($this->user->getNsmUser()->hasTarget('IcingaCommandRestrictions')) {
$this->filterCommandsByUser($this->config);
}
}
/**
* (non-PHPdoc)
* @see CronksBaseModel::initialize()
*/
public function initialize(AgaviContext $context, array $parameters = array())
{
parent::initialize($context, $parameters);
// Init cronk categgory configurtion
$tmp = (include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/cronks.xml'));
self::$xml_categories = (array) $tmp[1];
// Init user objects
$this->refreshUser();
}
/**
* Initialize this AgaviLoggingManager.
*
* @param AgaviContext An AgaviContext instance.
* @param array An array of initialization parameters.
*
* @throws <b>AgaviInitializationException</b> If an error occurs while
* initializing this instance.
*
* @author David Zülke <*****@*****.**>
* @author Sean Kerr <*****@*****.**>
* @since 0.9.0
*/
public function initialize(AgaviContext $context, array $parameters = array())
{
$this->context = $context;
if (isset($parameters['default_message_class'])) {
$this->defaultMessageClass = $parameters['default_message_class'];
}
// load logging configuration
require AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/logging.xml', $context->getName());
}
/**
* Initialize this model.
*
* @param AgaviContext The current application context.
*
* @author Luis Merino <*****@*****.**>
* @since 0.1.0
*/
public function initialize(AgaviContext $context, array $parameters = array())
{
$this->context = $context;
try {
$cfg = AgaviConfig::get('core.config_dir') . '/static_files.xml';
$this->cacheName = AgaviConfigCache::checkConfig($cfg, $this->context->getName());
require $this->cacheName;
} catch (AgaviUnreadableException $e) {
throw new AgaviConfigurationException($e->getMessage());
}
}
/**
* Dispatch the test run.
*
* @param array An array of arguments configuring PHPUnit behavior.
* @param bool Whether exit() should be called with an appropriate shell
* exit status to indicate success or failures/errors.
*
* @return PHPUnit_Framework_TestResult The PHPUnit result object.
*
* @author Felix Gilcher <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 1.0.0
* @deprecated 1.1.0 Use AgaviPhpUnitCli
*/
public static function dispatch($arguments = array(), $exit = true)
{
$suites = (include AgaviConfigCache::checkConfig(AgaviConfig::get('core.testing_dir') . '/config/suites.xml'));
$master_suite = new AgaviTestSuite('Master');
if (!empty($arguments['include-suite'])) {
$names = explode(',', $arguments['include-suite']);
unset($arguments['include-suite']);
foreach ($names as $name) {
if (empty($suites[$name])) {
throw new InvalidArgumentException(sprintf('Invalid suite name %1$s.', $name));
}
$master_suite->addTest(self::createSuite($name, $suites[$name]));
}
} else {
$excludes = array();
if (!empty($arguments['exclude-suite'])) {
$excludes = explode(',', $arguments['exclude-suite']);
unset($arguments['exclude-suite']);
}
foreach ($suites as $name => $suite) {
if (!in_array($name, $excludes)) {
$master_suite->addTest(self::createSuite($name, $suite));
}
}
}
if (version_compare(PHPUnit_Runner_Version::id(), '3.6', '<')) {
// PHP_CodeCoverage_Filter is a singleton
$runner = new PHPUnit_TextUI_TestRunner();
} else {
// PHP_CodeCoverage_Filter instance must be passed to the test runner
$runner = new PHPUnit_TextUI_TestRunner(null, self::$codeCoverageFilter);
}
$result = $runner->doRun($master_suite, $arguments);
if ($exit) {
// bai
exit(self::getExitStatus($result));
} else {
// return result so calling code can use it
return $result;
}
}
public function initialize(AgaviContext $context, array $parameters = array())
{
$this->context = $context;
include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/translation.xml');
$this->loadSupplementalData();
$this->loadTimeZoneData();
$this->loadAvailableLocales();
if ($this->defaultLocaleIdentifier === null) {
throw new AgaviException('Tried to use the translation system without a default locale and without a locale set');
}
$this->setLocale($this->defaultLocaleIdentifier);
if ($this->defaultTimeZone === null) {
$this->defaultTimeZone = date_default_timezone_get();
} else {
date_default_timezone_set($this->defaultTimeZone);
}
if ($this->defaultTimeZone === 'System/Localtime') {
// http://trac.agavi.org/ticket/1008
throw new AgaviException("Your default timezone is 'System/Localtime', which will causes problems with icinga-web date function." . "Please set date.timezone in your php.ini or set a default timezone in the app/config/translations.xml file of icinga-web.");
}
}
/**
* Executes the task.
*/
public function main()
{
if ($this->name === null) {
throw new BuildException('The name attribute must be specified');
}
$this->tryLoadAgavi();
$this->tryBootstrapAgavi();
/* Oookay. This is interesting. */
$moduleName = $this->name;
require_once AgaviConfigCache::checkConfig(sprintf('%s/%s/%s/%s/module.xml', (string) $this->project->getProperty('project.directory'), (string) $this->project->getProperty('project.directory.app.modules'), $this->name, (string) $this->project->getProperty('module.config.directory')));
/* Set up us the values.
*
* XXX: With regards to the defaults:
*
* You might expect to use the <property>.default properties defined in
* build.xml. But this is not so; consider that someone might have decided
* to upgrade their project properties but still have some legacy modules
* lying around. We need to use the actual Agavi defaults to ensure
* consistency.
*
* If you change this, you're f*****g asking for it. */
$values = array();
$lowerModuleName = strtolower($moduleName);
$values['action.path'] = AgaviConfig::get(sprintf('modules.%s.agavi.action.path', $lowerModuleName), '%core.module_dir%/${moduleName}/actions/${actionName}Action.class.php');
$values['action.path'] = AgaviToolkit::expandVariables($values['action.path'], array('moduleName' => $moduleName));
$values['cache.path'] = AgaviConfig::get(sprintf('modules.%s.agavi.cache.path', $lowerModuleName), '%core.module_dir%/${moduleName}/cache/${actionName}.xml');
$values['cache.path'] = AgaviToolkit::expandVariables($values['cache.path'], array('moduleName' => $moduleName));
$values['templates.directory'] = AgaviConfig::get(sprintf('modules.%s.agavi.template.directory', $lowerModuleName), '%core.module_dir%/${module}/templates');
$values['templates.directory'] = AgaviToolkit::expandVariables($values['templates.directory'], array('module' => $moduleName));
$values['validate.path'] = AgaviConfig::get(sprintf('modules.%s.agavi.validate.path', $lowerModuleName), '%core.module_dir%/${moduleName}/validate/${actionName}.xml');
$values['validate.path'] = AgaviToolkit::expandVariables($values['validate.path'], array('moduleName' => $moduleName));
$values['view.path'] = AgaviConfig::get(sprintf('modules.%s.agavi.view.path', $lowerModuleName), '%core.module_dir%/${moduleName}/views/${viewName}View.class.php');
$values['view.path'] = AgaviToolkit::expandVariables($values['view.path'], array('moduleName' => $moduleName));
$values['view.name'] = AgaviConfig::get(sprintf('modules.%s.agavi.view.name', $lowerModuleName), '${actionName}${viewName}');
/* Main screen turn on. */
foreach ($values as $name => $value) {
$this->project->setUserProperty(sprintf('%s.%s', $this->prefix, $name), $value);
}
}
/**
* (non-PHPdoc)
* @see AppKitBaseModel::initialize()
*/
public function initialize(AgaviContext $ctx, array $parameters = array())
{
parent::initialize($ctx, $parameters);
include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/javascript.xml');
include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/css.xml');
}
/**
* Get validation information from agavi for the given action and module
* name for the request method 'read'.
*
* @author Jan Schütze <*****@*****.**>
*
* @param string $action name of action
* @param string $module name of module
*
* @return array of parameters for all registered validators
*/
protected function getParametersForActionAndModule($action, $module, $method = 'read')
{
/*
* Agavi uses different coding standard, so we ignore the following...
*
* @codingStandardsIgnoreStart
*/
$parameters = array();
$this->getContext()->getController()->initializeModule($module);
$validationManager = $this->getContext()->createInstanceFor('validation_manager');
$validationConfig = \AgaviToolkit::evaluateModuleDirective($module, 'agavi.validate.path', array('moduleName' => $module, 'actionName' => \AgaviToolkit::canonicalName($action)));
if (is_readable($validationConfig)) {
require \AgaviConfigCache::checkConfig($validationConfig, $this->getContext()->getName());
}
foreach ($validationManager->getChilds() as $validator) {
$property = new \ReflectionProperty(get_class($validator), 'arguments');
$property->setAccessible(true);
$arguments = $property->getValue($validator);
$parameters[] = array('name' => implode(', ', $arguments), 'class' => $validator->getParameter('class'), 'required' => $validator->getParameter('required', 'true'), 'description' => $validator->getParameter('description', null), 'base' => $validator->getParameter('base', null));
}
/*
* @codingStandardsIgnoreEnd
*/
return $parameters;
}
/**
* Return a list of cronks defined in xml
* @param boolean $all
* @return array
*/
private function getXmlCronks($all = false)
{
// pull cronk xml data from the cache
$cached = $this->user->getStorage()->read("icinga.cronks.cache.xml");
// get me a timestamp for our xml disk cache for cronks
$configcache_ts = filemtime(AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/cronks.xml'));
// do we have any cache?
if (isset($cached) and isset($cached["data"])) {
// is the cached data newer than that in the xml cache on disk?
if (isset($cached["timestamp"]) and $cached["timestamp"] > $configcache_ts) {
// return cache
return $cached["data"];
}
}
$out = array();
foreach (self::$xml_cronk_data as $uid => $cronk) {
/*
* Database credentials overwrite xml credentials
*/
$this->getSecurityModel()->setCronkUid($uid);
if ($this->getSecurityModel()->hasDatabaseRoles()) {
$cronk['groupsonly'] = $this->getSecurityModel()->getRoleNamesAsString();
}
if (isset($cronk['groupsonly']) && $this->checkGroups($cronk['groupsonly']) !== true && $this->agaviUser->hasCredential('icinga.cronk.admin') === false) {
continue;
} elseif (isset($cronk['principalsonly']) && $this->checkPrincipals($cronk['principalsonly']) !== true) {
continue;
} elseif (isset($cronk['disabled']) && $cronk['disabled'] == true) {
continue;
} elseif (!isset($cronk['action']) || !isset($cronk['module'])) {
$this->getContext()->getLoggerManager()->log('No action or module for cronk: ' . $uid, AgaviLogger::ERROR);
continue;
}
$out[$uid] = array('cronkid' => $uid, 'module' => $cronk['module'], 'action' => $cronk['action'], 'hide' => isset($cronk['hide']) ? (bool) $cronk['hide'] : false, 'description' => isset($cronk['description']) ? $cronk['description'] : null, 'name' => isset($cronk['name']) ? $cronk['name'] : null, 'categories' => isset($cronk['categories']) ? $cronk['categories'] : null, 'image' => isset($cronk['image']) ? $cronk['image'] : self::DEFAULT_CRONK_IMAGE, 'disabled' => isset($cronk['disabled']) ? (bool) $cronk['disabled'] : false, 'groupsonly' => isset($cronk['groupsonly']) ? $cronk['groupsonly'] : null, 'state' => isset($cronk['state']) ? $cronk['state'] : null, 'ae:parameter' => isset($cronk['ae:parameter']) ? $cronk['ae:parameter'] : null, 'system' => true, 'owner' => false, 'position' => isset($cronk['position']) ? $cronk['position'] : 0, 'owner_name' => self::DEFAULT_CRONK_OWNER, 'owner_id' => self::DEFAULT_CRONK_OWNERID);
}
// write data to the cache, with a timestamp
$this->user->getStorage()->write("icinga.cronks.cache.xml", array("timestamp" => time(), "data" => $out));
return $out;
}
/**
* Load RBAC role and permission definitions.
*
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
protected function loadDefinitions()
{
$cfg = $this->getParameter('definitions_file', AgaviConfig::get('core.config_dir') . '/rbac_definitions.xml');
if (is_readable($cfg)) {
$this->definitions = (include AgaviConfigCache::checkConfig($cfg, $this->context->getName()));
}
}
public function removeRestrictedCommands()
{
$data = $this->data;
if (!isset($data["option"])) {
return;
}
if (!isset($data["option"]["commands"])) {
return;
}
if (!isset($data["option"]["commands"]["items"])) {
return;
}
$items = $data["option"]["commands"]["items"];
if (!is_array($items)) {
return;
}
$config = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.module_dir%/Api/config/icingaCommands.xml')));
$toRemove = array();
foreach ($items as $cmd_name => $cmd_def) {
if (!isset($config[$cmd_name])) {
$toRemove[] = $cmd_name;
continue;
}
if (!$config[$cmd_name]["isSimple"]) {
$toRemove[] = $cmd_name;
}
}
foreach ($toRemove as $removeItem) {
unset($data["option"]["commands"]["items"][$removeItem]);
}
$this->data = $data;
}
private function initializeAutosettings()
{
// Try to set the web path to correct urls within the frontend
if (AgaviConfig::get('core.default_context') == 'web') {
// Try to set the web path to correct urls within the frontend
if (AgaviConfig::get('org.icinga.appkit.web_path', null) == null) {
AgaviConfig::set('org.icinga.appkit.web_path', AppKitStringUtil::extractWebPath(), true, true);
}
}
include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.config_dir%/schedules.xml'));
// Global temp directory
AgaviConfig::set('core.tmp_dir', AgaviConfig::get('core.data_dir') . '/tmp');
}
/**
* Load the config handlers from the given config file.
* Existing handlers will not be overwritten.
*
* @param string The path to a config_handlers.xml file.
*
* @author Felix Gilcher <*****@*****.**>
* @since 1.0.0
*/
protected static function loadConfigHandlersFile($cfg)
{
self::$handlers = (array) self::$handlers + (include AgaviConfigCache::checkConfig($cfg));
}
protected function loadFixtureConfig()
{
return include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . DIRECTORY_SEPARATOR . FixtureServiceProvisioner::FIXTURE_CONFIG_NAME);
}
public function readJsonFromConfig()
{
$config = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.config_dir%/menu.xml')));
$menu = $this->getAllowedMenuPoints($config);
return $menu;
}
protected function loadMigrationConfig()
{
return include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . DIRECTORY_SEPARATOR . MigrationServiceProvisioner::MIGRATION_CONFIG_NAME);
}
/**
* Load the routing.xml configuration file.
*
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
protected function loadConfig()
{
$cfg = AgaviConfig::get('core.config_dir') . '/routing.xml';
// allow missing routing.xml when routing is not enabled
if ($this->isEnabled() || is_readable($cfg)) {
$this->importRoutes(unserialize(file_get_contents(AgaviConfigCache::checkConfig($cfg, $this->context->getName()))));
}
}
/**
* Returns a new AgaviLocale object from the given identifier.
*
* @param string The locale identifier
* @param bool Force a new instance even if an identical one exists.
*
* @return AgaviLocale The locale instance which matches the available
* locales most.
*
* @author Dominik del Bondio <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
public function getLocale($identifier, $forceNew = false)
{
// enable shortcut notation to only set options to the current locale
if ($identifier[0] == '@' && $this->currentLocaleIdentifier) {
$idData = AgaviLocale::parseLocaleIdentifier($this->currentLocaleIdentifier);
$identifier = $idData['locale_str'] . $identifier;
$newIdData = AgaviLocale::parseLocaleIdentifier($identifier);
$idData['options'] = array_merge($idData['options'], $newIdData['options']);
} else {
$idData = AgaviLocale::parseLocaleIdentifier($identifier);
}
// this doesn't care about the options
$availableLocale = $this->availableLocales[$this->getLocaleIdentifier($identifier)];
// if the user wants all options reset he supplies an 'empty' option set (identifier ends with @)
if (substr($identifier, -1) == '@') {
$idData['options'] = array();
} else {
$idData['options'] = array_merge($availableLocale['identifierData']['options'], $idData['options']);
}
if (($atPos = strpos($identifier, '@')) !== false) {
$identifier = $availableLocale['identifierData']['locale_str'] . substr($identifier, $atPos);
} else {
$identifier = $availableLocale['identifier'];
}
if (!$forceNew && isset($this->localeCache[$identifier])) {
return $this->localeCache[$identifier];
}
if (!isset($this->localeDataCache[$idData['locale_str']])) {
$lookupPath = AgaviLocale::getLookupPath($availableLocale['identifierData']);
$cldrDir = AgaviConfig::get('core.cldr_dir');
$data = null;
foreach ($lookupPath as $localeName) {
$fileName = $cldrDir . '/locales/' . $localeName . '.xml';
if (is_readable($fileName)) {
$data = (include AgaviConfigCache::checkConfig($fileName));
break;
}
}
if ($data === null) {
throw new AgaviException('No data available for locale ' . $identifier);
}
if ($availableLocale['identifierData']['territory']) {
$territory = $availableLocale['identifierData']['territory'];
if (isset($this->supplementalData['territories'][$territory]['currencies'])) {
$slice = array_slice($this->supplementalData['territories'][$territory]['currencies'], 0, 1);
$currency = current($slice);
$data['locale']['currency'] = $currency['currency'];
}
}
$this->localeDataCache[$idData['locale_str']] = $data;
}
$data = $this->localeDataCache[$idData['locale_str']];
if (isset($idData['options']['calendar'])) {
$data['locale']['calendar'] = $idData['options']['calendar'];
}
if (isset($idData['options']['currency'])) {
$data['locale']['currency'] = $idData['options']['currency'];
}
if (isset($idData['options']['timezone'])) {
$data['locale']['timezone'] = $idData['options']['timezone'];
}
$locale = new AgaviLocale();
$locale->initialize($this->context, $availableLocale['parameters'], $identifier, $data);
if (!$forceNew) {
$this->localeCache[$identifier] = $locale;
}
return $locale;
}
/**
* register the validators for this container
*
* @author David Zülke <*****@*****.**>
* @author Felix Gilcher <*****@*****.**>
* @since 1.0.0
*/
public function registerValidators()
{
$validationManager = $this->getValidationManager();
// get the current action instance
$actionInstance = $this->getActionInstance();
// get the current action information
$moduleName = $this->getModuleName();
$actionName = $this->getActionName();
// get the (already formatted) request method
$method = $this->getRequestMethod();
// get the current action validation configuration
$validationConfig = AgaviToolkit::evaluateModuleDirective($moduleName, 'agavi.validate.path', array('moduleName' => $moduleName, 'actionName' => $actionName));
if (is_readable($validationConfig)) {
// load validation configuration
// do NOT use require_once
require AgaviConfigCache::checkConfig($validationConfig, $this->context->getName());
}
// manually load validators
$registerValidatorsMethod = 'register' . $method . 'Validators';
if (!is_callable(array($actionInstance, $registerValidatorsMethod))) {
$registerValidatorsMethod = 'registerValidators';
}
$actionInstance->{$registerValidatorsMethod}();
}
/**
* Execute this filter.
*
* @param AgaviFilterChain The filter chain.
* @param AgaviExecutionContainer The current execution container.
*
* @throws <b>AgaviInitializationException</b> If an error occurs during
* View initialization.
* @throws <b>AgaviViewException</b> If an error occurs while
* executing the View.
*
* @author David Zülke <*****@*****.**>
* @author Felix Gilcher <*****@*****.**>
* @author Sean Kerr <*****@*****.**>
* @since 0.9.0
*/
public function execute(AgaviFilterChain $filterChain, AgaviExecutionContainer $container)
{
// $lm = $this->context->getLoggerManager();
// get the context, controller and validator manager
$controller = $this->context->getController();
// get the current action information
$actionName = $container->getActionName();
$moduleName = $container->getModuleName();
// the action instance
$actionInstance = $container->getActionInstance();
$request = $this->context->getRequest();
$isCacheable = false;
$cachingDotXml = AgaviToolkit::evaluateModuleDirective($moduleName, 'agavi.cache.path', array('moduleName' => $moduleName, 'actionName' => $actionName));
if ($this->getParameter('enable_caching', true) && is_readable($cachingDotXml)) {
// $lm->log('Caching enabled, configuration file found, loading...');
// no _once please!
include AgaviConfigCache::checkConfig($cachingDotXml, $this->context->getName());
}
$isActionCached = false;
if ($isCacheable) {
try {
$groups = $this->determineGroups($config['groups'], $container);
$actionGroups = array_merge($groups, array(self::ACTION_CACHE_ID));
} catch (AgaviUncacheableException $e) {
// a group callback threw an exception. that means we're not allowed t cache
$isCacheable = false;
}
if ($isCacheable) {
// this is not wrapped in the try/catch block above as it might throw an exception itself
$isActionCached = $this->checkCache(array_merge($groups, array(self::ACTION_CACHE_ID)), $config['lifetime']);
if (!$isActionCached) {
// cacheable, but action is not cached. notify our callback so it can prevent the stampede that follows
$this->startedCacheCreationCallback(self::CACHE_CALLBACK_ACTION_NOT_CACHED, $actionGroups, $config, $container);
}
}
} else {
// $lm->log('Action is not cacheable!');
}
if ($isActionCached) {
// $lm->log('Action is cached, loading...');
// cache/dir/4-8-15-16-23-42 contains the action cache
try {
$actionCache = $this->readCache($actionGroups);
// and restore action attributes
$actionInstance->setAttributes($actionCache['action_attributes']);
} catch (AgaviException $e) {
// cacheable, but action is not cached. notify our callback so it can prevent the stampede that follows
$this->startedCacheCreationCallback(self::CACHE_CALLBACK_ACTION_CACHE_GONE, $actionGroups, $config, $container);
$isActionCached = false;
}
}
$isViewCached = false;
$rememberTheView = null;
while (true) {
if (!$isActionCached) {
$actionCache = array();
// $lm->log('Action not cached, executing...');
// execute the Action and get the View to execute
list($actionCache['view_module'], $actionCache['view_name']) = $container->runAction();
// check if we've just run the action again after a previous cache read revealed that the view is not cached for this output type and we need to go back to square one due to the lack of action attribute caching configuration...
// if yes: is the view module/name that we got just now different from what was in the cache?
if (isset($rememberTheView) && $actionCache != $rememberTheView) {
// yup. clear it!
$ourClass = get_class($this);
call_user_func(array($ourClass, 'clearCache'), $groups);
}
// check if the returned view is cacheable
if ($isCacheable && is_array($config['views']) && !in_array(array('module' => $actionCache['view_module'], 'name' => $actionCache['view_name']), $config['views'], true)) {
$isCacheable = false;
$this->abortedCacheCreationCallback(self::CACHE_CALLBACK_VIEW_NOT_CACHEABLE, $actionGroups, $config, $container);
// so that view is not cacheable? okay then:
// check if we've just run the action again after a previous cache read revealed that the view is not cached for this output type and we need to go back to square one due to the lack of action attribute caching configuration...
// 'cause then we need to flush all those existing caches - obviously, that data is stale now, as we learned, since we are not allowed to cache anymore for the view that was returned now
if (isset($rememberTheView)) {
// yup. clear it!
$ourClass = get_class($this);
call_user_func(array($ourClass, 'clearCache'), $groups);
}
// $lm->log('Returned View is not cleared for caching, setting cacheable status to false.');
} else {
// $lm->log('Returned View is cleared for caching, proceeding...');
}
$actionAttributes = $actionInstance->getAttributes();
}
// clear the response
$response = $container->getResponse();
$response->clear();
// clear any forward set, it's ze view's job
$container->clearNext();
if ($actionCache['view_name'] !== AgaviView::NONE) {
$container->setViewModuleName($actionCache['view_module']);
$container->setViewName($actionCache['view_name']);
$key = $request->toggleLock();
try {
// get the view instance
$viewInstance = $controller->createViewInstance($actionCache['view_module'], $actionCache['view_name']);
// initialize the view
$viewInstance->initialize($container);
} catch (Exception $e) {
// we caught an exception... unlock the request and rethrow!
$request->toggleLock($key);
throw $e;
}
$request->toggleLock($key);
// Set the View Instance in the container
$container->setViewInstance($viewInstance);
$outputType = $container->getOutputType()->getName();
if ($isCacheable) {
if (isset($config['output_types'][$otConfig = $outputType]) || isset($config['output_types'][$otConfig = '*'])) {
$otConfig = $config['output_types'][$otConfig];
$viewGroups = array_merge($groups, array($outputType));
if ($isActionCached) {
$isViewCached = $this->checkCache($viewGroups, $config['lifetime']);
if (!$isViewCached) {
// cacheable, but view is not cached. notify our callback so it can prevent the stampede that follows
$this->startedCacheCreationCallback(self::CACHE_CALLBACK_VIEW_NOT_CACHED, $viewGroups, $config, $container);
}
}
} else {
$this->abortedCacheCreationCallback(self::CACHE_CALLBACK_OUTPUT_TYPE_NOT_CACHEABLE, $actionGroups, $config, $container);
$isCacheable = false;
}
}
if ($isViewCached) {
// $lm->log('View is cached, loading...');
try {
$viewCache = $this->readCache($viewGroups);
} catch (AgaviException $e) {
$this->startedCacheCreationCallback(self::CACHE_CALLBACK_VIEW_CACHE_GONE, $viewGroups, $config, $container);
$isViewCached = false;
}
}
if (!$isViewCached) {
// view not cached
// has the cache config a list of action attributes?
if ($isActionCached && !$config['action_attributes']) {
// no. that means we must run the action again!
$isActionCached = false;
if ($isCacheable) {
// notify our callback so it can remove the lock that's on the view
// but only if we're still marked as cacheable (if not, then that means the OT is not cacheable, so there wouldn't be a $viewGroups)
$this->abortedCacheCreationCallback(self::CACHE_CALLBACK_ACTION_CACHE_USELESS, $viewGroups, $config, $container);
}
// notify our callback so it can prevent the stampede that follows
$this->startedCacheCreationCallback(self::CACHE_CALLBACK_ACTION_CACHE_USELESS, $actionGroups, $config, $container);
// but remember the view info, just in case it differs if we run the action again now
$rememberTheView = array('view_module' => $actionCache['view_module'], 'view_name' => $actionCache['view_name']);
continue;
}
$viewCache = array();
$viewCache['next'] = $this->executeView($container);
}
if ($viewCache['next'] instanceof AgaviExecutionContainer) {
// $lm->log('Forwarding request, skipping rendering...');
$container->setNext($viewCache['next']);
} else {
$output = array();
$nextOutput = null;
if ($isViewCached) {
$layers = $viewCache['layers'];
$response = $viewCache['response'];
$container->setResponse($response);
foreach ($viewCache['template_variables'] as $name => $value) {
$viewInstance->setAttribute($name, $value);
}
foreach ($viewCache['request_attributes'] as $requestAttribute) {
$request->setAttribute($requestAttribute['name'], $requestAttribute['value'], $requestAttribute['namespace']);
}
foreach ($viewCache['request_attribute_namespaces'] as $ranName => $ranValues) {
$request->setAttributes($ranValues, $ranName);
}
$nextOutput = $response->getContent();
} else {
if ($viewCache['next'] !== null) {
// response content was returned from view execute()
$response->setContent($nextOutput = $viewCache['next']);
$viewCache['next'] = null;
}
$layers = $viewInstance->getLayers();
if ($isCacheable) {
$viewCache['template_variables'] = array();
foreach ($otConfig['template_variables'] as $varName) {
$viewCache['template_variables'][$varName] = $viewInstance->getAttribute($varName);
}
$viewCache['response'] = clone $response;
$viewCache['layers'] = array();
$viewCache['slots'] = array();
$lastCacheableLayer = -1;
if (is_array($otConfig['layers'])) {
if (count($otConfig['layers'])) {
for ($i = count($layers) - 1; $i >= 0; $i--) {
$layer = $layers[$i];
$layerName = $layer->getName();
if (isset($otConfig['layers'][$layerName])) {
if (is_array($otConfig['layers'][$layerName])) {
$lastCacheableLayer = $i - 1;
} else {
$lastCacheableLayer = $i;
}
}
}
}
} else {
$lastCacheableLayer = count($layers) - 1;
}
for ($i = $lastCacheableLayer + 1; $i < count($layers); $i++) {
// $lm->log('Adding non-cacheable layer "' . $layers[$i]->getName() . '" to list');
$viewCache['layers'][] = clone $layers[$i];
}
}
}
$attributes =& $viewInstance->getAttributes();
// whether or not we should assign the previous' layer's output to the $slots array
$assignInnerToSlots = $this->getParameter('assign_inner_to_slots', false);
// $lm->log('Starting rendering...');
for ($i = 0; $i < count($layers); $i++) {
$layer = $layers[$i];
$layerName = $layer->getName();
// $lm->log('Running layer "' . $layerName . '"...');
foreach ($layer->getSlots() as $slotName => $slotContainer) {
if ($isViewCached && isset($viewCache['slots'][$layerName][$slotName])) {
// $lm->log('Loading cached slot "' . $slotName . '"...');
$slotResponse = $viewCache['slots'][$layerName][$slotName];
} else {
// $lm->log('Running slot "' . $slotName . '"...');
$slotResponse = $slotContainer->execute();
if ($isCacheable && !$isViewCached && isset($otConfig['layers'][$layerName]) && is_array($otConfig['layers'][$layerName]) && in_array($slotName, $otConfig['layers'][$layerName])) {
// $lm->log('Adding response of slot "' . $slotName . '" to cache...');
$viewCache['slots'][$layerName][$slotName] = $slotResponse;
}
}
// set the presentation data as a template attribute
$output[$slotName] = $slotResponse->getContent();
// and merge the other slot's response (this used to be conditional and done only when the content was not null)
// $lm->log('Merging in response from slot "' . $slotName . '"...');
$response->merge($slotResponse);
}
$moreAssigns = array('container' => $container, 'inner' => $nextOutput, 'request_data' => $container->getRequestData(), 'validation_manager' => $container->getValidationManager(), 'view' => $viewInstance);
// lock the request. can't be done outside the loop for the whole run, see #628
$key = $request->toggleLock();
try {
$nextOutput = $layer->getRenderer()->render($layer, $attributes, $output, $moreAssigns);
} catch (Exception $e) {
// we caught an exception... unlock the request and rethrow!
$request->toggleLock($key);
throw $e;
}
// and unlock the request again
$request->toggleLock($key);
$response->setContent($nextOutput);
if ($isCacheable && !$isViewCached && $i === $lastCacheableLayer) {
$viewCache['response'] = clone $response;
}
$output = array();
if ($assignInnerToSlots) {
$output[$layer->getName()] = $nextOutput;
}
}
}
if ($isCacheable && !$isViewCached) {
// we're writing the view cache first. this is just in case we get into a situation with really bad timing on the leap of a second
$viewCache['request_attributes'] = array();
foreach ($otConfig['request_attributes'] as $requestAttribute) {
$viewCache['request_attributes'][] = $requestAttribute + array('value' => $request->getAttribute($requestAttribute['name'], $requestAttribute['namespace']));
}
$viewCache['request_attribute_namespaces'] = array();
foreach ($otConfig['request_attribute_namespaces'] as $requestAttributeNamespace) {
$viewCache['request_attribute_namespaces'][$requestAttributeNamespace] = $request->getAttributes($requestAttributeNamespace);
}
$this->writeCache($viewGroups, $viewCache, $config['lifetime']);
// notify callback that the execution has finished and caches have been written
$this->finishedCacheCreationCallback(self::CACHE_CALLBACK_VIEW_CACHE_WRITTEN, $viewGroups, $config, $container);
// $lm->log('Writing View cache...');
}
}
// action cache writing must occur here, so actions that return AgaviView::NONE also get their cache written
if ($isCacheable && !$isActionCached) {
$actionCache['action_attributes'] = array();
foreach ($config['action_attributes'] as $attributeName) {
$actionCache['action_attributes'][$attributeName] = $actionAttributes[$attributeName];
}
// $lm->log('Writing Action cache...');
$this->writeCache($actionGroups, $actionCache, $config['lifetime']);
// notify callback that the execution has finished and caches have been written
$this->finishedCacheCreationCallback(self::CACHE_CALLBACK_ACTION_CACHE_WRITTEN, $actionGroups, $config, $container);
}
// we're done here. bai.
break;
}
}
/**
* Initialize this DatabaseManager.
*
* @param AgaviContext An AgaviContext instance.
* @param array An array of initialization parameters.
*
* @throws <b>AgaviInitializationException</b> If an error occurs while
* initializing this
* DatabaseManager.
*
* @author David Zülke <*****@*****.**>
* @author Sean Kerr <*****@*****.**>
* @since 0.9.0
*/
public function initialize(AgaviContext $context, array $parameters = array())
{
$this->context = $context;
// load database configuration
require AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/databases.xml');
}
public function testTicket941()
{
if (!extension_loaded('xdebug')) {
$this->markTestSkipped('This test check for an infinite loop, you need xdebug as protection.');
}
$config = AgaviConfig::get('core.module_dir') . '/Default/config/config_handlers.xml';
AgaviTestingConfigCache::addConfigHandlersFile($config);
AgaviConfigCache::checkConfig(AgaviConfig::get('core.module_dir') . '/Default/config/autoload.xml');
}
/**
* (re)Initialize the AgaviContext instance.
*
* @author Dominik del Bondio <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @author Mike Vincent <*****@*****.**>
* @since 0.10.0
*/
public function initialize()
{
try {
include AgaviConfigCache::checkConfig(AgaviConfig::get('core.config_dir') . '/factories.xml', $this->name);
} catch (Exception $e) {
AgaviException::render($e, $this);
}
register_shutdown_function(array($this, 'shutdown'));
}
