source: branches/comu-ver2/data/module/log4php/php4/log4php/xml/LoggerDOMConfigurator.php @ 18220

Revision 18220, 24.6 KB checked in by yokkuns, 11 years ago (diff)

#149 ロガークラス作成

Line 
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 */
23if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__) . '/..');
24 
25require_once(LOG4PHP_DIR . '/spi/LoggerConfigurator.php');
26require_once(LOG4PHP_DIR . '/helpers/LoggerOptionConverter.php');
27require_once(LOG4PHP_DIR . '/LoggerLayout.php');
28require_once(LOG4PHP_DIR . '/LoggerAppender.php');
29require_once(LOG4PHP_DIR . '/spi/LoggerFilter.php');
30require_once(LOG4PHP_DIR . '/or/LoggerObjectRenderer.php');
31require_once(LOG4PHP_DIR . '/LoggerManager.php');
32
33define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_APPENDER_STATE',    1000);
34define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_LAYOUT_STATE',      1010);
35define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE',        1020);
36define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE',      1030);
37define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_FILTER_STATE',      1040);
38
39define('LOG4PHP_LOGGER_DOM_CONFIGURATOR_DEFAULT_FILENAME',  './log4php.xml');
40
41/**
42 * @var string the default configuration document
43 */
44define('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 */
59define('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 * &lt;log4php:configuration <b>debug="true"</b> xmlns:log4php="http://www.vxr.it/log4php/">
72 * ...
73 * &lt;/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 */
85class 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?>
Note: See TracBrowser for help on using the repository browser.