コード例 #1
0
void XMLConfigurator::save(XMLDocumentWrapper& xmlDoc, 
                           XMLNodeWrapperPtr& pXML,
                           const Configurator::ConfMap& confMap)
{
    Configurator conf(confMap);
    Configurator::Iterator it = conf.iterator();
    while (it.hasNext())
    {
        Configurator::KeyValuePair kv = it.next();
        
        if (kv.second.getType() == typeid(Configurator::ConfMap))
        {
            XMLNodeWrapperPtr pNode = xmlDoc.allocateNode(
                    XMLDocumentWrapper::NODE_ELEMENT, kv.first.c_str());
            save(xmlDoc, pNode, AnyCast<Configurator::ConfMap>(kv.second));
            pXML->appendNode(pNode);
        }
        else 
        {
            string str = AnyCast<string>(kv.second);
            XMLNodeWrapperPtr pNode = xmlDoc.allocateNode(
                    XMLDocumentWrapper::NODE_ELEMENT, kv.first.c_str(), str);
            pXML->appendNode(pNode);
        }
    }
}
コード例 #2
0
void XMLDocumentWrapperTestCase::testParse()
{
    std::string sXml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                       "<root>\n"
                       "\t<global>\n"
                       "\t\t<general>\n"
                       "\t\t\t<dict id=\"id_attr_value\">dict_value</dict>\n"
                       "\t\t</general>\n"
                       "\t</global>\n"
                       "</root>\n\n";
    XMLDocumentWrapper xmlDoc;
    try
    {
        xmlDoc.parse(sXml);
    }
    catch(const BadXmlFormatException& )
    {
        CPPUNIT_ASSERT(false);
    }

    XMLNodeWrapperPtr firstNode = xmlDoc.firstNode();
    CPPUNIT_ASSERT(firstNode;
    CPPUNIT_ASSERT_EQUAL(std::string("root"), std::string(firstNode->getName()));

    string sPrint;
    xmlDoc.print(sPrint);
    CPPUNIT_ASSERT_EQUAL(sXml, sPrint);
}
コード例 #3
0
void XMLConfigurator::loadFromBuffer(const string& sXML)
{
    setMode(Configurator::FROM_CONF);
    XMLDocumentWrapper xmlDoc;
    xmlDoc.parse(sXML);
    XMLNodeWrapperPtr pRoot = xmlDoc.firstNode(CONFIGURE_TAG_NAME);
    if (pRoot.isNotNull())
    {
        load(pRoot, getMap());
    }
}
コード例 #4
0
void XMLConfigurator::load(const string& sCfgFile)
{
    FIRTEX_ASSERT2(sCfgFile.empty() == false);
	
    m_sPath = sCfgFile;
    extractDir();

    XMLDocumentWrapper xmlDoc;
    xmlDoc.parseFile(sCfgFile);
    load(xmlDoc);
}
コード例 #5
0
void HTTPWatchdogService::sendPID(EvHttpRequestContext* pCtx, PIDType pid)
{
    stringstream ss;
    ss << pid;
    XMLDocumentWrapper xmlDoc;    
    xmlDoc.appendNode(XMLDocumentWrapper::NODE_ELEMENT, "pid", ss.str());
    
    ostringstream oss;
    xmlDoc.print(oss);
    pCtx->getOutBuffer()->addData(oss.str().c_str(), oss.str().length());
}
コード例 #6
0
void HTTPWatchdogService::sendProcessInfo(EvHttpRequestContext* pCtx,
        const ProcessInfoPtr& pProcInfo)
{
    XMLDocumentWrapper xmlDoc;
    XMLNodeWrapperPtr pProcNode = xmlDoc.appendNode(
            XMLDocumentWrapper::NODE_ELEMENT, "process");
    procInfoToXML(pProcNode, pProcInfo);
    stringstream ss;
    xmlDoc.print(ss);
    pCtx->getOutBuffer()->addData(ss.str().c_str(), ss.str().length());
}
コード例 #7
0
void XMLConfigurator::save(const string& sCfgFile)
{
    m_sPath = sCfgFile;
    XMLDocumentWrapper xmlDoc;
    XMLNodeWrapperPtr pRoot = xmlDoc.appendNode(
            XMLDocumentWrapper::NODE_ELEMENT, CONFIGURE_TAG_NAME);
    save(xmlDoc, pRoot, getMap());

    //TODO: UTF-8 encoding
    xmlDoc.addDeclarationNode("UTF-8");
    xmlDoc.printToFile(m_sPath);
}
コード例 #8
0
void TrecDocumentProcessorTestCase::makeAnswer(const std::string& str, Answer& ans)
{
    XMLDocumentWrapper xmlDoc;
    xmlDoc.parse(str);
    
    for (XMLNodeWrapperPtr pDocNode = xmlDoc.firstNode();
         pDocNode; pDocNode = pDocNode->nextSibling())
    {
        for (XMLNodeWrapperPtr pChildNode = pDocNode->firstNode();
             pChildNode; pChildNode = pChildNode->nextSibling())
        {
            ans.push_back(make_pair(pChildNode->getName(), pChildNode->getValue()));
        }
    }
}
コード例 #9
0
void XMLConfigurator::load(XMLDocumentWrapper& xmlDoc)
{
    setMode(Configurator::FROM_CONF);
    XMLNodeWrapperPtr pNode = xmlDoc.firstNode(CONFIGURE_TAG_NAME);
    if (pNode.isNull())
    {
        FIRTEX_THROW(InvalidConfigException, "Load xml configure FAILED: no configure element.");
    }
    load(pNode, getMap());
}
コード例 #10
0
void XMLDocumentWrapperTestCase::testPrint()
{
    XMLDocumentWrapper xmlDoc;
    xmlDoc.addDeclarationNode("UTF-8");

    xmlDoc.appendNode(XMLDocumentWrapper::NODE_ELEMENT, "root");
    XMLNodeWrapperPtr pRoot = xmlDoc.firstNode();
    pRoot->appendNode(XMLDocumentWrapper::NODE_ELEMENT, "global", "testvalue");
    pRoot->appendAttribute("id", "testid");
        
    ostringstream ss;
    xmlDoc.print(ss);

    string sExpect = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                     "<root id=\"testid\">\n"
                     "\t<global>testvalue</global>\n"
                     "</root>\n\n";
    CPPUNIT_ASSERT_EQUAL(sExpect, ss.str());
}
コード例 #11
0
void XMLDocumentWrapperTestCase::testClearAndReuse()
{
    XMLDocumentWrapper xmlDoc;

    string sExpect = "<result>\n"
                     "\t<hits number_hits=\"1\">\n"
                     "\t\t<hit>hit_value1</hit>\n"
                     "\t</hits>\n"
                     "\t<hits number_hits=\"2\">\n"
                     "\t\t<hit>hit_value2</hit>\n"
                     "\t</hits>\n"
                     "</result>\n\n";
                 
    for (size_t i = 0; i < 2; ++i)
    {
        XMLNodeWrapperPtr pRootNode = xmlDoc.appendNode(
                XMLDocumentWrapper::NODE_ELEMENT, "result");

        XMLNodeWrapperPtr pHitsNode = pRootNode->appendNode(
            XMLDocumentWrapper::NODE_ELEMENT, "hits");
        pHitsNode->appendAttribute("number_hits", "1");
        pHitsNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
                              "hit", "hit_value1");
        
        pHitsNode = pRootNode->appendNode(
                XMLDocumentWrapper::NODE_ELEMENT, "hits");
        pHitsNode->appendAttribute("number_hits", "2");
        pHitsNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
                              "hit", "hit_value2");

        ostringstream ss;
        xmlDoc.print(ss);
        CPPUNIT_ASSERT_EQUAL(sExpect, ss.str());

        xmlDoc.clear();
    }
}
コード例 #12
0
void XMLConfigurator::save(const string& sCfgFile, FileSystemPtr& pFileSys)
{
    XMLDocumentWrapper xmlDoc;
    XMLNodeWrapperPtr pRoot = xmlDoc.appendNode(
            XMLDocumentWrapper::NODE_ELEMENT, CONFIGURE_TAG_NAME);
    Iterator it = iterator();
    while (it.hasNext())
    {
        Configurator::KeyValuePair kv = it.next();

        if (kv.second.getType() == typeid(Configurator::ConfMap))
        {
            XMLNodeWrapperPtr pNode = xmlDoc.allocateNode(
                    XMLDocumentWrapper::NODE_ELEMENT, kv.first.c_str());
            save(xmlDoc, pNode, AnyCast<Configurator::ConfMap>(kv.second));
            pRoot->appendNode(pNode);
        }
        else 
        {
            string str = AnyCast<string>(kv.second);
            XMLNodeWrapperPtr pNode = xmlDoc.allocateNode(
                    XMLDocumentWrapper::NODE_ELEMENT, kv.first.c_str(), str);
            pRoot->appendNode(pNode);
        }
    }

    OutputStreamPtr pOutStream = pFileSys->createFile(sCfgFile);
    if (pOutStream.isNull())
    {
        FIRTEX_THROW(FileIOException, "Save configure [%s] FAILED ",
                     sCfgFile.c_str());
    }
    string str;
    xmlDoc.addDeclarationNode("UTF-8");
    xmlDoc.print(str);
    pOutStream->write((const void*)str.c_str(), str.length());
}
コード例 #13
0
bool HTTPWatchdogService::commandToTask(EvHttpRequestContext* pCtx,
                                        ExecutionTask& task, 
                                        int32_t& stopSignal)
{
    string sContent;
    if (pCtx->getMethodType() == EVHTTP_REQ_GET)
    {
        sContent = pCtx->getQuery();
        KeyValueParser kvParser;
        if (!kvParser.parse(sContent, "&", "="))
        {
            stringstream ss;
            ss << "Invalid request: [" << sContent << "]";
            sendErrorMsg(pCtx, ss.str(), HTTPTypes::RESPONSE_CODE_BAD_REQUEST);
            return false;
        }
        string sValue;
        if (kvParser.getValue("process_name", sValue))
        {
            task.command.processName = sValue;
        }
        if (kvParser.getValue("parameters", sValue))
        {
            StringTokenizer st(sValue, ",", StringTokenizer::TOKEN_TRIM
                    | StringTokenizer::TOKEN_IGNORE_EMPTY);
            task.command.parameters.assign(st.begin(), st.end());
        }
        return true;
    }
    else // POST/PUT/DELETE
    {
        const char* p = (const char*)(pCtx->getInBuffer()->getData());
        if (!p || !*p)
        {
            sendErrorMsg(pCtx, "Request missing content", 
                        HTTPTypes::RESPONSE_CODE_BAD_REQUEST);
            return false;
        }

        XMLDocumentWrapper xmlDoc;
        try
        {
            string str(p, pCtx->getInBuffer()->getLength());
            xmlDoc.parse(str);
        }
        catch(const FirteXException& ex)
        {
            sendErrorMsg(pCtx, ex.what(), HTTPTypes::RESPONSE_CODE_BAD_REQUEST);
            return false;
        }

        XMLNodeWrapperPtr pRootNode = xmlDoc.firstNode("process");
        if (pRootNode.isNull())
        {
            sendErrorMsg(pCtx, "Missing process info", 
                        HTTPTypes::RESPONSE_CODE_BAD_REQUEST);
            return false;
        }
            
        EXTRACT_NODE_STRING2(pRootNode, "process_name", 
                             task.command.processName);
        if (task.command.processName.empty())
        {
            sendErrorMsg(pCtx, "Missing process name", 
                        HTTPTypes::RESPONSE_CODE_BAD_REQUEST);
            return false;
        }
            
        XMLNodeWrapperPtr pParamRootNode = pRootNode->firstNode("parameters");
        if (pParamRootNode.isNotNull())
        {
            for (XMLNodeWrapperPtr pParamNode = pParamRootNode->firstNode("parameter");
                 pParamNode.isNotNull(); pParamNode = pParamNode->nextSibling())
            {
                string str;
                EXTRACT_NODE_STRING(pParamNode, str);
                task.command.parameters.push_back(str);
            }
        }

        XMLNodeWrapperPtr pEnvNode = pRootNode->firstNode("environment");
        if (pEnvNode.isNotNull())
        {
            for (XMLNodeWrapperPtr pValueNode = pEnvNode->firstNode("value");
                 pValueNode.isNotNull(); pValueNode = pValueNode->nextSibling())
            {
                XMLAttributeWrapperPtr pNameAttr = pValueNode->firstAttribute("name");
                XMLNodeWrapperPtr pDataNode = pValueNode->firstNode();
                task.envVariables.insert(make_pair(pNameAttr->getValue(), 
                                pDataNode->getValue()));
            }
        }

        XMLNodeWrapperPtr pProcInfoKeepTimeNode = 
            pRootNode->firstNode("process_info_keep_time");
        if (pProcInfoKeepTimeNode.isNotNull())
        {
            task.processInfoKeepTime = NumberParser::parseInt32(
                    pProcInfoKeepTimeNode->getValue());
        }

        XMLNodeWrapperPtr pStopSignalNode = pRootNode->firstNode("stop_signal");
        if (pStopSignalNode.isNotNull())
        {
            stopSignal = NumberParser::parseInt32(pStopSignalNode->getValue());
        }
            
        EXTRACT_NODE_STRING2(pRootNode, "work_directory", task.workDirectory);

        XMLNodeWrapperPtr pRestartAfterCrash = pRootNode->firstNode("restart_after_crash");
        if (pRestartAfterCrash.isNotNull())
        {
            if (!strCompareNoCase(pRestartAfterCrash->getValue(), "true"))
            {
                task.restartAfterCrash = true;
            }
            else
            {
                task.restartAfterCrash = false;
            }
        }
        return true;
    } //end else // POST/PUT/DELETE
}