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

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

#149 ロガークラス作成

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