void StandardStopFilter::setParam(const tstring& sParam)
{
KeyValueParser parser;
if (parser.parse(sParam, TokenFilter::PARAM_SEPERATOR,
TokenFilter::EQUAL_MARK))
{
size_t nWords = 0;
string sValue;
if (parser.getValue("words", sValue))
{
nWords = loadWords(sValue);
}
else if (parser.getValue("file", sValue))
{
nWords = loadFile(sValue);
}
else
{
return ;
}
if (nWords == 0)
{
FX_LOG(ERROR, "Load stop words: [%s] FAILED.",
sValue.c_str());
}
else
{
FX_LOG(INFO, "Loaded [%u] stop words.", (uint32_t)nWords);
}
}
}
void FormulaScorer::setParameter(const std::string& sParam)
{
KeyValueParser kvParser;
if (!kvParser.parse(sParam, ",", "="))
{
FX_LOG(ERROR, "Parse formula parameter : [%s] FAILED", sParam.c_str());
return;
}
if (!kvParser.getValue("formula", m_sFormula))
{
FX_LOG(ERROR, "Extract formula from [%s] FAILED", sParam.c_str());
return;
}
}
void StandardAnalyzer::setParam(const tstring& sParam)
{
KeyValueParser kvParser;
bool ret = kvParser.parse(sParam, ";", "=");
if (!ret)
{
FX_LOG(ERROR, "Invalid analyzer parameter: [%s]",
sParam.c_str());
}
else
{
tstring sValue;
if (kvParser.getValue(PARAM_ALGORITHM, sValue))
{
if (!strCompareNoCase(sValue.c_str(), "max_forward"))
{
m_eSegAlgorithm = SA_MAX_FORWARD;
}
else if (!strCompareNoCase(sValue.c_str(), "unigram"))
{
m_eSegAlgorithm = SA_UNIGRAM;
}
else
{
FX_LOG(ERROR, "Invalid parameter: [algorithm=%s]",
sValue.c_str());
m_eSegAlgorithm = SA_MAX_FORWARD;
}
}
if (kvParser.getValue(PARAM_ENCODE, sValue))
{
if ((!strCompareNoCase(sValue.c_str(), "utf-8"))
|| (!strCompareNoCase(sValue.c_str(), "gbk"))
|| (!strCompareNoCase(sValue.c_str(), "gb2312")))
{
m_sEncodeName = toLower(sValue);
}
else
{
FX_LOG(ERROR, "Invalid parameter: [encode=%s], "
"using default [encode=utf-8]",
sValue.c_str());
m_sEncodeName = toLower(sValue);
}
}
}
}
void ScorerProfileClause::fromString(const string& sClauseValue)
{
string sKey, sValue, sSkipBlock;
Clause::parseClauseValue(sKey, sValue, sSkipBlock, sClauseValue, 0);
m_sProfileName = sKey;
if (!sSkipBlock.empty())
{
KeyValueParser kvParser;
if (!kvParser.parse(sSkipBlock, ",", "="))
{
FX_LOG(ERROR, "Parse scorer_profile parameter FAILED: [%s]",
sSkipBlock.c_str());
}
for (size_t i = 0; i < kvParser.getKVCount(); ++i)
{
string k, v;
if (kvParser.getKeyValue(i, k, v))
{
m_parameters.insert(make_pair(k, v));
}
}
}
}
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
}
