/**
* 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']));
}
}
}
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"]);
}
protected function parseRoutesAndFiles(AgaviRouting $routing, $routes, &$data)
{
$controller = $this->context->getController();
$request = $this->context->getRequest();
foreach ($routes as $route) {
$outputTypes = array();
$routeName = $route->getAttribute('name');
if ($routeName !== '*' && is_null($routing->getRoute($routeName))) {
throw new AgaviConfigurationException('Route name "' . $routeName . '" does not exist or is not correct.');
}
if ($route->hasAttribute('output_type')) {
foreach (explode(' ', $route->getAttribute('output_type')) as $ot) {
if ($controller->getOutputType($ot)) {
$outputTypes[] = $ot;
}
}
} else {
$outputTypes[] = $controller->getOutputType()->getName();
// Defaults to HTML
}
foreach ($route->get('filelist') as $filelist) {
$metatype = $filelist->getAttribute('metatype');
foreach ($filelist->getElementsByTagName('file') as $file) {
foreach ($outputTypes as $ot) {
if ($file->hasAttribute('name')) {
$data[$routeName][$ot][$metatype][$file->getAttribute('name')] = AgaviToolkit::expandDirectives($file->getValue());
} else {
$data[$routeName][$ot][$metatype][] = AgaviToolkit::expandDirectives($file->getValue());
}
}
}
}
}
}
/**
* Execute this configuration handler.
*
* @param AgaviXmlConfigDomDocument The document to parse.
*
* @return string Data to be written to a cache file.
*
* @throws <b>AgaviParseException</b> If a requested configuration file is
* improperly formatted.
*
* @author Sean Kerr <*****@*****.**>
* @author Dominik del Bondio <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 0.9.0
*/
public function execute(AgaviXmlConfigDomDocument $document)
{
// set up our default namespace
$document->setDefaultNamespace(self::XML_NAMESPACE, 'compile');
$config = $document->documentURI;
$data = array();
// let's do our fancy work
foreach ($document->getConfigurationElements() as $configuration) {
if (!$configuration->has('compiles')) {
continue;
}
foreach ($configuration->get('compiles') as $compileFile) {
$file = trim($compileFile->getValue());
$file = AgaviToolkit::expandDirectives($file);
$file = self::replacePath($file);
$file = realpath($file);
if (!is_readable($file)) {
// file doesn't exist
$error = 'Configuration file "%s" specifies nonexistent ' . 'or unreadable file "%s"';
$error = sprintf($error, $config, $compileFile->getValue());
throw new AgaviParseException($error);
}
if (AgaviConfig::get('core.debug', false)) {
// debug mode, just require() the files, makes for nicer stack traces
$contents = 'require(' . var_export($file, true) . ');';
} else {
// no debug mode, so make things fast
$contents = $this->formatFile(file_get_contents($file));
}
// append file data
$data[$file] = $contents;
}
}
return $this->generate($data, $config);
}
public function testExpandDirectives()
{
AgaviConfig::set('whatever', 'something');
$value = "whatever %directive% asdasdasd %whatever% ";
$result = "whatever %directive% asdasdasd something ";
$this->assertEquals($result, AgaviToolkit::expandDirectives($value));
}
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();
}
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;
}
/**
* Load Propel config
*
* @param AgaviDatabaseManager The database manager of this instance.
* @param array An assoc array of initialization params.
*
* @author David Zülke <*****@*****.**>
* @since 0.10.0
*/
public function initialize(AgaviDatabaseManager $databaseManager, array $parameters = array())
{
parent::initialize($databaseManager, $parameters);
$configPath = AgaviToolkit::expandDirectives($this->getParameter('config'));
$datasource = $this->getParameter('datasource', null);
$use_as_default = $this->getParameter('use_as_default', false);
$config = (require $configPath);
if ($datasource === null || $datasource == 'default') {
if (isset($config['propel']['datasources']['default'])) {
$datasource = $config['propel']['datasources']['default'];
} elseif (isset($config['datasources']['default'])) {
$datasource = $config['datasources']['default'];
} else {
throw new AgaviDatabaseException('No datasource given for Propel connection, and no default datasource specified in runtime configuration file.');
}
}
if (!class_exists('Propel')) {
include 'propel/Propel.php';
}
if (!Propel::isInit()) {
Propel::init($configPath);
}
$is13 = version_compare(Propel::VERSION, '1.4', '<');
// grab the configuration values and inject possibly defined overrides for this data source
if ($is13) {
// old-style config array; PropelConfiguration was added after 1.3.0, http://trac.agavi.org/ticket/1195
$config = Propel::getConfiguration();
$config['datasources'][$datasource]['adapter'] = $this->getParameter('overrides[adapter]', $config['datasources'][$datasource]['adapter']);
$config['datasources'][$datasource]['connection'] = array_merge($config['datasources'][$datasource]['connection'], $this->getParameter('overrides[connection]', array()));
// also the autoload classes
$config['datasources'][$datasource]['classes'] = array_merge($config['datasources'][$datasource]['classes'], $this->getParameter('overrides[classes]', array()));
// and init queries
if (!isset($config['datasources'][$datasource]['connection']['settings']['queries']['query'])) {
$config['datasources'][$datasource]['connection']['settings']['queries']['query'] = array();
}
// array cast because "query" might be a string if just one init query was given, http://trac.agavi.org/ticket/1194
$config['datasources'][$datasource]['connection']['settings']['queries']['query'] = array_merge((array) $config['datasources'][$datasource]['connection']['settings']['queries']['query'], (array) $this->getParameter('init_queries'));
// set the new config
Propel::setConfiguration($config);
} else {
$config = Propel::getConfiguration(PropelConfiguration::TYPE_OBJECT);
$overrides = (array) $this->getParameter('overrides');
// set override values
foreach ($overrides as $key => $value) {
$config->setParameter($key, $value);
}
// handle init queries in a cross-adapter fashion (they all support the "init_queries" param)
$queries = (array) $config->getParameter('datasources.' . $datasource . '.connection.settings.queries.query', array());
// yes... it's one array, [connection][settings][queries][query], with all the init queries from the config, so we append to that
$queries = array_merge($queries, (array) $this->getParameter('init_queries'));
$config->setParameter('datasources.' . $datasource . '.connection.settings.queries.query', $queries);
}
if (true === $this->getParameter('enable_instance_pooling')) {
Propel::enableInstancePooling();
} elseif (false === $this->getParameter('enable_instance_pooling')) {
Propel::disableInstancePooling();
}
}
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);
}
}
/**
* Execute this configuration handler.
*
* @param AgaviXmlConfigDomDocument The document to handle.
*
* @return string Data to be written to a cache file.
*
* @throws <b>AgaviUnreadableException</b> If a requested configuration
* file does not exist or is not
* readable.
* @throws <b>AgaviParseException</b> If a requested configuration file is
* improperly formatted.
*
* @author Dominik del Bondio <*****@*****.**>
* @author Noah Fontes <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
public function execute(AgaviXmlConfigDomDocument $document)
{
// set up our default namespace
$document->setDefaultNamespace(self::XML_NAMESPACE, 'config_handlers');
// init our data arrays
$handlers = array();
foreach ($document->getConfigurationElements() as $configuration) {
if (!$configuration->has('handlers')) {
continue;
}
// let's do our fancy work
foreach ($configuration->get('handlers') as $handler) {
$pattern = $handler->getAttribute('pattern');
$category = AgaviToolkit::normalizePath(AgaviToolkit::expandDirectives($pattern));
$class = $handler->getAttribute('class');
$transformations = array(AgaviXmlConfigParser::STAGE_SINGLE => array(), AgaviXmlConfigParser::STAGE_COMPILATION => array());
if ($handler->has('transformations')) {
foreach ($handler->get('transformations') as $transformation) {
$path = AgaviToolkit::literalize($transformation->getValue());
$for = $transformation->getAttribute('for', AgaviXmlConfigParser::STAGE_SINGLE);
$transformations[$for][] = $path;
}
}
$validations = array(AgaviXmlConfigParser::STAGE_SINGLE => array(AgaviXmlConfigParser::STEP_TRANSFORMATIONS_BEFORE => array(AgaviXmlConfigParser::VALIDATION_TYPE_RELAXNG => array(), AgaviXmlConfigParser::VALIDATION_TYPE_SCHEMATRON => array(), AgaviXmlConfigParser::VALIDATION_TYPE_XMLSCHEMA => array()), AgaviXmlConfigParser::STEP_TRANSFORMATIONS_AFTER => array(AgaviXmlConfigParser::VALIDATION_TYPE_RELAXNG => array(), AgaviXmlConfigParser::VALIDATION_TYPE_SCHEMATRON => array(), AgaviXmlConfigParser::VALIDATION_TYPE_XMLSCHEMA => array())), AgaviXmlConfigParser::STAGE_COMPILATION => array(AgaviXmlConfigParser::STEP_TRANSFORMATIONS_BEFORE => array(AgaviXmlConfigParser::VALIDATION_TYPE_RELAXNG => array(), AgaviXmlConfigParser::VALIDATION_TYPE_SCHEMATRON => array(), AgaviXmlConfigParser::VALIDATION_TYPE_XMLSCHEMA => array()), AgaviXmlConfigParser::STEP_TRANSFORMATIONS_AFTER => array(AgaviXmlConfigParser::VALIDATION_TYPE_RELAXNG => array(), AgaviXmlConfigParser::VALIDATION_TYPE_SCHEMATRON => array(), AgaviXmlConfigParser::VALIDATION_TYPE_XMLSCHEMA => array())));
if ($handler->has('validations')) {
foreach ($handler->get('validations') as $validation) {
$path = AgaviToolkit::literalize($validation->getValue());
$type = null;
if (!$validation->hasAttribute('type')) {
$type = $this->guessValidationType($path);
} else {
$type = $validation->getAttribute('type');
}
$for = $validation->getAttribute('for', AgaviXmlConfigParser::STAGE_SINGLE);
$step = $validation->getAttribute('step', AgaviXmlConfigParser::STEP_TRANSFORMATIONS_AFTER);
$validations[$for][$step][$type][] = $path;
}
}
$handlers[$category] = isset($handlers[$category]) ? $handlers[$category] : array('parameters' => array());
$handlers[$category] = array('class' => $class, 'parameters' => $handler->getAgaviParameters($handlers[$category]['parameters']), 'transformations' => $transformations, 'validations' => $validations);
}
}
$data = array('return ' . var_export($handlers, true));
return $this->generate($data, $document->documentURI);
}
/**
* Execute this configuration handler.
*
* @param AgaviXmlConfigDomDocument The document to parse.
*
* @return string Data to be written to a cache file.
*
* @throws <b>AgaviParseException</b> If a requested configuration file is
* improperly formatted.
*
* @author Sean Kerr <*****@*****.**>
* @author Dominik del Bondio <*****@*****.**>
* @author Noah Fontes <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 0.9.0
*/
public function execute(AgaviXmlConfigDomDocument $document)
{
// set up our default namespace
$document->setDefaultNamespace(self::XML_NAMESPACE, 'autoload');
$classes = $namespaces = array();
foreach ($document->getConfigurationElements() as $configuration) {
if (!$configuration->has('autoloads')) {
continue;
}
// let's do our fancy work
foreach ($configuration->get('autoloads') as $autoload) {
// we can have variables in the filename
$path = AgaviToolkit::expandDirectives($autoload->getValue());
// sanity check; XML Schema can't do <xs:choice> on attributes...
if (($isClass = $autoload->hasAttribute('class')) && $autoload->hasAttribute('namespace')) {
$error = sprintf('Configuration file "%s" specifies both "class" and "namespace" attribute for path "%s"', $document->documentURI, $path);
throw new AgaviParseException($error);
}
// prepend the app dir if the path is not absolute
$file = self::replacePath($path);
// check if absolute path is readable or try to resolve it against the include path
if (!file_exists($file) && ($path == $file || !($file = stream_resolve_include_path($path)))) {
// the class path doesn't exist and couldn't be resolved against the include path either
$error = sprintf('Configuration file "%s" specifies %s "%s" with non-existent path "%s"', $document->documentURI, $isClass ? 'file' : 'namespace', $isClass ? $autoload->getAttribute('class') : $autoload->getAttribute('namespace'), $path);
throw new AgaviParseException($error);
}
if ($isClass) {
// it's a class
$classes[$autoload->getAttribute('class')] = $file;
} else {
// it's a whole namespace
// trim backslashes from the namespace and trailing slashes or backslashes from the path
$namespaces[trim($autoload->getAttribute('namespace'), '\\')] = rtrim($file, '/\\');
}
}
}
$code = array('AgaviAutoloader::addClasses(' . var_export($classes, true) . ');', 'AgaviAutoloader::addNamespaces(' . var_export($namespaces, true) . ');');
return $this->generate($code, $document->documentURI);
}
/**
* Execute this configuration handler.
*
* @param AgaviXmlConfigDomDocument The document to parse.
*
* @return string Data to be written to a cache file.
*
* @throws <b>AgaviParseException</b> If a requested configuration file is
* improperly formatted.
*
* @author Sean Kerr <*****@*****.**>
* @author Dominik del Bondio <*****@*****.**>
* @author Noah Fontes <*****@*****.**>
* @since 0.9.0
*/
public function execute(AgaviXmlConfigDomDocument $document)
{
// set up our default namespace
$document->setDefaultNamespace(self::XML_NAMESPACE, 'autoload');
$data = array();
foreach ($document->getConfigurationElements() as $configuration) {
if (!$configuration->has('autoloads')) {
continue;
}
// let's do our fancy work
foreach ($configuration->get('autoloads') as $autoload) {
// we can have variables in the filename
$file = AgaviToolkit::expandDirectives($autoload->getValue());
// we need the filename w/o app dir prepended since the file could
// be placed in the include path
$originalFile = $file;
// if the filename is not absolute we assume its relative to the app dir
$file = self::replacePath($file);
$class = $autoload->getAttribute('name');
if (!($fp = @fopen($file, 'r', true))) {
if ($originalFile != $file && ($fpOriginal = @fopen($originalFile, 'r', true))) {
$file = $originalFile;
$fp = $fpOriginal;
} else {
// the class path doesn't exist
$error = 'Configuration file "%s" specifies class "%s" with ' . 'nonexistent or unreadable file "%s"';
$error = sprintf($error, $document->documentURI, $class, $file);
throw new AgaviParseException($error);
}
}
fclose($fp);
$data[$class] = $file;
}
}
$code = array('return ' . var_export($data, true) . ';');
return $this->generate($code, $document->documentURI);
}
/**
* Returns the literal value. By default, that means whitespace is trimmed,
* boolean literals ("on", "yes", "true", "no", "off", "false") are converted
* and configuration directives ("%core.app_dir%") are expanded.
*
* Takes attributes {http://www.w3.org/XML/1998/namespace}space and
* {http://agavi.org/agavi/config/global/envelope/1.1}literalize into account
* when computing the literal value. This way, users can control the trimming
* and the literalization of values.
*
* AEP-100 has a list of all the conversion rules that apply.
*
* @return mixed The element content converted according to the rules
* defined in AEP-100.
*
* @author David Zülke <*****@*****.**>
* @since 1.1.0
*/
public function getLiteralValue()
{
$value = $this->getValue();
// XML specifies [\x9\xA\xD\x20] as whitespace
// trim strips more than that
// no problem though, because these other chars aren't legal in XML
$trimmedValue = trim($value);
$preserveWhitespace = $this->getAttributeNS(AgaviXmlConfigParser::NAMESPACE_XML_1998, 'space') == 'preserve';
$literalize = AgaviToolkit::literalize($this->getAttributeNS(AgaviXmlConfigParser::NAMESPACE_AGAVI_ENVELOPE_LATEST, 'literalize')) !== false;
if ($literalize) {
if ($preserveWhitespace && ($trimmedValue === '' || $value != $trimmedValue)) {
// we must preserve whitespace, and there is leading or trailing whitespace in the original value, so we won't run AgaviToolkit::literalize(), which trims the input and then converts "true" to a boolean and so forth
// however, we should still expand possible occurrences of config directives
$value = AgaviToolkit::expandDirectives($value);
} else {
// no need to preserve whitespace, or no leading/trailing whitespace, which means we can expand "true", "false" and so forth using AgaviToolkit::literalize()
$value = AgaviToolkit::literalize($trimmedValue);
}
} elseif (!$preserveWhitespace) {
$value = $trimmedValue;
if ($value === '') {
// with or without literalize, an empty string must be converted to NULL if xml:space is default (see ticket #1203 and AEP-100)
$value = null;
}
}
return $value;
}
/**
* Replace configuration directive identifiers in a string.
*
* @param string The value on which to run the replacement procedure.
*
* @return string The new value.
*
* @author Sean Kerr <*****@*****.**>
* @author Johan Mjones <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 0.9.0
*
* @deprecated Use AgaviToolkit::expandDirectives() instead.
*/
public static function replaceConstants($value)
{
return AgaviToolkit::expandDirectives($value);
}
/**
* Validate a given document according to XMLSchema-instance (xsi)
* declarations.
*
* @param AgaviXmlConfigDomDocument The document to act upon.
*
* @author David Zülke <*****@*****.**>
* @author Noah Fontes <*****@*****.**>
* @since 1.0.0
*/
public static function validateXsi(AgaviXmlConfigDomDocument $document)
{
// next, find (and validate against) XML schema instance declarations
$sources = array();
if ($document->documentElement->hasAttributeNS('http://www.w3.org/2001/XMLSchema-instance', 'schemaLocation')) {
// find locations. for namespaces, they are space separated pairs of a namespace URI and a schema location
$locations = preg_split('/\\s+/', $document->documentElement->getAttributeNS('http://www.w3.org/2001/XMLSchema-instance', 'schemaLocation'));
for ($i = 1; $i < count($locations); $i = $i + 2) {
$sources[] = $locations[$i];
}
}
// no namespace? then it's only one schema location in this attribute
if ($document->documentElement->hasAttributeNS('http://www.w3.org/2001/XMLSchema-instance', 'noNamespaceSchemaLocation')) {
$sources[] = $document->documentElement->getAttributeNS('http://www.w3.org/2001/XMLSchema-instance', 'noNamespaceSchemaLocation');
}
if ($sources) {
// we have instances to validate against...
$schemas = array();
foreach ($sources as &$source) {
// so for each location, we need to grab the file and validate against this grabbed source code, as libxml often has a hard time retrieving stuff over HTTP
$source = AgaviToolkit::expandDirectives($source);
if (parse_url($source, PHP_URL_SCHEME) === null && !AgaviToolkit::isPathAbsolute($source)) {
// the schema location is relative to the XML file
$source = dirname($document->documentURI) . DIRECTORY_SEPARATOR . $source;
}
$schema = @file_get_contents($source);
if ($schema === false) {
throw new AgaviUnreadableException(sprintf('XML Schema validation file "%s" for configuration file "%s" does not exist or is unreadable', $source, $document->documentURI));
}
$schemas[] = $schema;
}
// now validate them all
self::validateXmlschemaSource($document, $schemas);
}
}
private function importModuleXML($accessLocation)
{
$document = new AgaviXmlConfigDomDocument();
$document->load(AgaviToolkit::expandDirectives($accessLocation));
$this->fetchDQLViews($this->setupXPath($document));
}
/**
* Execute this configuration handler.
*
* @param AgaviXmlConfigDomDocument The document to parse.
*
* @return string Data to be written to a cache file.
*
* @throws <b>AgaviUnreadableException</b> If a requested configuration
* file does not exist or is not
* readable.
* @throws <b>AgaviParseException</b> If a requested configuration file is
* improperly formatted.
*
* @author David Zülke <*****@*****.**>
* @author Dominik del Bondio <*****@*****.**>
* @author Sean Kerr <*****@*****.**>
* @since 0.9.0
*/
public function execute(AgaviXmlConfigDomDocument $document)
{
// set up our default namespace
$document->setDefaultNamespace(self::XML_NAMESPACE, 'settings');
// init our data array
$data = array();
$prefix = 'core.';
foreach ($document->getConfigurationElements() as $cfg) {
// let's do our fancy work
if ($cfg->has('system_actions')) {
foreach ($cfg->get('system_actions') as $action) {
$name = $action->getAttribute('name');
$data[sprintf('actions.%s_module', $name)] = $action->getChild('module')->getValue();
$data[sprintf('actions.%s_action', $name)] = $action->getChild('action')->getValue();
}
}
// loop over <setting> elements; there can be many of them
foreach ($cfg->get('settings') as $setting) {
$localPrefix = $prefix;
// let's see if this buddy has a <settings> parent with valuable information
if ($setting->parentNode->localName == 'settings') {
if ($setting->parentNode->hasAttribute('prefix')) {
$localPrefix = $setting->parentNode->getAttribute('prefix');
}
}
$settingName = $localPrefix . $setting->getAttribute('name');
if ($setting->hasAgaviParameters()) {
$data[$settingName] = $setting->getAgaviParameters();
} else {
$data[$settingName] = $setting->getLiteralValue();
}
}
if ($cfg->has('exception_templates')) {
foreach ($cfg->get('exception_templates') as $exception_template) {
$tpl = AgaviToolkit::expandDirectives($exception_template->getValue());
if (!is_readable($tpl)) {
throw new AgaviConfigurationException('Exception template "' . $tpl . '" does not exist or is unreadable');
}
if ($exception_template->hasAttribute('context')) {
foreach (array_map('trim', explode(' ', $exception_template->getAttribute('context'))) as $ctx) {
$data['exception.templates.' . $ctx] = $tpl;
}
} else {
$data['exception.default_template'] = AgaviToolkit::expandDirectives($tpl);
}
}
}
}
$code = 'AgaviConfig::fromArray(' . var_export($data, true) . ');';
return $this->generate($code, $document->documentURI);
}
/**
* Evaluates a given AgaviConfig per-module directive using the given info.
*
* @param string The name of the module
* @param string The relevant name fragment of the directive
* @param array The variables to expand in the directive value.
*
* @return string The final value
*
* @author David Zülke <*****@*****.**>
* @since 1.0.0
*/
public static function evaluateModuleDirective($moduleName, $directiveNameFragment, $variables = array())
{
return AgaviToolkit::expandVariables(AgaviToolkit::expandDirectives(AgaviConfig::get(sprintf('modules.%s.%s', strtolower($moduleName), $directiveNameFragment))), $variables);
}
/**
* Takes a nested array of AgaviConfigValueHolder containing the routing
* information and creates the routes in the given routing.
*
* @param AgaviRouting The routing instance to create the routes in.
* @param mixed The "roles" node (element or node list)
* @param string The name of the parent route (if any).
*
* @author Dominik del Bondio <*****@*****.**>
* @since 0.11.0
*/
protected function parseRoutes(AgaviRouting $routing, $routes, $parent = null)
{
foreach ($routes as $route) {
$pattern = AgaviToolkit::expandDirectives($route->getAttribute('pattern'));
$opts = array();
if ($route->hasAttribute('imply')) {
$opts['imply'] = AgaviToolkit::literalize($route->getAttribute('imply'));
}
if ($route->hasAttribute('cut')) {
$opts['cut'] = AgaviToolkit::literalize($route->getAttribute('cut'));
}
if ($route->hasAttribute('stop')) {
$opts['stop'] = AgaviToolkit::literalize($route->getAttribute('stop'));
}
if ($route->hasAttribute('name')) {
$opts['name'] = AgaviToolkit::expandDirectives($route->getAttribute('name'));
}
if ($route->hasAttribute('source')) {
$opts['source'] = AgaviToolkit::expandDirectives($route->getAttribute('source'));
}
if ($route->hasAttribute('constraint')) {
$opts['constraint'] = array_map('trim', explode(' ', trim(AgaviToolkit::expandDirectives($route->getAttribute('constraint')))));
}
// values which will be set when the route matched
if ($route->hasAttribute('action')) {
$opts['action'] = AgaviToolkit::expandDirectives($route->getAttribute('action'));
}
if ($route->hasAttribute('locale')) {
$opts['locale'] = AgaviToolkit::expandDirectives($route->getAttribute('locale'));
}
if ($route->hasAttribute('method')) {
$opts['method'] = AgaviToolkit::expandDirectives($route->getAttribute('method'));
}
if ($route->hasAttribute('module')) {
$opts['module'] = AgaviToolkit::expandDirectives($route->getAttribute('module'));
}
if ($route->hasAttribute('output_type')) {
$opts['output_type'] = AgaviToolkit::expandDirectives($route->getAttribute('output_type'));
}
if ($route->has('ignores')) {
foreach ($route->get('ignores') as $ignore) {
$opts['ignores'][] = $ignore->getValue();
}
}
if ($route->has('defaults')) {
foreach ($route->get('defaults') as $default) {
$opts['defaults'][$default->getAttribute('for')] = $default->getValue();
}
}
if ($route->has('callbacks')) {
$opts['callbacks'] = array();
foreach ($route->get('callbacks') as $callback) {
$opts['callbacks'][] = array('class' => $callback->getAttribute('class'), 'parameters' => $callback->getAgaviParameters());
}
}
$opts['parameters'] = $route->getAgaviParameters();
if (isset($opts['name']) && $parent) {
// don't overwrite $parent since it's used later
$parentName = $parent;
if ($opts['name'][0] == '.') {
while ($parentName && isset($this->unnamedRoutes[$parentName])) {
$parentRoute = $routing->getRoute($parentName);
$parentName = $parentRoute['opt']['parent'];
}
$opts['name'] = $parentName . $opts['name'];
}
}
if (isset($opts['action']) && $parent) {
if ($opts['action'][0] == '.') {
$parentRoute = $routing->getRoute($parent);
// unwind all empty 'action' attributes of the parent(s)
while ($parentRoute && empty($parentRoute['opt']['action'])) {
$parentRoute = $routing->getRoute($parentRoute['opt']['parent']);
}
if (!empty($parentRoute['opt']['action'])) {
$opts['action'] = $parentRoute['opt']['action'] . $opts['action'];
}
}
}
$name = $routing->addRoute($pattern, $opts, $parent);
if (!isset($opts['name']) || $opts['name'] !== $name) {
$this->unnamedRoutes[$name] = true;
}
if ($route->has('routes')) {
$this->parseRoutes($routing, $route->get('routes'), $name);
}
}
}
/**
* Executes the task.
*/
public function main()
{
if ($this->property === null) {
throw new BuildException('The property attribute must be specified');
}
if ($this->string === null) {
throw new BuildException('The string attribute must be specified');
}
$this->tryLoadAgavi();
$this->tryBootstrapAgavi();
$assigns = array();
foreach ($this->variables as $variable) {
$assigns[$variable->getName()] = $variable->getValue();
}
$result = AgaviToolkit::expandVariables($this->expandDirectives ? AgaviToolkit::expandDirectives($this->string) : $this->string, $assigns);
$this->project->setUserProperty($this->property, $result);
}
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');
}
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;
}
/**
* Execute this configuration handler.
*
* @param AgaviXmlConfigDomDocument The document to parse.
*
* @return string Data to be written to a cache file.
*
* @throws <b>AgaviUnreadableException</b> If a requested configuration
* file does not exist or is not
* readable.
* @throws <b>AgaviParseException</b> If a requested configuration file is
* improperly formatted.
*
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
public function execute(AgaviXmlConfigDomDocument $document)
{
// set up our default namespace
$document->setDefaultNamespace(self::XML_NAMESPACE, 'output_types');
// remember the config file path
$config = $document->documentURI;
$data = array();
$defaultOt = null;
foreach ($document->getConfigurationElements() as $cfg) {
if (!$cfg->has('output_types')) {
continue;
}
$otnames = array();
foreach ($cfg->get('output_types') as $outputType) {
$otname = $outputType->getAttribute('name');
if (in_array($otname, $otnames)) {
throw new AgaviConfigurationException('Duplicate Output Type "' . $otname . '" in ' . $config);
}
$otnames[] = $otname;
}
if (!$cfg->getChild('output_types')->hasAttribute('default')) {
throw new AgaviConfigurationException('No default Output Type specified in ' . $config);
}
foreach ($cfg->get('output_types') as $outputType) {
$outputTypeName = $outputType->getAttribute('name');
$data[$outputTypeName] = isset($data[$outputTypeName]) ? $data[$outputTypeName] : array('parameters' => array(), 'default_renderer' => null, 'renderers' => array(), 'layouts' => array(), 'default_layout' => null, 'exception_template' => null);
if ($outputType->has('renderers')) {
foreach ($outputType->get('renderers') as $renderer) {
$rendererName = $renderer->getAttribute('name');
$data[$outputTypeName]['renderers'][$rendererName] = array('class' => $renderer->getAttribute('class'), 'instance' => null, 'parameters' => $renderer->getAgaviParameters(array()));
}
$data[$outputTypeName]['default_renderer'] = $outputType->getChild('renderers')->getAttribute('default');
}
if ($outputType->has('layouts')) {
foreach ($outputType->get('layouts') as $layout) {
$layers = array();
if ($layout->has('layers')) {
foreach ($layout->get('layers') as $layer) {
$slots = array();
if ($layer->has('slots')) {
foreach ($layer->get('slots') as $slot) {
$slots[$slot->getAttribute('name')] = array('action' => $slot->getAttribute('action'), 'module' => $slot->getAttribute('module'), 'output_type' => $slot->getAttribute('output_type'), 'request_method' => $slot->getAttribute('method'), 'parameters' => $slot->getAgaviParameters(array()));
}
}
$layers[$layer->getAttribute('name')] = array('class' => $layer->getAttribute('class', $this->getParameter('default_layer_class', 'AgaviFileTemplateLayer')), 'parameters' => $layer->getAgaviParameters(array()), 'renderer' => $layer->getAttribute('renderer'), 'slots' => $slots);
}
}
$data[$outputTypeName]['layouts'][$layout->getAttribute('name')] = array('layers' => $layers, 'parameters' => $layout->getAgaviParameters(array()));
}
$data[$outputTypeName]['default_layout'] = $outputType->getChild('layouts')->getAttribute('default');
}
if ($outputType->hasAttribute('exception_template')) {
$data[$outputTypeName]['exception_template'] = AgaviToolkit::expandDirectives($outputType->getAttribute('exception_template'));
if (!is_readable($data[$outputTypeName]['exception_template'])) {
throw new AgaviConfigurationException('Exception template "' . $data[$outputTypeName]['exception_template'] . '" does not exist or is unreadable');
}
}
$data[$outputTypeName]['parameters'] = $outputType->getAgaviParameters($data[$outputTypeName]['parameters']);
}
$defaultOt = $cfg->getChild('output_types')->getAttribute('default');
}
if (!isset($data[$defaultOt])) {
$error = 'Configuration file "%s" specifies undefined default Output Type "%s".';
$error = sprintf($error, $document->documentURI, $defaultOt);
throw new AgaviConfigurationException($error);
}
$code = array();
foreach ($data as $outputTypeName => $outputType) {
$code[] = '$ot = new AgaviOutputType();';
$code[] = sprintf('$ot->initialize($this->context, %s, %s, %s, %s, %s, %s, %s);', var_export($outputType['parameters'], true), var_export($outputTypeName, true), var_export($outputType['renderers'], true), var_export($outputType['default_renderer'], true), var_export($outputType['layouts'], true), var_export($outputType['default_layout'], true), var_export($outputType['exception_template'], true));
$code[] = sprintf('$this->outputTypes[%s] = $ot;', var_export($outputTypeName, true));
}
$code[] = sprintf('$this->defaultOutputType = %s;', var_export($defaultOt, true));
return $this->generate($code, $config);
}
public function readJsonFromConfig()
{
$config = (include AgaviConfigCache::checkConfig(AgaviToolkit::expandDirectives('%core.config_dir%/menu.xml')));
$menu = $this->getAllowedMenuPoints($config);
return $menu;
}
/**
* Converts an AgaviXmlConfigDomElement into an array.
*
* @param AgaviXmlConfigDomElement The configuration element to convert.
* @param bool Whether this is a top level element.
*
* @return array The configuration values as an array.
*
* @author Dominik del Bondio <*****@*****.**>
* @author David Zülke <*****@*****.**>
* @since 0.11.0
*/
protected function convertToArray(AgaviXmlConfigDomElement $item, $topLevel = false)
{
$idAttribute = $this->getParameter('id_attribute', 'name');
$valueKey = $this->getParameter('value_key', 'value');
$forceArrayValues = $this->getParameter('force_array_values', false);
$attributePrefix = $this->getParameter('attribute_prefix', '');
$literalize = $this->getParameter('literalize', true);
$singularParentName = AgaviInflector::singularize($item->getName());
$data = array();
$attribs = $item->getAttributes();
$numAttribs = count($attribs);
if ($idAttribute && $item->hasAttribute($idAttribute)) {
$numAttribs--;
}
foreach ($item->getAttributes() as $name => $value) {
if ($topLevel && in_array($name, array('context', 'environment')) || $name == $idAttribute) {
continue;
}
if ($literalize) {
$value = AgaviToolkit::literalize($value);
}
if (!isset($data[$name])) {
$data[$attributePrefix . $name] = $value;
}
}
if (!(int) $item->ownerDocument->getXpath()->evaluate(sprintf('count(*[namespace-uri() = "%s"])', $item->ownerDocument->getDefaultNamespaceUri()), $item)) {
if ($literalize) {
$val = $item->getLiteralValue();
} else {
$val = $item->getValue();
}
if ($val === null) {
$val = '';
}
if (!$topLevel && ($numAttribs || $forceArrayValues)) {
$data[$valueKey] = $val;
} elseif (!$topLevel) {
$data = $val;
}
} else {
$names = array();
$children = $item->ownerDocument->getXpath()->query(sprintf('*[namespace-uri() = "%s"]', $item->ownerDocument->getDefaultNamespaceUri()), $item);
foreach ($children as $child) {
$names[] = $child->getName();
}
$dupes = array();
foreach (array_unique(array_diff_assoc($names, array_unique($names))) as $name) {
$dupes[] = $name;
}
foreach ($children as $key => $child) {
$hasId = $idAttribute && $child->hasAttribute($idAttribute);
$isDupe = in_array($child->getName(), $dupes);
$hasParent = $child->getName() == $singularParentName && $item->getName() != $singularParentName;
if (($hasId || $isDupe) && !$hasParent) {
// it's one of multiple tags in this level without the respective plural form as the parent node
if (!isset($data[$idx = AgaviInflector::pluralize($child->getName())])) {
$data[$idx] = array();
}
$hasParent = true;
$to =& $data[$idx];
} else {
$to =& $data;
}
if ($hasId) {
$key = $child->getAttribute($idAttribute);
if ($literalize) {
// no literalize, just constants!
$key = AgaviToolkit::expandDirectives($key);
}
$to[$key] = $this->convertToArray($child);
} elseif ($hasParent) {
$to[] = $this->convertToArray($child);
} else {
$to[$child->getName()] = $this->convertToArray($child);
}
}
}
return $data;
}
/**
* Runs AgaviToolkit::expandDirectives() on all attributes and text nodes of
* the given file and writes a it to a new file in the Agavi cache directory.
*
* @param string The path to the xml file
*
* @return string The path to the expanded file
*
* @author Dominik del Bondio <*****@*****.**>
* @since 1.1.0
*/
private static function expandConfiguration($file)
{
// file does not exist, let PHPUnit handle that case
if (!is_readable($file) || !is_file($file)) {
return $file;
}
$doc = new DOMDocument();
$doc->substituteEntities = true;
$doc->load($file);
$xpath = new DOMXPath($doc);
$attributeNodes = $xpath->query('//@*');
foreach ($attributeNodes as $attributeNode) {
$attributeNode->value = AgaviToolkit::expandDirectives($attributeNode->value);
}
$textNodes = $xpath->query('//text()');
foreach ($textNodes as $textNode) {
$textNode->nodeValue = AgaviToolkit::expandDirectives($textNode->nodeValue);
}
$translatedFile = AgaviConfigCache::getCacheName($file);
AgaviConfigCache::writeCacheFile($file, $translatedFile, $doc->saveXML());
return $translatedFile;
}
