domconfigurator.cpp

log4cxx 0.10 unix下编译包

}

/**
 Used internally to parse a filter element.
*/
void DOMConfigurator::parseFilters(Pool& p,                                 
                                   log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,
                                   apr_xml_elem* element, 
                                   std::vector<log4cxx::spi::FilterPtr>& filters)
{
        LogString clazz = subst(getAttribute(utf8Decoder, element, CLASS_ATTR));
        FilterPtr filter = OptionConverter::instantiateByClassName(clazz,
                Filter::getStaticClass(), 0);

        if(filter != 0)
        {
                PropertySetter propSetter(filter);

                for (apr_xml_elem* currentElement = element->first_child;
                     currentElement;
                     currentElement = currentElement->next)
                {
                                std::string tagName(currentElement->name);
                                if(tagName == PARAM_TAG)
                                {
                                        setParameter(p, utf8Decoder, currentElement, propSetter);
                                }
                }
                propSetter.activate(p);
                filters.push_back(filter);
        }
}

/**
Used internally to parse an category or logger element.
*/
void DOMConfigurator::parseLogger(
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* loggerElement, 
                                  apr_xml_doc* doc,
                                  AppenderMap& appenders)
{
        // Create a new Logger object from the <category> element.
        LogString loggerName = subst(getAttribute(utf8Decoder, loggerElement, NAME_ATTR));

        LogLog::debug(LOG4CXX_STR("Retreiving an instance of Logger."));
        LoggerPtr logger = repository->getLogger(loggerName, loggerFactory);

        // Setting up a logger needs to be an atomic operation, in order
        // to protect potential log operations while logger
        // configuration is in progress.
        synchronized sync(logger->getMutex());
        bool additivity = OptionConverter::toBoolean(
                subst(getAttribute(utf8Decoder, loggerElement, ADDITIVITY_ATTR)),
                true);

        LogLog::debug(LOG4CXX_STR("Setting [")+logger->getName()+LOG4CXX_STR("] additivity to [")+
                (additivity ? LogString(LOG4CXX_STR("true")) : LogString(LOG4CXX_STR("false")))+LOG4CXX_STR("]."));
        logger->setAdditivity(additivity);
        parseChildrenOfLoggerElement(p, utf8Decoder, loggerElement, logger, false, doc, appenders);
}

/**
 Used internally to parse the logger factory element.
*/
void DOMConfigurator::parseLoggerFactory(
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                   apr_xml_elem* factoryElement)
{
        LogString className(subst(getAttribute(utf8Decoder, factoryElement, CLASS_ATTR)));

        if(className.empty())
        {
                LogLog::error(LOG4CXX_STR("Logger Factory tag class attribute not found."));
                LogLog::debug(LOG4CXX_STR("No Logger Factory configured."));
        }
        else
        {
                LogLog::debug(LOG4CXX_STR("Desired logger factory: [")+className+LOG4CXX_STR("]"));
                loggerFactory = OptionConverter::instantiateByClassName(
                        className,
                        LoggerFactory::getStaticClass(),
                        0);
                PropertySetter propSetter(loggerFactory);

                for (apr_xml_elem* currentElement = factoryElement->first_child;
                     currentElement;
                     currentElement = currentElement->next) {
                     std::string tagName(currentElement->name);
                     if (tagName == PARAM_TAG) {
                            setParameter(p, utf8Decoder, currentElement, propSetter);
                    }
                }
        }
}

/**
 Used internally to parse the root logger element.
*/
void DOMConfigurator::parseRoot(
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* rootElement, 
                                  apr_xml_doc* doc, 
                                  AppenderMap& appenders)
{
        LoggerPtr root = repository->getRootLogger();
        // logger configuration needs to be atomic
        synchronized sync(root->getMutex());
        parseChildrenOfLoggerElement(p, utf8Decoder, rootElement, root, true, doc, appenders);
}

/**
 Used internally to parse the children of a logger element.
*/
void DOMConfigurator::parseChildrenOfLoggerElement(
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* loggerElement, LoggerPtr logger, bool isRoot,
                                  apr_xml_doc* doc, 
                                  AppenderMap& appenders)
{

    PropertySetter propSetter(logger);

    // Remove all existing appenders from logger. They will be
    // reconstructed if need be.
    logger->removeAllAppenders();


    for (apr_xml_elem* currentElement = loggerElement->first_child;
         currentElement;
         currentElement = currentElement->next) {
                        std::string tagName(currentElement->name);

                        if (tagName == APPENDER_REF_TAG)
                        {
                                AppenderPtr appender = findAppenderByReference(p, utf8Decoder, currentElement, doc, appenders);
                                LogString refName =  subst(getAttribute(utf8Decoder, currentElement, REF_ATTR));
                                if(appender != 0)
                                {
                                        LogLog::debug(LOG4CXX_STR("Adding appender named [")+ refName+
                                        LOG4CXX_STR("] to logger [")+logger->getName()+LOG4CXX_STR("]."));
                                }
                                else
                                {
                                        LogLog::debug(LOG4CXX_STR("Appender named [")+ refName +
                                                LOG4CXX_STR("] not found."));
                                }

                                logger->addAppender(appender);

                        }
                        else if(tagName == LEVEL_TAG)
                        {
                                parseLevel(p, utf8Decoder, currentElement, logger, isRoot);
                        }
                        else if(tagName == PRIORITY_TAG)
                        {
                                parseLevel(p, utf8Decoder, currentElement, logger, isRoot);
                        }
                        else if(tagName == PARAM_TAG)
                        {
                                setParameter(p, utf8Decoder, currentElement, propSetter);
                        }
    }
    propSetter.activate(p);
}

/**
 Used internally to parse a layout element.
*/
LayoutPtr DOMConfigurator::parseLayout (
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* layout_element)
{
        LogString className(subst(getAttribute(utf8Decoder, layout_element, CLASS_ATTR)));
        LogLog::debug(LOG4CXX_STR("Parsing layout of class: \"")+className+LOG4CXX_STR("\""));
        try
        {
                ObjectPtr instance = Loader::loadClass(className).newInstance();
                LayoutPtr layout = instance;
                PropertySetter propSetter(layout);

                for(apr_xml_elem* currentElement = layout_element->first_child;
                    currentElement;
                    currentElement = currentElement->next) {
                                std::string tagName(currentElement->name);
                                if(tagName == PARAM_TAG)
                                {
                                        setParameter(p, utf8Decoder, currentElement, propSetter);
                                }
                }

                propSetter.activate(p);
                return layout;
        }
        catch (Exception& oops)
        {
                LogLog::error(LOG4CXX_STR("Could not create the Layout. Reported error follows."),
                        oops);
                return 0;
        }
}

/**
 Used internally to parse a triggering policy
*/
ObjectPtr DOMConfigurator::parseTriggeringPolicy (
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* layout_element)
{
        LogString className = subst(getAttribute(utf8Decoder, layout_element, CLASS_ATTR));
        LogLog::debug(LOG4CXX_STR("Parsing triggering policy of class: \"")+className+LOG4CXX_STR("\""));
        try
        {
                ObjectPtr instance = Loader::loadClass(className).newInstance();
                PropertySetter propSetter(instance);

                for (apr_xml_elem* currentElement = layout_element->first_child;
                     currentElement;
                     currentElement = currentElement->next) {
                                std::string tagName(currentElement->name);
                                if(tagName == PARAM_TAG)
                                {
                                        setParameter(p, utf8Decoder, currentElement, propSetter);
                                }
                                else if (tagName == FILTER_TAG) {
                                  std::vector<log4cxx::spi::FilterPtr> filters;
                                  parseFilters(p, utf8Decoder, currentElement, filters);
                                  FilterBasedTriggeringPolicyPtr fbtp(instance);
                                  if (fbtp != NULL) {
                                    for(std::vector<log4cxx::spi::FilterPtr>::iterator iter = filters.begin();
                                        iter != filters.end();
                                        iter++) {
                                        fbtp->addFilter(*iter);
                                    }
                                  }
                                }
                }

                propSetter.activate(p);
                return instance;
        }
        catch (Exception& oops)
        {
                LogLog::error(LOG4CXX_STR("Could not create the TriggeringPolicy. Reported error follows."),
                        oops);
                return 0;
        }
}

/**
 Used internally to parse a triggering policy
*/
RollingPolicyPtr DOMConfigurator::parseRollingPolicy (
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* layout_element)
{
        LogString className = subst(getAttribute(utf8Decoder, layout_element, CLASS_ATTR));
        LogLog::debug(LOG4CXX_STR("Parsing rolling policy of class: \"")+className+LOG4CXX_STR("\""));
        try
        {
                ObjectPtr instance = Loader::loadClass(className).newInstance();
                RollingPolicyPtr layout = instance;
                PropertySetter propSetter(layout);

                for(apr_xml_elem* currentElement = layout_element->first_child;
                    currentElement;
                    currentElement = currentElement->next) {
                                std::string tagName(currentElement->name);
                                if(tagName == PARAM_TAG)
                                {
                                        setParameter(p, utf8Decoder, currentElement, propSetter);
                        }
                }

                propSetter.activate(p);
                return layout;
        }
        catch (Exception& oops)
        {
                LogLog::error(LOG4CXX_STR("Could not create the RollingPolicy. Reported error follows."),
                        oops);
                return 0;
        }
}



/**
 Used internally to parse a level  element.
*/
void DOMConfigurator::parseLevel(
                                  log4cxx::helpers::Pool& p,
                                  log4cxx::helpers::CharsetDecoderPtr& utf8Decoder,                                  
                                  apr_xml_elem* element, LoggerPtr logger, bool isRoot)
{
    LogString loggerName = logger->getName();
    if(isRoot)
        {
                loggerName = LOG4CXX_STR("root");
    }

    LogString levelStr(subst(getAttribute(utf8Decoder, element, VALUE_ATTR)));
        LogLog::debug(LOG4CXX_STR("Level value for ")+loggerName+LOG4CXX_STR(" is [")+levelStr+LOG4CXX_STR("]."));

    if (StringHelper::equalsIgnoreCase(levelStr,LOG4CXX_STR("INHERITED"), LOG4CXX_STR("inherited"))
        || StringHelper::equalsIgnoreCase(levelStr, LOG4CXX_STR("NULL"), LOG4CXX_STR("null")))
        {
                if(isRoot)
                {
                        LogLog::error(LOG4CXX_STR("Root level cannot be inherited. Ignoring directive."));
                }
                else
                {
                        logger->setLevel(0);
                }
    }
        else
        {
                LogString className(subst(getAttribute(utf8Decoder, element, CLASS_ATTR)));