WsWuInfo::WsWuInfo(const char *wuid_, const char *qset, const char *qname, const char *user, const char *pw) :
wuid(wuid_), qsetname(qset), queryname(qname), username(user), password(pw)
{
Owned<IWorkUnitFactory> wf = getWorkUnitFactory();
if (!wuid.length() && qsetname.length() && queryname.length())
{
Owned<IPropertyTree> qstree = getQueryRegistry(qsetname.sget(), true);
if (qstree)
{
VStringBuffer xpath("Query[@id=\"%s\"]", queryname.sget());
IPropertyTree *query = qstree->queryPropTree(xpath.str());
if (query)
wuid.set(query->queryProp("@wuid"));
else
throw MakeStringException(-1, "Query %s not found in QuerySet %s", queryname.sget(), qsetname.sget());
}
else
throw MakeStringException(-1, "QuerySet %s not found", qsetname.sget());
}
if (wuid.length())
{
wu.setown(wf->openWorkUnit(wuid.sget(), false));
if (!wu)
throw MakeStringException(-1, "Could not open workunit: %s", wuid.sget());
}
else
throw MakeStringException(-1, "Workunit not specified");
}
void scheduleWorkUnit(char const * wuid, ISecManager & secmgr, ISecUser & secuser)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IWorkUnit> wu = factory->updateWorkUnit(wuid, &secmgr, &secuser);
if(wu)
wu->schedule();
}
void descheduleWorkUnit(char const * wuid)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IWorkUnit> wu = factory->updateWorkUnit(wuid);
if(wu)
wu->deschedule();
}
static IConstWorkUnit * getWorkunit(ICodeContext * ctx)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
StringAttr wuid;
wuid.setown(ctx->getWuid());
return factory->openWorkUnit(wuid, false);
}
bool WuResubmit(const char *wuid)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IWorkUnit> wu = factory->updateWorkUnit(wuid);
if (!wu)
{
ERRLOG("WuResubmit(%s): could not find workunit",wuid);
return false;
}
if (wu->getState()!=WUStateFailed)
{
ERRLOG("WuResubmit(%s): could not resubmit as workunit state is '%s'", wuid, wu->queryStateDesc());
return false;
}
SCMStringBuffer token;
wu->getSecurityToken(token);
SCMStringBuffer user;
SCMStringBuffer password;
extractToken(token.str(), wuid, user, password);
wu->resetWorkflow();
wu->setState(WUStateSubmitted);
wu->commit();
wu.clear();
submitWorkUnit(wuid,user.str(),password.str());
PROGLOG("WuResubmit(%s): resubmitted",wuid);
return true;
}
bool QueryDataSource::loadBlock(__int64 startRow, offset_t startOffset)
{
MemoryBuffer temp;
//enter scope....>
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IWorkUnit> wu = factory->updateWorkUnit(browseWuid);
Owned<IWUResult> lower = wu->updateVariableByName(LOWER_LIMIT_ID);
lower->setResultInt(startOffset);
lower->setResultStatus(ResultStatusSupplied);
Owned<IWUResult> dataResult = wu->updateResultBySequence(0);
dataResult->setResultRaw(0, NULL, ResultFormatRaw);
dataResult->setResultStatus(ResultStatusUndefined);
wu->clearExceptions();
if (wu->getState() != WUStateUnknown)
wu->setState(WUStateCompiled);
//Owned<IWUResult> count = wu->updateVariableByName(RECORD_LIMIT_ID);
//count->setResultInt64(fetchSize);
}
//Resubmit the query...
submitWorkUnit(browseWuid, username, password);
WUState finalState = waitForWorkUnitToComplete(browseWuid, -1, true);
if(!((finalState == WUStateCompleted) || (finalState == WUStateWait)))
return false;
//Now extract the results...
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IConstWorkUnit> wu = factory->openWorkUnit(browseWuid, false);
Owned<IConstWUResult> dataResult = wu->getResultBySequence(0);
MemoryBuffer2IDataVal xxx(temp);
dataResult->getResultRaw(xxx, NULL, NULL);
if (temp.length() == 0)
return false;
RowBlock * rows;
if (returnedMeta->isFixedSize())
rows = new FilePosFixedRowBlock(temp, startRow, startOffset, returnedMeta->fixedSize());
else
rows = new FilePosVariableRowBlock(temp, startRow, startOffset, returnedMeta, true);
cache.addRowsOwn(rows);
return true;
}
QueryDataSource::~QueryDataSource()
{
if (browseWuid)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
factory->deleteWorkUnit(browseWuid);
}
}
IConstWorkUnit *getWorkUnit(const char *wuid)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
IConstWorkUnit *workunit = factory->openWorkUnit(wuid, false);
if (!workunit)
throw MakeStringException(ROXIEMANAGER_MISSING_ID, "Unknown workunit id %s", wuid);
return workunit;
}
bool QueryDataSource::createBrowseWU()
{
StringAttr dataset, datasetDefs;
StringAttrAdaptor a1(dataset), a2(datasetDefs);
wuResult->getResultDataset(a1, a2);
if (!dataset || !datasetDefs)
return false;
StringBuffer fullText;
fullText.append(datasetDefs).append(dataset);
OwnedHqlExpr parsed = parseQuery(fullText.str());
if (!parsed)
return false;
HqlExprAttr selectFields = parsed.getLink();
if (selectFields->getOperator() == no_output)
selectFields.set(selectFields->queryChild(0));
OwnedHqlExpr browseWUcode = buildQueryViewerEcl(selectFields);
if (!browseWUcode)
return false;
returnedRecord.set(browseWUcode->queryChild(0)->queryRecord());
StringAttr tempAttr;
StringAttrAdaptor temp(tempAttr);
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IConstWorkUnit> parent = factory->openWorkUnit(wuid, false);
SCMStringBuffer user;
StringAttrAdaptor acluster(cluster);
parent->getClusterName(acluster);
parent->getUser(user);
Owned<IWorkUnit> workunit = factory->createWorkUnit(NULL, "fileViewer", user.str());
workunit->setUser(user.str());
workunit->setClusterName(cluster);
workunit->setCustomerId(parent->getCustomerId(temp).str());
workunit->setCompareMode(CompareModeOff); // ? parent->getCompareMode()
StringAttrAdaptor bwa(browseWuid); workunit->getWuid(bwa);
workunit->setDebugValueInt("importImplicitModules", false, true);
workunit->setDebugValueInt("importAllModules", false, true);
workunit->setDebugValueInt("forceFakeThor", 1, true);
StringBuffer jobName;
jobName.append("FileView for ").append(wuid).append(":").append("x");
workunit->setJobName(jobName.str());
StringBuffer eclText;
toECL(browseWUcode, eclText, true);
Owned<IWUQuery> query = workunit->updateQuery();
query->setQueryText(eclText.str());
query->setQueryName(jobName.str());
return true;
}
IConstWorkUnit *WsEclWuInfo::ensureWorkUnit()
{
if (!wuid.length())
ensureWuid();
if (wu)
return wu;
Owned<IWorkUnitFactory> wf = getWorkUnitFactory();
wu.setown(wf->openWorkUnit(wuid.sget(), false));
if (!wu)
throw MakeStringException(-1, "Could not open workunit: %s", wuid.sget());
if (isLibrary(wu))
throw MakeStringException(-1, "%s/%s %s is a library", qsetname.sget(), queryname.sget(), wuid.sget());
return wu;
}
static IWorkUnitFactory * getWorkunitFactory(ICodeContext * ctx)
{
IEngineContext *engineCtx = ctx->queryEngineContext();
if (engineCtx && !engineCtx->allowDaliAccess())
{
Owned<IException> e = MakeStringException(-1, "workunitservices cannot access Dali in this context - this normally means it is being called from a thor slave");
EXCLOG(e, NULL);
throw e.getClear();
}
//MORE: These should really be set up correctly - probably should be returned from IEngineContext
ISecManager *secmgr = NULL;
ISecUser *secuser = NULL;
return getWorkUnitFactory(secmgr, secuser);
}
int CEclAgentExecutionServer::executeWorkunit(const char * wuid)
{
//build eclagent command line
StringBuffer command;
#ifdef _WIN32
command.append(".\\eclagent.exe");
#else
command.append("start_eclagent");
#endif
StringBuffer cmdLine = command;
cmdLine.append(" WUID=").append(wuid).append(" DALISERVERS=").append(daliServers);
DWORD runcode;
PROGLOG("AgentExec: Executing '%s'", cmdLine.str());
#ifdef _WIN32
bool success = invoke_program(cmdLine.str(), runcode, false, NULL, NULL);
#else
//specify "wait" to eliminate linux zombies. Waits for the startup script to
//complete (not eclagent), because script starts eclagent in the background
bool success = invoke_program(cmdLine.str(), runcode, true, NULL, NULL);
#endif
if (success)
{
if (runcode != 0)
PROGLOG("Process failed during execution: %s error(%"I64F"i)", cmdLine.str(), (unsigned __int64) runcode);
else
PROGLOG("Execution started");
}
else
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
Owned<IWorkUnit> workunit = factory->updateWorkUnit(wuid);
if (workunit)
{
workunit->setState(WUStateFailed);
workunit->commit();
}
PROGLOG("Process failed to start: %s", cmdLine.str());
}
return success && runcode == 0;
}
static IWorkUnit * updateWorkunit(ICodeContext * ctx)
{
// following bit of a kludge, as
// 1) eclagent keeps WU locked, and
// 2) rtti not available in generated .so's to convert to IAgentContext
IAgentContext * actx = dynamic_cast<IAgentContext *>(ctx);
if (actx == NULL) { // fall back to pure ICodeContext
// the following works for thor only
char * platform = ctx->getPlatform();
if (strcmp(platform,"thor")==0) {
CTXFREE(parentCtx, platform);
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
StringAttr wuid;
wuid.setown(ctx->getWuid());
return factory->updateWorkUnit(wuid);
}
CTXFREE(parentCtx, platform);
return NULL;
}
return actx->updateWorkUnit();
}
void descheduleAllWorkUnits(ISecManager & secmgr, ISecUser & secuser)
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
factory->descheduleAllWorkUnits(&secmgr, &secuser);
}
bool CEclDirectEx::onRunEclEx(IEspContext &context, IEspRunEclExRequest & req, IEspRunEclExResponse & resp)
{
if (!context.validateFeatureAccess(ECLDIRECT_ACCESS, SecAccess_Full, false))
throw MakeStringException(-1, "EclDirect access permission denied.");
const char* eclText = req.getEclText();
if (!eclText || !*eclText)
{
resp.setResults("<Exception><Source>ESP</Source><Message>No Ecl Text provided</Message></Exception>");
return true;
}
StringBuffer user;
if (!context.getUserID(user).length())
user.append(req.getUserName());
Owned <IWorkUnitFactory> factory = getWorkUnitFactory(context.querySecManager(), context.queryUser());
Owned <IWorkUnit> workunit;
if (!user.length())
workunit.setown(factory->createWorkUnit(NULL, "ECL-Direct", ""));
else
{
workunit.setown(factory->createWorkUnit(NULL, "ECL-Direct", user.str()));
workunit->setUser(user.str());
}
Owned<IWUQuery> query = workunit->updateQuery();
query->setQueryText(eclText);
query.clear();
const char* cluster = req.getCluster();
if (!cluster || !*cluster || !stricmp(cluster, "default"))
cluster = defaultCluster.str();
if (!cluster || !*cluster)
throw MakeStringException(-1, "No Cluster Specified");
if (!isValidCluster(cluster))
throw MakeStringException(-1, "Invalid TargetCluster %s Specified", cluster);
workunit->setClusterName(cluster);
const char* snapshot = req.getSnapshot();
if (snapshot && *snapshot)
workunit->setSnapshot(snapshot);
if (req.getResultLimit())
workunit->setResultLimit(req.getResultLimit());
// Execute it
SCMStringBuffer wuid;
workunit->getWuid(wuid);
workunit->setAction(WUActionRun);
workunit->setState(WUStateSubmitted);
workunit.clear();
resp.setWuid(wuid.str());
submitWorkUnit(wuid.str(), context.querySecManager(), context.queryUser());
if (!waitForWorkUnitToComplete(wuid.str(), (req.getWait_isNull()) ? defaultWait : req.getWait()))
{
StringBuffer result;
result.appendf("<Exception><Source>ESP</Source><Message>Timed out waiting for job to complete: %s</Message></Exception>", wuid.str());
resp.setResults(result.str());
return true;
}
if (!deleteWorkunits && context.queryRequestParameters()->hasProp("redirect"))
{
StringBuffer url("/WsWorkunits/WUInfo?Wuid=");
resp.setRedirectUrl(url.append(wuid).str());
return true;
}
Owned<IConstWorkUnit> cw = factory->openWorkUnit(wuid.str(), false);
EclDirectWUExceptions errors(*cw);
resp.setErrors(errors);
if (req.getIncludeResults())
{
StringBuffer results;
CRunEclExFormat outputFormat = req.getFormat();
Owned<IWuWebView> web = createWuWebView(wuid.str(), NULL, NULL, getCFD(), true);
if (!web)
results.appendf("<Exception><Source>ESP</Source><Message>Failed loading result workunit %s</Message></Exception>", wuid.str());
else if (outputFormat == CRunEclExFormat_Table)
{
StringBuffer xsltfile(getCFD());
web->applyResultsXSLT(xsltfile.append("xslt/wsecl3_result.xslt").str(), results);
}
else
{
unsigned xmlflags = 0;
if (outputFormat != CRunEclExFormat_ExtendedXml)
xmlflags |= WWV_OMIT_SCHEMAS;
if (context.queryRequestParameters()->hasProp("display_xslt"))
xmlflags |= WWV_USE_DISPLAY_XSLT;
else
xmlflags |= WWV_OMIT_XML_DECLARATION;
web->expandResults(results, xmlflags);
}
resp.setResults(results.str());
}
if (req.getIncludeGraphs())
{
Owned<IConstWUGraphIterator> it = &cw->getGraphs(GraphTypeAny);
StringBuffer xgmml("<Graphs>");
SCMStringBuffer s;
ForEach(*it)
xgmml.append(it->query().getXGMML(s, true).str());
xgmml.append("</Graphs>");
resp.setGraphsXGMML(xgmml.str());
}
if (deleteWorkunits)
deleteEclDirectWorkunit(factory, wuid.str());
return true;
}
bool CEclDirectEx::onRunEcl(IEspContext &context, IEspRunEclRequest & req, IEspRunEclResponse & resp)
{
if (!context.validateFeatureAccess(ECLDIRECT_ACCESS, SecAccess_Full, false))
throw MakeStringException(-1, "EclDirect access permission denied.");
StringBuffer user;
if (!context.getUserID(user).length())
user.append(req.getUserName());
Owned <IWorkUnitFactory> factory = getWorkUnitFactory(context.querySecManager(), context.queryUser());
Owned <IWorkUnit> workunit;
if (!user.length())
workunit.setown(factory->createWorkUnit(NULL, "ECL-Direct", ""));
else
{
workunit.setown(factory->createWorkUnit(NULL, "ECL-Direct", user.str()));
workunit->setUser(user.str());
}
Owned<IWUQuery> query = workunit->updateQuery();
query->setQueryText(req.getEclText());
query.clear();
const char* clustername = req.getCluster();
if (!clustername || !*clustername || strieq(clustername, "default"))
clustername = defaultCluster.str();
if (!clustername || !*clustername)
throw MakeStringException(-1, "No Cluster Specified");
if (!isValidCluster(clustername))
throw MakeStringException(-1, "Invalid TargetCluster %s Specified", clustername);
workunit->setClusterName(clustername);
if (req.getLimitResults())
workunit->setResultLimit(100);
const char* snapshot = req.getSnapshot();
if (snapshot && *snapshot)
workunit->setSnapshot(snapshot);
// Execute it
SCMStringBuffer wuid;
workunit->getWuid(wuid);
workunit->setAction(WUActionRun);
workunit->setState(WUStateSubmitted);
workunit.clear();
submitWorkUnit(wuid.str(), context.querySecManager(), context.queryUser());
if (waitForWorkUnitToComplete(wuid.str(), defaultWait))
{
Owned<IConstWorkUnit> cw = factory->openWorkUnit(wuid.str(), false);
SCMStringBuffer resultXML;
getFullWorkUnitResultsXML(context.queryUserId(), context.queryPassword(), cw.get(), resultXML);
resp.setResults(resultXML.str());
cw.clear();
if (deleteWorkunits)
deleteEclDirectWorkunit(factory, wuid.str());
}
else
{
// Don't delete these ones...
DBGLOG("WorkUnit %s timed out", wuid.str());
StringBuffer result;
result.appendf("<Exception><Source>ESP</Source><Message>Timed out waiting for job to complete: %s</Message></Exception>", wuid.str());
resp.setResults(result.str());
}
return true;
}
CWUWrapper(const char * app, const char * user, IEspContext &context):
factory(getWorkUnitFactory()), wu(factory->createWorkUnit(app, user, context.querySecManager(), context.queryUser()))
{
if(!wu)
throw MakeStringException(ECLWATCH_CANNOT_CREATE_WORKUNIT,"Could not create workunit.");
}
CWUWrapper(const char* wuid): factory(getWorkUnitFactory()), wu(factory->openWorkUnit(wuid, false))
{
if(!wu)
throw MakeStringException(ECLWATCH_CANNOT_OPEN_WORKUNIT,"Could not open workunit %s",wuid);
}
CWUWrapper(const char* wuid, IEspContext &context):
factory(getWorkUnitFactory()), wu(factory->openWorkUnit(wuid, false, context.querySecManager(), context.queryUser()))
{
if(!wu)
throw MakeStringException(ECLWATCH_CANNOT_OPEN_WORKUNIT,"Could not open workunit %s",wuid);
}
void descheduleAllWorkUnits()
{
Owned<IWorkUnitFactory> factory = getWorkUnitFactory();
factory->descheduleAllWorkUnits();
}
