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);
}
}
}
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);
}
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());
}
}
void XMLConfigurator::load(const string& sCfgFile)
{
FIRTEX_ASSERT2(sCfgFile.empty() == false);
m_sPath = sCfgFile;
extractDir();
XMLDocumentWrapper xmlDoc;
xmlDoc.parseFile(sCfgFile);
load(xmlDoc);
}
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());
}
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());
}
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);
}
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()));
}
}
}
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());
}
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());
}
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();
}
}
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());
}
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
}