source: branches/feature-module-paygent/data/downloads/module/mdl_paygent/log4php/xml/LoggerDOMConfigurator.php @ 15162

Revision 15162, 24.4 KB checked in by naka, 17 years ago (diff)

ペイジェント決済モジュール
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 . '/helpers/LoggerOptionConverter.php');
26require_once(LOG4PHP_DIR . '/or/LoggerObjectRenderer.php');
27require_once(LOG4PHP_DIR . '/spi/LoggerConfigurator.php');
28require_once(LOG4PHP_DIR . '/LoggerAppender.php');
29require_once(LOG4PHP_DIR . '/LoggerLayout.php');
30require_once(LOG4PHP_DIR . '/LoggerLog.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.12 $
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'])) {
227               
228                    $this->repository->setThreshold(
229                        LoggerOptionConverter::toLevel(
230                            $this->subst($attribs['THRESHOLD']),
231                            $this->repository->getThreshold()
232                        )
233                    );
234                }
235                if (isset($attribs['DEBUG'])) {
236                    $debug = LoggerOptionConverter::toBoolean($this->subst($attribs['DEBUG']), LoggerLog::internalDebugging());
237                    $this->repository->debug = $debug;
238                    LoggerLog::internalDebugging($debug);
239                    LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LOG4PHP:CONFIGURATION. Internal Debug turned ".($debug ? 'on':'off'));
240                   
241                }
242                break;
243               
244            case 'APPENDER' :
245            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER':
246           
247                unset($this->appender);
248                $this->appender = null;
249               
250                $name  = $this->subst(@$attribs['NAME']);
251                $class = $this->subst(@$attribs['CLASS']);
252               
253                LoggerLog::debug("LoggerDOMConfigurator::tagOpen():tag=[$tag]:name=[$name]:class=[$class]");
254               
255                $this->appender =& LoggerAppender::singleton($name, $class);
256                if ($this->appender === null) {
257                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() APPENDER cannot instantiate appender '$name'");
258                }
259                $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_APPENDER_STATE;
260                break;
261               
262            case 'APPENDER_REF' :
263            case 'APPENDER-REF' :
264            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER_REF':
265            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER-REF':
266           
267           
268                if (isset($attribs['REF']) and !empty($attribs['REF'])) {
269                    $appenderName = $this->subst($attribs['REF']);
270                   
271                    LoggerLog::debug("LoggerDOMConfigurator::tagOpen() APPENDER-REF ref='$appenderName'");       
272                   
273                    $appender =& LoggerAppender::singleton($appenderName);
274                    if ($appender !== null) {
275                        switch (end($this->state)) {
276                            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE:
277                            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE:               
278                                $this->logger->addAppender($appender);
279                                break;
280                        }
281                    } else {
282                        LoggerLog::warn("LoggerDOMConfigurator::tagOpen() APPENDER-REF ref '$appenderName' points to a null appender");
283                    }
284                } else {
285                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() APPENDER-REF ref not set or empty");           
286                }
287                break;
288               
289            case 'FILTER' :
290            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':FILTER':
291           
292                LoggerLog::debug("LoggerDOMConfigurator::tagOpen() FILTER");
293                           
294                unset($this->filter);
295                $this->filter = null;
296
297                $filterName = basename($this->subst(@$attribs['CLASS']));
298                if (!empty($filterName)) {
299                    if (!class_exists($filterName)) {
300                        @include_once(LOG4PHP_DIR . "/varia/{$filterName}.php");
301                    }
302                    if (class_exists($filterName)) {
303                        $this->filter = new $filterName();
304                    } else {
305                        LoggerLog::warn("LoggerDOMConfigurator::tagOpen() FILTER. class '$filterName' doesnt exist");
306                    }
307                    $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_FILTER_STATE;
308                } else {
309                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() FILTER filter name cannot be empty");
310                }
311                break;
312               
313            case 'LAYOUT':
314            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LAYOUT':
315           
316                $class = @$attribs['CLASS'];
317
318                LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LAYOUT class='{$class}'");
319
320                $this->layout = LoggerLayout::factory($this->subst($class));
321                if ($this->layout === null)
322                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LAYOUT unable to instanciate class='{$class}'");
323               
324                $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_LAYOUT_STATE;
325                break;
326           
327            case 'LOGGER':
328            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LOGGER':
329           
330                // $this->logger is assigned by reference.
331                // Only '$this->logger=null;' destroys referenced object
332                unset($this->logger);
333                $this->logger = null;
334               
335                $loggerName = $this->subst(@$attribs['NAME']);
336                if (!empty($loggerName)) {
337                    LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LOGGER. name='$loggerName'");       
338                   
339                    $class = $this->subst(@$attribs['CLASS']);
340                    if (empty($class)) {
341                        $this->logger =& $this->repository->getLogger($loggerName);
342                    } else {
343                        $className = basename($class);
344                        if (!class_exists($className)) 
345                            @include_once("{$class}.php");
346                        if (!class_exists($className)) {
347                            LoggerLog::warn(
348                                "LoggerDOMConfigurator::tagOpen() LOGGER. ".
349                                "cannot find '$className'."
350                            );                       
351                        } else {
352                       
353                            if (in_array('getlogger', get_class_methods($className))) {
354                                $this->logger =& call_user_func(array($className, 'getlogger'), $loggerName);
355                            } else {
356                                LoggerLog::warn(
357                                    "LoggerDOMConfigurator::tagOpen() LOGGER. ".
358                                    "class '$className' doesnt implement 'getLogger()' method."
359                                );                       
360                            }
361                        }
362                    }   
363                    if ($this->logger !== null and isset($attribs['ADDITIVITY'])) {
364                        $additivity = LoggerOptionConverter::toBoolean($this->subst($attribs['ADDITIVITY']), true);     
365                        $this->logger->setAdditivity($additivity);
366                    }
367                } else {
368                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LOGGER. Attribute 'name' is not set or is empty.");
369                }
370                $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE;;
371                break;
372           
373            case 'LEVEL':
374            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LEVEL':
375            case 'PRIORITY':
376            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':PRIORITY':
377           
378                if (!isset($attribs['VALUE'])) {
379                    LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LEVEL value not set");
380                    break;
381                }
382                   
383                LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LEVEL value={$attribs['VALUE']}");
384               
385                if ($this->logger === null) {
386                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LEVEL. parent logger is null");
387                    break;
388                }
389       
390                switch (end($this->state)) {
391                    case LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE:
392                        $this->logger->setLevel(
393                            LoggerOptionConverter::toLevel(
394                                $this->subst($attribs['VALUE']),
395                                $this->logger->getLevel()
396                            )
397                        );
398                        LoggerLog::debug("LoggerDOMConfigurator::tagOpen() LEVEL root level is now '{$attribs['VALUE']}' ");               
399                        break;
400                    case LOG4PHP_LOGGER_DOM_CONFIGURATOR_LOGGER_STATE:
401                        $this->logger->setLevel(
402                            LoggerOptionConverter::toLevel(
403                                $this->subst($attribs['VALUE']),
404                                $this->logger->getLevel()
405                            )
406                        );
407                        break;
408                    default:
409                        LoggerLog::warn("LoggerDOMConfigurator::tagOpen() LEVEL state '{$this->state}' not allowed here");
410                }
411                break;
412           
413            case 'PARAM':
414            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':PARAM':
415
416                LoggerLog::debug("LoggerDOMConfigurator::tagOpen() PARAM");
417               
418                if (!isset($attribs['NAME'])) {
419                    LoggerLog::warn(
420                        "LoggerDOMConfigurator::tagOpen() PARAM. ".
421                        "attribute 'name' not defined."
422                    );
423                    break;
424                }
425                if (!isset($attribs['VALUE'])) {
426                    LoggerLog::warn(
427                        "LoggerDOMConfigurator::tagOpen() PARAM. ".
428                        "attribute 'value' not defined."
429                    );
430                    break;
431                }
432                   
433                switch (end($this->state)) {
434                    case LOG4PHP_LOGGER_DOM_CONFIGURATOR_APPENDER_STATE:
435                        if ($this->appender !== null) {
436                            $this->setter($this->appender, $this->subst($attribs['NAME']), $this->subst($attribs['VALUE']));
437                        } else {
438                            LoggerLog::warn(
439                                "LoggerDOMConfigurator::tagOpen() PARAM. ".
440                                " trying to set property to a null appender."
441                            );
442                        }
443                        break;
444                    case LOG4PHP_LOGGER_DOM_CONFIGURATOR_LAYOUT_STATE:
445                        if ($this->layout !== null) {
446                            $this->setter($this->layout, $this->subst($attribs['NAME']), $this->subst($attribs['VALUE']));               
447                        } else {
448                            LoggerLog::warn(
449                                "LoggerDOMConfigurator::tagOpen() PARAM. ".
450                                " trying to set property to a null layout."
451                            );
452                        }
453                        break;
454                    case LOG4PHP_LOGGER_DOM_CONFIGURATOR_FILTER_STATE:
455                        if ($this->filter !== null) {
456                            $this->setter($this->filter, $this->subst($attribs['NAME']), $this->subst($attribs['VALUE']));
457                        } else {
458                            LoggerLog::warn(
459                                "LoggerDOMConfigurator::tagOpen() PARAM. ".
460                                " trying to set property to a null filter."
461                            );
462                        }
463                        break;
464                    default:
465                        LoggerLog::warn("LoggerDOMConfigurator::tagOpen() PARAM state '{$this->state}' not allowed here");
466                }
467                break;
468           
469            case 'RENDERER':
470            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':RENDERER':
471
472                $renderedClass   = $this->subst(@$attribs['RENDEREDCLASS']);
473                $renderingClass  = $this->subst(@$attribs['RENDERINGCLASS']);
474       
475                LoggerLog::debug("LoggerDOMConfigurator::tagOpen() RENDERER renderedClass='$renderedClass' renderingClass='$renderingClass'");
476       
477                if (!empty($renderedClass) and !empty($renderingClass)) {
478                    $renderer = LoggerObjectRenderer::factory($renderingClass);
479                    if ($renderer === null) {
480                        LoggerLog::warn("LoggerDOMConfigurator::tagOpen() RENDERER cannot instantiate '$renderingClass'");
481                    } else {
482                        $this->repository->setRenderer($renderedClass, $renderer);
483                    }
484                } else {
485                    LoggerLog::warn("LoggerDOMConfigurator::tagOpen() RENDERER renderedClass or renderingClass is empty");       
486                }
487                break;
488           
489            case 'ROOT':
490            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':ROOT':
491           
492                LoggerLog::debug("LoggerDOMConfigurator::tagOpen() ROOT");
493               
494                $this->logger =& LoggerManager::getRootLogger();
495               
496                $this->state[] = LOG4PHP_LOGGER_DOM_CONFIGURATOR_ROOT_STATE;
497                break;
498               
499        }
500         
501    }
502
503
504    /**
505     * @param mixed $parser
506     * @param string $tag
507     */
508    function tagClose($parser, $tag)
509    {
510        switch ($tag) {
511       
512            case 'CONFIGURATION' :
513            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':CONFIGURATION':
514         
515                LoggerLog::debug("LoggerDOMConfigurator::tagClose() CONFIGURATION");
516                break;
517               
518            case 'APPENDER' :
519            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':APPENDER':
520           
521                LoggerLog::debug("LoggerDOMConfigurator::tagClose() APPENDER");
522               
523                if ($this->appender !== null) {
524                    if ($this->appender->requiresLayout() and $this->appender->layout === null) {
525                        $appenderName = $this->appender->getName();
526                        LoggerLog::warn(
527                            "LoggerDOMConfigurator::tagClose() APPENDER. ".
528                            "'$appenderName' requires a layout that is not defined. ".
529                            "Using a simple layout"
530                        );
531                        $this->appender->setLayout(LoggerLayout::factory('LoggerLayoutSimple'));
532                    }                   
533                    $this->appender->activateOptions();
534                }       
535                array_pop($this->state);       
536                break;
537               
538            case 'FILTER' :
539            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':FILTER':
540           
541                LoggerLog::debug("LoggerDOMConfigurator::tagClose() FILTER");
542                           
543                if ($this->filter !== null) {
544                    $this->filter->activateOptions();
545                    $this->appender->addFilter($this->filter);
546                    $this->filter = null;
547                }
548                array_pop($this->state);       
549                break;
550               
551            case 'LAYOUT':
552            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LAYOUT':
553
554                LoggerLog::debug("LoggerDOMConfigurator::tagClose() LAYOUT");
555
556                if ($this->appender !== null and $this->layout !== null and $this->appender->requiresLayout()) {
557                    $this->layout->activateOptions();
558                    $this->appender->setLayout($this->layout);
559                    $this->layout = null;
560                }
561                array_pop($this->state);
562                break;
563           
564            case 'LOGGER':
565            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':LOGGER':
566           
567                LoggerLog::debug("LoggerDOMConfigurator::tagClose() LOGGER");       
568
569                array_pop($this->state);
570                break;
571           
572            case 'ROOT':
573            case LOG4PHP_LOGGER_DOM_CONFIGURATOR_XMLNS.':ROOT':
574           
575                LoggerLog::debug("LoggerDOMConfigurator::tagClose() ROOT");
576
577                array_pop($this->state);
578                break;
579        }
580    }
581   
582    /**
583     * @param object $object
584     * @param string $name
585     * @param mixed $value
586     */
587    function setter(&$object, $name, $value)
588    {
589        if (empty($name)) {
590            LoggerLog::debug("LoggerDOMConfigurator::setter() 'name' param cannot be empty");       
591            return false;
592        }
593        $methodName = 'set'.ucfirst($name);
594        if (method_exists($object, $methodName)) {
595            LoggerLog::debug("LoggerDOMConfigurator::setter() Calling ".get_class($object)."::{$methodName}({$value})");
596            return call_user_func(array(&$object, $methodName), $value);
597        } else {
598            LoggerLog::warn("LoggerDOMConfigurator::setter() ".get_class($object)."::{$methodName}() does not exists");
599            return false;
600        }
601    }
602   
603    function subst($value)
604    {
605        return LoggerOptionConverter::substVars($value);
606    }
607
608}
609?>
Note: See TracBrowser for help on using the repository browser.