[18220] | 1 | <?php
|
---|
| 2 | /**
|
---|
| 3 | * log4php is a PHP port of the log4j java logging package.
|
---|
| 4 | *
|
---|
| 5 | * <p>This framework is based on log4j (see {@link http://jakarta.apache.org/log4j log4j} for details).</p>
|
---|
| 6 | * <p>Design, strategies and part of the methods documentation are developed by log4j team
|
---|
| 7 | * (Ceki Gülcü as log4j project founder and
|
---|
| 8 | * {@link http://jakarta.apache.org/log4j/docs/contributors.html contributors}).</p>
|
---|
| 9 | *
|
---|
| 10 | * <p>PHP port, extensions and modifications by VxR. All rights reserved.<br>
|
---|
| 11 | * For more information, please see {@link http://www.vxr.it/log4php/}.</p>
|
---|
| 12 | *
|
---|
| 13 | * <p>This software is published under the terms of the LGPL License
|
---|
| 14 | * a copy of which has been included with this distribution in the LICENSE file.</p>
|
---|
| 15 | *
|
---|
| 16 | * @package log4php
|
---|
| 17 | * @subpackage xml
|
---|
| 18 | */
|
---|
| 19 |
|
---|
| 20 | /**
|
---|
| 21 | * @ignore
|
---|
| 22 | */
|
---|
| 23 | if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__) . '/..');
|
---|
| 24 |
|
---|
| 25 | require_once(LOG4PHP_DIR . '/spi/LoggerConfigurator.php');
|
---|
| 26 | require_once(LOG4PHP_DIR . '/helpers/LoggerOptionConverter.php');
|
---|
| 27 | require_once(LOG4PHP_DIR . '/LoggerLayout.php');
|
---|
| 28 | require_once(LOG4PHP_DIR . '/LoggerAppender.php');
|
---|
| 29 | require_once(LOG4PHP_DIR . '/spi/LoggerFilter.php');
|
---|
| 30 | require_once(LOG4PHP_DIR . '/or/LoggerObjectRenderer.php');
|
---|
| 31 | require_once(LOG4PHP_DIR . '/LoggerManager.php');
|
---|
| 32 |
|
---|
| 33 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_APPENDER_STATE', 1000);
|
---|
| 34 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_LAYOUT_STATE', 1010);
|
---|
| 35 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE', 1020);
|
---|
| 36 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE', 1030);
|
---|
| 37 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_FILTER_STATE', 1040);
|
---|
| 38 |
|
---|
| 39 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_DEFAULT_FILENAME', './log4php.xml');
|
---|
| 40 |
|
---|
| 41 | /**
|
---|
| 42 | * @var string the default configuration document
|
---|
| 43 | */
|
---|
| 44 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_DEFAULT_CONFIGURATION',
|
---|
| 45 | '<?xml version="1.0" ?>
|
---|
| 46 | <log4php:configuration threshold="all">
|
---|
| 47 | <appender name="A1" class="LoggerAppenderEcho">
|
---|
| 48 | <layout class="LoggerLayoutSimple" />
|
---|
| 49 | </appender>
|
---|
| 50 | <root>
|
---|
| 51 | <level value="debug" />
|
---|
| 52 | <appender_ref ref="A1" />
|
---|
| 53 | </root>
|
---|
| 54 | </log4php:configuration>');
|
---|
| 55 |
|
---|
| 56 | /**
|
---|
| 57 | * @var string the elements namespace
|
---|
| 58 | */
|
---|
| 59 | define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS', 'HTTP://WWW.VXR.IT/LOG4PHP/');
|
---|
| 60 |
|
---|
| 61 | /**
|
---|
| 62 | * Use this class to initialize the log4php environment using expat parser.
|
---|
| 63 | *
|
---|
| 64 | * <p>Read the log4php.dtd included in the documentation directory. Note that
|
---|
| 65 | * php parser does not validate the document.</p>
|
---|
| 66 | *
|
---|
| 67 | * <p>Sometimes it is useful to see how log4php is reading configuration
|
---|
| 68 | * files. You can enable log4php internal logging by setting the <var>debug</var>
|
---|
| 69 | * attribute in the <var>log4php:configuration</var> element. As in
|
---|
| 70 | * <pre>
|
---|
| 71 | * <log4php:configuration <b>debug="true"</b> xmlns:log4php="http://www.vxr.it/log4php/">
|
---|
| 72 | * ...
|
---|
| 73 | * </log4php:configuration>
|
---|
| 74 | * </pre>
|
---|
| 75 | *
|
---|
| 76 | * <p>There are sample XML files included in the package under <b>tests/</b>
|
---|
| 77 | * subdirectories.</p>
|
---|
| 78 | *
|
---|
| 79 | * @author VxR <vxr@vxr.it>
|
---|
| 80 | * @version $Revision: 1.10 $
|
---|
| 81 | * @package log4php
|
---|
| 82 | * @subpackage xml
|
---|
| 83 | * @since 0.4
|
---|
| 84 | */
|
---|
| 85 | class LoggerDOMConfigurator extends LoggerConfigurator {
|
---|
| 86 |
|
---|
| 87 | /**
|
---|
| 88 | * @var LoggerHierarchy
|
---|
| 89 | */
|
---|
| 90 | var $repository;
|
---|
| 91 |
|
---|
| 92 | /**
|
---|
| 93 | * @var array state stack
|
---|
| 94 | */
|
---|
| 95 | var $state;
|
---|
| 96 |
|
---|
| 97 | /**
|
---|
| 98 | * @var Logger parsed Logger
|
---|
| 99 | */
|
---|
| 100 | var $logger;
|
---|
| 101 |
|
---|
| 102 | /**
|
---|
| 103 | * @var LoggerAppender parsed LoggerAppender
|
---|
| 104 | */
|
---|
| 105 | var $appender;
|
---|
| 106 |
|
---|
| 107 | /**
|
---|
| 108 | * @var LoggerFilter parsed LoggerFilter
|
---|
| 109 | */
|
---|
| 110 | var $filter;
|
---|
| 111 |
|
---|
| 112 | /**
|
---|
| 113 | * @var LoggerLayout parsed LoggerLayout
|
---|
| 114 | */
|
---|
| 115 | var $layout;
|
---|
| 116 |
|
---|
| 117 | /**
|
---|
| 118 | * Constructor
|
---|
| 119 | */
|
---|
| 120 | function LoggerDOMConfigurator()
|
---|
| 121 | {
|
---|
| 122 | $this->state = array();
|
---|
| 123 | $this->logger = null;
|
---|
| 124 | $this->appender = null;
|
---|
| 125 | $this->filter = null;
|
---|
| 126 | $this->layout = null;
|
---|
| 127 | }
|
---|
| 128 |
|
---|
| 129 | /**
|
---|
| 130 | * Configure the default repository using the resource pointed by <b>url</b>.
|
---|
| 131 | * <b>Url</b> is any valid resurce as defined in {@link PHP_MANUAL#file} function.
|
---|
| 132 | * Note that the resource will be search with <i>use_include_path</i> parameter
|
---|
| 133 | * set to "1".
|
---|
| 134 | *
|
---|
| 135 | * @param string $url
|
---|
| 136 | * @static
|
---|
| 137 | */
|
---|
| 138 | function configure($url = '')
|
---|
| 139 | {
|
---|
| 140 | $configurator = new LoggerDOMConfigurator();
|
---|
| 141 | $repository =& LoggerManager::getLoggerRepository();
|
---|
| 142 | return $configurator->doConfigure($url, $repository);
|
---|
| 143 | }
|
---|
| 144 |
|
---|
| 145 | /**
|
---|
| 146 | * Configure the given <b>repository</b> using the resource pointed by <b>url</b>.
|
---|
| 147 | * <b>Url</b> is any valid resurce as defined in {@link PHP_MANUAL#file} function.
|
---|
| 148 | * Note that the resource will be search with <i>use_include_path</i> parameter
|
---|
| 149 | * set to "1".
|
---|
| 150 | *
|
---|
| 151 | * @param string $url
|
---|
| 152 | * @param LoggerHierarchy &$repository
|
---|
| 153 | */
|
---|
| 154 | function doConfigure($url = '', &$repository)
|
---|
| 155 | {
|
---|
| 156 | $xmlData = '';
|
---|
| 157 | if (!empty($url))
|
---|
| 158 | $xmlData = implode('', file($url, 1));
|
---|
| 159 | return $this->doConfigureByString($xmlData, $repository);
|
---|
| 160 | }
|
---|
| 161 |
|
---|
| 162 | /**
|
---|
| 163 | * Configure the given <b>repository</b> using the configuration written in <b>xmlData</b>.
|
---|
| 164 | * Do not call this method directly. Use {@link doConfigure()} instead.
|
---|
| 165 | * @param string $xmlData
|
---|
| 166 | * @param LoggerHierarchy &$repository
|
---|
| 167 | */
|
---|
| 168 | function doConfigureByString($xmlData, &$repository)
|
---|
| 169 | {
|
---|
| 170 | return $this->parse($xmlData, $repository);
|
---|
| 171 | }
|
---|
| 172 |
|
---|
| 173 | /**
|
---|
| 174 | * @param LoggerHierarchy &$repository
|
---|
| 175 | */
|
---|
| 176 | function doConfigureDefault(&$repository)
|
---|
| 177 | {
|
---|
| 178 | return $this->doConfigureByString(LOG4PHP_LOGGER_DOM_CONFIGURATOR_DEFAULT_CONFIGURATION, $repository);
|
---|
| 179 | }
|
---|
| 180 |
|
---|
| 181 | /**
|
---|
| 182 | * @param string $xmlData
|
---|
| 183 | */
|
---|
| 184 | function parse($xmlData, &$repository)
|
---|
| 185 | {
|
---|
| 186 | // LoggerManager::resetConfiguration();
|
---|
| 187 | $this->repository =& $repository;
|
---|
| 188 |
|
---|
| 189 | $parser = xml_parser_create_ns();
|
---|
| 190 |
|
---|
| 191 | xml_set_object($parser, &$this);
|
---|
| 192 | xml_set_element_handler($parser, "tagOpen", "tagClose");
|
---|
| 193 |
|
---|
| 194 | $result = xml_parse($parser, $xmlData, true);
|
---|
| 195 | if (!$result) {
|
---|
| 196 | $errorCode = xml_get_error_code($parser);
|
---|
| 197 | $errorStr = xml_error_string($errorCode);
|
---|
| 198 | $errorLine = xml_get_current_line_number($parser);
|
---|
| 199 | LoggerLog::warn(
|
---|
| 200 | "LoggerDOMConfigurator::parse() ".
|
---|
| 201 | "Parsing error [{$errorCode}] {$errorStr}, line {$errorLine}"
|
---|
| 202 | );
|
---|
| 203 | $this->repository->resetConfiguration();
|
---|
| 204 | } else {
|
---|
| 205 | xml_parser_free($parser);
|
---|
| 206 | }
|
---|
| 207 | return $result;
|
---|
| 208 | }
|
---|
| 209 |
|
---|
| 210 | /**
|
---|
| 211 | * @param mixed $parser
|
---|
| 212 | * @param string $tag
|
---|
| 213 | * @param array $attribs
|
---|
| 214 | *
|
---|
| 215 | * @todo In 'LOGGER' case find a better way to detect 'getLogger()' method
|
---|
| 216 | */
|
---|
| 217 | function tagOpen($parser, $tag, $attribs)
|
---|
| 218 | {
|
---|
| 219 | switch ($tag) {
|
---|
| 220 |
|
---|
| 221 | case 'CONFIGURATION' :
|
---|
| 222 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':CONFIGURATION':
|
---|
| 223 |
|
---|
| 224 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() CONFIGURATION");
|
---|
| 225 | /*
|
---|
| 226 | if (isset($attribs['THRESHOLD']) and
|
---|
| 227 | strtolower($attribs['THRESHOLD']) != 'null' and
|
---|
| 228 | LoggerLevel::isLevel($attribs['THRESHOLD']) )
|
---|
| 229 | {
|
---|
| 230 | $this->repository->setThreshold(LoggerLevel::toCode($attribs['THRESHOLD']));
|
---|
| 231 | }
|
---|
| 232 | */
|
---|
| 233 | if (isset($attribs['THRESHOLD'])) {
|
---|
| 234 |
|
---|
| 235 | $this->repository->setThreshold(
|
---|
| 236 | LoggerOptionConverter::toLevel(
|
---|
| 237 | $this->subst($attribs['THRESHOLD']),
|
---|
| 238 | $this->repository->getThreshold()
|
---|
| 239 | )
|
---|
| 240 | );
|
---|
| 241 | }
|
---|
| 242 | if (isset($attribs['DEBUG'])) {
|
---|
| 243 | $debug = LoggerOptionConverter::toBoolean($this->subst($attribs['DEBUG']), LoggerLog::internalDebugging());
|
---|
| 244 | $this->repository->debug = $debug;
|
---|
| 245 | LoggerLog::internalDebugging($debug);
|
---|
| 246 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LOG4PHP:CONFIGURATION. Internal Debug turned ".($debug ? 'on':'off'));
|
---|
| 247 |
|
---|
| 248 | }
|
---|
| 249 | break;
|
---|
| 250 |
|
---|
| 251 | case 'APPENDER' :
|
---|
| 252 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER':
|
---|
| 253 |
|
---|
| 254 | unset($this->appender);
|
---|
| 255 | $this->appender = null;
|
---|
| 256 |
|
---|
| 257 | $name = $this->subst(@$attribs['NAME']);
|
---|
| 258 | $class = $this->subst(@$attribs['CLASS']);
|
---|
| 259 |
|
---|
| 260 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen():tag=[$tag]:name=[$name]:class=[$class]");
|
---|
| 261 |
|
---|
| 262 | $this->appender =& LoggerAppender::singleton($name, $class);
|
---|
| 263 | if ($this->appender === null) {
|
---|
| 264 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() APPENDER cannot instantiate appender '$name'");
|
---|
| 265 | }
|
---|
| 266 | $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_APPENDER_STATE;
|
---|
| 267 | break;
|
---|
| 268 |
|
---|
| 269 | case 'APPENDER_REF' :
|
---|
| 270 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER_REF':
|
---|
| 271 |
|
---|
| 272 | if (isset($attribs['REF']) and !empty($attribs['REF'])) {
|
---|
| 273 | $appenderName = $this->subst($attribs['REF']);
|
---|
| 274 |
|
---|
| 275 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() APPENDER_REF ref='$appenderName'");
|
---|
| 276 |
|
---|
| 277 | $appender =& LoggerAppender::singleton($appenderName);
|
---|
| 278 | if ($appender !== null) {
|
---|
| 279 | switch (end($this->state)) {
|
---|
| 280 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE:
|
---|
| 281 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE:
|
---|
| 282 | $this->logger->addAppender($appender);
|
---|
| 283 | break;
|
---|
| 284 | }
|
---|
| 285 | } else {
|
---|
| 286 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() APPENDER_REF ref '$appenderName' points to a null appender");
|
---|
| 287 | }
|
---|
| 288 | } else {
|
---|
| 289 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() APPENDER_REF ref not set or empty");
|
---|
| 290 | }
|
---|
| 291 | break;
|
---|
| 292 |
|
---|
| 293 | case 'FILTER' :
|
---|
| 294 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':FILTER':
|
---|
| 295 |
|
---|
| 296 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() FILTER");
|
---|
| 297 |
|
---|
| 298 | unset($this->filter);
|
---|
| 299 | $this->filter = null;
|
---|
| 300 |
|
---|
| 301 | $filterName = basename($this->subst(@$attribs['CLASS']));
|
---|
| 302 | if (!empty($filterName)) {
|
---|
| 303 | if (!class_exists($filterName)) {
|
---|
| 304 | @include_once(LOG4PHP_DIR . "/varia/{$filterName}.php");
|
---|
| 305 | }
|
---|
| 306 | if (class_exists($filterName)) {
|
---|
| 307 | $this->filter = new $filterName();
|
---|
| 308 | } else {
|
---|
| 309 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() FILTER. class '$filterName' doesnt exist");
|
---|
| 310 | }
|
---|
| 311 | $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_FILTER_STATE;
|
---|
| 312 | } else {
|
---|
| 313 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() FILTER filter name cannot be empty");
|
---|
| 314 | }
|
---|
| 315 | break;
|
---|
| 316 |
|
---|
| 317 | case 'LAYOUT':
|
---|
| 318 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LAYOUT':
|
---|
| 319 |
|
---|
| 320 | $class = @$attribs['CLASS'];
|
---|
| 321 |
|
---|
| 322 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LAYOUT class='{$class}'");
|
---|
| 323 |
|
---|
| 324 | $this->layout = LoggerLayout::factory($this->subst($class));
|
---|
| 325 | if ($this->layout === null)
|
---|
| 326 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LAYOUT unable to instanciate class='{$class}'");
|
---|
| 327 |
|
---|
| 328 | $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_LAYOUT_STATE;
|
---|
| 329 | break;
|
---|
| 330 |
|
---|
| 331 | case 'LOGGER':
|
---|
| 332 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LOGGER':
|
---|
| 333 |
|
---|
| 334 | // $this->logger is assigned by reference.
|
---|
| 335 | // Only '$this->logger=null;' destroys referenced object
|
---|
| 336 | unset($this->logger);
|
---|
| 337 | $this->logger = null;
|
---|
| 338 |
|
---|
| 339 | $loggerName = $this->subst(@$attribs['NAME']);
|
---|
| 340 | if (!empty($loggerName)) {
|
---|
| 341 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LOGGER. name='$loggerName'");
|
---|
| 342 |
|
---|
| 343 | $class = $this->subst(@$attribs['CLASS']);
|
---|
| 344 | if (empty($class)) {
|
---|
| 345 | $this->logger =& $this->repository->getLogger($loggerName);
|
---|
| 346 | } else {
|
---|
| 347 | $className = basename($class);
|
---|
| 348 | if (!class_exists($className))
|
---|
| 349 | @include_once("{$class}.php");
|
---|
| 350 | if (!class_exists($className)) {
|
---|
| 351 | LoggerLog::warn(
|
---|
| 352 | "LoggerDOMConfigurator::tagOpen() LOGGER. ".
|
---|
| 353 | "cannot find '$className'."
|
---|
| 354 | );
|
---|
| 355 | } else {
|
---|
| 356 |
|
---|
| 357 | if (in_array('getlogger', get_class_methods($className))) {
|
---|
| 358 | $this->logger =& call_user_func(array($className, 'getlogger'), $loggerName);
|
---|
| 359 | } else {
|
---|
| 360 | LoggerLog::warn(
|
---|
| 361 | "LoggerDOMConfigurator::tagOpen() LOGGER. ".
|
---|
| 362 | "class '$className' doesnt implement 'getLogger()' method."
|
---|
| 363 | );
|
---|
| 364 | }
|
---|
| 365 | }
|
---|
| 366 | }
|
---|
| 367 | if ($this->logger !== null and isset($attribs['ADDITIVITY'])) {
|
---|
| 368 | $additivity = LoggerOptionConverter::toBoolean($this->subst($attribs['ADDITIVITY']), true);
|
---|
| 369 | $this->logger->setAdditivity($additivity);
|
---|
| 370 | }
|
---|
| 371 | } else {
|
---|
| 372 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LOGGER. Attribute 'name' is not set or is empty.");
|
---|
| 373 | }
|
---|
| 374 | $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE;;
|
---|
| 375 | break;
|
---|
| 376 |
|
---|
| 377 | case 'LEVEL':
|
---|
| 378 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LEVEL':
|
---|
| 379 | case 'PRIORITY':
|
---|
| 380 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':PRIORITY':
|
---|
| 381 |
|
---|
| 382 | if (!isset($attribs['VALUE'])) {
|
---|
| 383 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LEVEL value not set");
|
---|
| 384 | break;
|
---|
| 385 | }
|
---|
| 386 |
|
---|
| 387 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LEVEL value={$attribs['VALUE']}");
|
---|
| 388 |
|
---|
| 389 | if ($this->logger === null) {
|
---|
| 390 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LEVEL. parent logger is null");
|
---|
| 391 | break;
|
---|
| 392 | }
|
---|
| 393 |
|
---|
| 394 | switch (end($this->state)) {
|
---|
| 395 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE:
|
---|
| 396 | $this->logger->setLevel(
|
---|
| 397 | LoggerOptionConverter::toLevel(
|
---|
| 398 | $this->subst($attribs['VALUE']),
|
---|
| 399 | $this->logger->getLevel()
|
---|
| 400 | )
|
---|
| 401 | );
|
---|
| 402 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LEVEL root level is now '{$attribs['VALUE']}' ");
|
---|
| 403 | break;
|
---|
| 404 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE:
|
---|
| 405 | $this->logger->setLevel(
|
---|
| 406 | LoggerOptionConverter::toLevel(
|
---|
| 407 | $this->subst($attribs['VALUE']),
|
---|
| 408 | $this->logger->getLevel()
|
---|
| 409 | )
|
---|
| 410 | );
|
---|
| 411 | break;
|
---|
| 412 | default:
|
---|
| 413 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LEVEL state '{$this->state}' not allowed here");
|
---|
| 414 | }
|
---|
| 415 | break;
|
---|
| 416 |
|
---|
| 417 | case 'PARAM':
|
---|
| 418 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':PARAM':
|
---|
| 419 |
|
---|
| 420 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() PARAM");
|
---|
| 421 |
|
---|
| 422 | if (!isset($attribs['NAME'])) {
|
---|
| 423 | LoggerLog::warn(
|
---|
| 424 | "LoggerDOMConfigurator::tagOpen() PARAM. ".
|
---|
| 425 | "attribute 'name' not defined."
|
---|
| 426 | );
|
---|
| 427 | break;
|
---|
| 428 | }
|
---|
| 429 | if (!isset($attribs['VALUE'])) {
|
---|
| 430 | LoggerLog::warn(
|
---|
| 431 | "LoggerDOMConfigurator::tagOpen() PARAM. ".
|
---|
| 432 | "attribute 'value' not defined."
|
---|
| 433 | );
|
---|
| 434 | break;
|
---|
| 435 | }
|
---|
| 436 |
|
---|
| 437 | switch (end($this->state)) {
|
---|
| 438 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_APPENDER_STATE:
|
---|
| 439 | if ($this->appender !== null) {
|
---|
| 440 | $this->setter($this->appender, $this->subst($attribs['NAME']), $this->subst($attribs['VALUE']));
|
---|
| 441 | } else {
|
---|
| 442 | LoggerLog::warn(
|
---|
| 443 | "LoggerDOMConfigurator::tagOpen() PARAM. ".
|
---|
| 444 | " trying to set property to a null appender."
|
---|
| 445 | );
|
---|
| 446 | }
|
---|
| 447 | break;
|
---|
| 448 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_LAYOUT_STATE:
|
---|
| 449 | if ($this->layout !== null) {
|
---|
| 450 | $this->setter($this->layout, $this->subst($attribs['NAME']), $this->subst($attribs['VALUE']));
|
---|
| 451 | } else {
|
---|
| 452 | LoggerLog::warn(
|
---|
| 453 | "LoggerDOMConfigurator::tagOpen() PARAM. ".
|
---|
| 454 | " trying to set property to a null layout."
|
---|
| 455 | );
|
---|
| 456 | }
|
---|
| 457 | break;
|
---|
| 458 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_FILTER_STATE:
|
---|
| 459 | if ($this->filter !== null) {
|
---|
| 460 | $this->setter($this->filter, $this->subst($attribs['NAME']), $this->subst($attribs['VALUE']));
|
---|
| 461 | } else {
|
---|
| 462 | LoggerLog::warn(
|
---|
| 463 | "LoggerDOMConfigurator::tagOpen() PARAM. ".
|
---|
| 464 | " trying to set property to a null filter."
|
---|
| 465 | );
|
---|
| 466 | }
|
---|
| 467 | break;
|
---|
| 468 | default:
|
---|
| 469 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() PARAM state '{$this->state}' not allowed here");
|
---|
| 470 | }
|
---|
| 471 | break;
|
---|
| 472 |
|
---|
| 473 | case 'RENDERER':
|
---|
| 474 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':RENDERER':
|
---|
| 475 |
|
---|
| 476 | $renderedClass = $this->subst(@$attribs['RENDEREDCLASS']);
|
---|
| 477 | $renderingClass = $this->subst(@$attribs['RENDERINGCLASS']);
|
---|
| 478 |
|
---|
| 479 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() RENDERER renderedClass='$renderedClass' renderingClass='$renderingClass'");
|
---|
| 480 |
|
---|
| 481 | if (!empty($renderedClass) and !empty($renderingClass)) {
|
---|
| 482 | $renderer = LoggerObjectRenderer::factory($renderingClass);
|
---|
| 483 | if ($renderer === null) {
|
---|
| 484 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() RENDERER cannot instantiate '$renderingClass'");
|
---|
| 485 | } else {
|
---|
| 486 | $this->repository->setRenderer($renderedClass, $renderer);
|
---|
| 487 | }
|
---|
| 488 | } else {
|
---|
| 489 | LoggerLog::warn("LoggerDOMConfigurator::tagOpen() RENDERER renderedClass or renderingClass is empty");
|
---|
| 490 | }
|
---|
| 491 | break;
|
---|
| 492 |
|
---|
| 493 | case 'ROOT':
|
---|
| 494 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':ROOT':
|
---|
| 495 |
|
---|
| 496 | LoggerLog::debug("LoggerDOMConfigurator::tagOpen() ROOT");
|
---|
| 497 |
|
---|
| 498 | $this->logger =& LoggerManager::getRootLogger();
|
---|
| 499 |
|
---|
| 500 | $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE;
|
---|
| 501 | break;
|
---|
| 502 |
|
---|
| 503 | }
|
---|
| 504 |
|
---|
| 505 | }
|
---|
| 506 |
|
---|
| 507 |
|
---|
| 508 | /**
|
---|
| 509 | * @param mixed $parser
|
---|
| 510 | * @param string $tag
|
---|
| 511 | */
|
---|
| 512 | function tagClose($parser, $tag)
|
---|
| 513 | {
|
---|
| 514 | switch ($tag) {
|
---|
| 515 |
|
---|
| 516 | case 'CONFIGURATION' :
|
---|
| 517 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':CONFIGURATION':
|
---|
| 518 |
|
---|
| 519 | LoggerLog::debug("LoggerDOMConfigurator::tagClose() CONFIGURATION");
|
---|
| 520 | break;
|
---|
| 521 |
|
---|
| 522 | case 'APPENDER' :
|
---|
| 523 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER':
|
---|
| 524 |
|
---|
| 525 | LoggerLog::debug("LoggerDOMConfigurator::tagClose() APPENDER");
|
---|
| 526 |
|
---|
| 527 | if ($this->appender !== null) {
|
---|
| 528 | if ($this->appender->requiresLayout() and $this->appender->layout === null) {
|
---|
| 529 | $appenderName = $this->appender->getName();
|
---|
| 530 | LoggerLog::warn(
|
---|
| 531 | "LoggerDOMConfigurator::tagClose() APPENDER. ".
|
---|
| 532 | "'$appenderName' requires a layout that is not defined. ".
|
---|
| 533 | "Using a simple layout"
|
---|
| 534 | );
|
---|
| 535 | $this->appender->setLayout(LoggerLayout::factory('LoggerLayoutSimple'));
|
---|
| 536 | }
|
---|
| 537 | $this->appender->activateOptions();
|
---|
| 538 | }
|
---|
| 539 | array_pop($this->state);
|
---|
| 540 | break;
|
---|
| 541 |
|
---|
| 542 | case 'FILTER' :
|
---|
| 543 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':FILTER':
|
---|
| 544 |
|
---|
| 545 | LoggerLog::debug("LoggerDOMConfigurator::tagClose() FILTER");
|
---|
| 546 |
|
---|
| 547 | if ($this->filter !== null) {
|
---|
| 548 | $this->filter->activateOptions();
|
---|
| 549 | $this->appender->addFilter($this->filter);
|
---|
| 550 | $this->filter = null;
|
---|
| 551 | }
|
---|
| 552 | array_pop($this->state);
|
---|
| 553 | break;
|
---|
| 554 |
|
---|
| 555 | case 'LAYOUT':
|
---|
| 556 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LAYOUT':
|
---|
| 557 |
|
---|
| 558 | LoggerLog::debug("LoggerDOMConfigurator::tagClose() LAYOUT");
|
---|
| 559 |
|
---|
| 560 | if ($this->appender !== null and $this->layout !== null and $this->appender->requiresLayout()) {
|
---|
| 561 | $this->layout->activateOptions();
|
---|
| 562 | $this->appender->setLayout($this->layout);
|
---|
| 563 | $this->layout = null;
|
---|
| 564 | }
|
---|
| 565 | array_pop($this->state);
|
---|
| 566 | break;
|
---|
| 567 |
|
---|
| 568 | case 'LOGGER':
|
---|
| 569 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LOGGER':
|
---|
| 570 |
|
---|
| 571 | LoggerLog::debug("LoggerDOMConfigurator::tagClose() LOGGER");
|
---|
| 572 |
|
---|
| 573 | array_pop($this->state);
|
---|
| 574 | break;
|
---|
| 575 |
|
---|
| 576 | case 'ROOT':
|
---|
| 577 | case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':ROOT':
|
---|
| 578 |
|
---|
| 579 | LoggerLog::debug("LoggerDOMConfigurator::tagClose() ROOT");
|
---|
| 580 |
|
---|
| 581 | array_pop($this->state);
|
---|
| 582 | break;
|
---|
| 583 | }
|
---|
| 584 | }
|
---|
| 585 |
|
---|
| 586 | /**
|
---|
| 587 | * @param object $object
|
---|
| 588 | * @param string $name
|
---|
| 589 | * @param mixed $value
|
---|
| 590 | */
|
---|
| 591 | function setter(&$object, $name, $value)
|
---|
| 592 | {
|
---|
| 593 | if (empty($name)) {
|
---|
| 594 | LoggerLog::debug("LoggerDOMConfigurator::setter() 'name' param cannot be empty");
|
---|
| 595 | return false;
|
---|
| 596 | }
|
---|
| 597 | $methodName = 'set'.ucfirst($name);
|
---|
| 598 | if (method_exists($object, $methodName)) {
|
---|
| 599 | LoggerLog::debug("LoggerDOMConfigurator::setter() Calling ".get_class($object)."::{$methodName}({$value})");
|
---|
| 600 | return call_user_func(array(&$object, $methodName), $value);
|
---|
| 601 | } else {
|
---|
| 602 | LoggerLog::warn("LoggerDOMConfigurator::setter() ".get_class($object)."::{$methodName}() does not exists");
|
---|
| 603 | return false;
|
---|
| 604 | }
|
---|
| 605 | }
|
---|
| 606 |
|
---|
| 607 | function subst($value)
|
---|
| 608 | {
|
---|
| 609 | return LoggerOptionConverter::substVars($value);
|
---|
| 610 | }
|
---|
| 611 |
|
---|
| 612 | }
|
---|
| 613 | ?> |
---|