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::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 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 XMLResultFormatter::formatTracer(XMLNodeWrapperPtr& pTraceRootNode,
const QueryTracerPtr& pTracer)
{
XMLNodeWrapperPtr pTraceNode = pTraceRootNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "tracer");
pTraceNode->appendAttribute("path", pTracer->getPath());
pTraceNode->appendAttribute("level",
LoggingLevel::levelToStr(pTracer->getLevel()));
const QueryTracer::TraceInfo& traceInfo = pTracer->getTraceInfo();
for (size_t i = 0; i < traceInfo.size(); ++i)
{
XMLNodeWrapperPtr pCDataNode = pTraceNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "message");
pCDataNode->appendNode(XMLDocumentWrapper::NODE_CDATA,
"", traceInfo[i]);
}
const QueryTracer::TracerVector& tracers = pTracer->getChildTracers();
for (size_t i = 0; i < tracers.size(); ++i)
{
const QueryTracerPtr& pChildTracer = tracers[i];
if (pChildTracer)
{
formatTracer(pTraceNode, pChildTracer);
}
}
}
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 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());
}
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 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::load(XMLNodeWrapperPtr& pNode, Configurator::ConfMap& conf)
{
XMLNodeWrapperPtr pChild = pNode->firstNode();
if (pChild.isNull())
{
Configurator c(conf, Configurator::TO_CONF);
string sValue = pNode->getValue();
c.configure((const string&)pNode->getName(),
sValue, (const string&)_T(""));
conf = c.getMap();
}
else if (pChild->nextSibling().isNull()
&& pChild->type() == XMLDocumentWrapper::NODE_DATA)
{
Configurator c(conf, Configurator::TO_CONF);
string sValue = pChild->getValue();
c.configure((const string&)pNode->getName(),
sValue, (const string&)_T(""));
conf = c.getMap();
}
else
{
Configurator::ConfMap confMap;
for (XMLNodeWrapperPtr pSubNode = pNode->firstNode();
pSubNode.isNotNull(); pSubNode = pSubNode->nextSibling())
{
load(pSubNode, confMap);
}
if (strCompareNoCase(pNode->getName(), CONFIGURE_TAG_NAME))
{
Configurator c(conf, Configurator::TO_CONF);
c.configure(pNode->getName(), confMap);
conf = c.getMap();
}
else
{
conf = confMap;
}
}
}
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
}
void XMLResultFormatter::format(const QueryResult& result,
std::stringstream& ss)
{
m_xmlDoc.clear();
m_xmlDoc.addDeclarationNode(result.getEncoding());
XMLNodeWrapperPtr pRootNode = m_xmlDoc.appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "result");
if (result.hasError())
{
formatError(pRootNode, result.getErrorMsg());
}
else
{
XMLNodeWrapperPtr resultNode = pRootNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "hits");
string str;
NumberFormatter::append(str, (int32_t)result.size());
resultNode->appendAttribute("number_hits", str);
str.clear();
NumberFormatter::append(str, result.getTotalHits());
resultNode->appendAttribute("total_hits", str);
str.clear();
NumberFormatter::append(str, result.getTimeCost());
resultNode->appendAttribute("cost", str);
QueryResult::Iterator it = result.iterator();
while (it.hasNext())
{
XMLNodeWrapperPtr pHitNode = resultNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "hit");
const ResultDocPtr& pResDoc = it.next();
if (result.hasShardId())
{
str.clear();
NumberFormatter::append(str, pResDoc->getShardId());
pHitNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
"shardid", str);
}
if (result.hasDocId())
{
str.clear();
NumberFormatter::append(str, pResDoc->getDocId());
pHitNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
"docid", str);
}
if (result.hasScore())
{
str.clear();
NumberFormatter::append(str, pResDoc->getScore(), 2);
pHitNode->appendNode(XMLDocumentWrapper::NODE_ELEMENT,
"score", str);
}
if (result.hasFields())
{
XMLNodeWrapperPtr pFieldsNode = pHitNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "fields");
ResultDoc::Iterator fieldIt = pResDoc->iterator();
while (fieldIt.hasNext())
{
const ResultDoc::Field& field = fieldIt.next();
XMLNodeWrapperPtr pCDataNode = pFieldsNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, field.first);
pCDataNode->appendNode(XMLDocumentWrapper::NODE_CDATA,
"", field.second);
}
}
} // end while
const QueryTracerPtr& pTracer = result.getTracer();
if (pTracer)
{
formatTracer(pRootNode, pTracer);
}
}
m_xmlDoc.print(ss);
}
void XMLResultFormatter::formatError(XMLNodeWrapperPtr& pRootNode, const string& sErrorMsg)
{
XMLNodeWrapperPtr pErrorNode = pRootNode->appendNode(
XMLDocumentWrapper::NODE_ELEMENT, "error");
pErrorNode->appendNode(XMLDocumentWrapper::NODE_CDATA, "", sErrorMsg);
}