void SWProcess::addInstances(IPropertyTree *parent, IPropertyTree *params)
{
IPropertyTree* pAttrs = params->queryPropTree("Attributes");
if (!pAttrs)
throw MakeStringException(CfgEnvErrorCode::InvalidParams, "Miss instance attributes input");
const char * instanceXMLTagName = getInstanceXMLTagName(params->queryProp("@selector"));
Owned<IPropertyTreeIterator> iter = pAttrs->getElements("Attribute");
ForEach (*iter)
{
IPropertyTree *attr = &iter->query();
const char* propName = attr->queryProp("@name");
if (!stricmp(propName, "ip") || !stricmp(propName, "ipfile"))
{
bool isFile = false;
if (!stricmp(propName, "ipfile")) isFile = true;
StringArray ips;
m_envHelper->processNodeAddress(attr->queryProp("@value"), ips, isFile);
for ( unsigned i = 0; i < ips.ordinality() ; i++)
{
IPropertyTree * computerNode = addComputer(ips.item(i));
addInstance(computerNode, parent, pAttrs, instanceXMLTagName);
}
}
}
}
void SWDirectories::modify(IPropertyTree *params)
{
synchronized block(mutex);
IPropertyTree * envTree = m_envHelper->getEnvTree();
IPropertyTree * pAttrsTree = params->queryPropTree("Attributes");
//Todo: if name attribute given in @selector
//const char* selector = params->queryProp("@selector");
const char* selectorKey = params->queryProp("@selector-key");
if (selectorKey)
{
const char* dirPath = pAttrsTree->queryProp("Attribute[1]/@value");
setCategoryAttributes(envTree, selectorKey, dirPath);
}
else
{
Owned<IPropertyTreeIterator> attrsIter = pAttrsTree->getElements("Attribute");
ForEach(*attrsIter)
{
IPropertyTree* pAttrTree = &attrsIter->query();
const char* dirName = pAttrTree->queryProp("@name");
const char* dirPath = pAttrTree->queryProp("@value");
setCategoryAttributes(envTree, dirName, dirPath);
}
}
//query id
}
void SWProcess::computerUpdated(IPropertyTree *computerNode, const char* oldName,
const char* oldIp, const char* instanceXMLTagName)
{
IPropertyTree *software = m_envHelper->getEnvTree()->queryPropTree("Software");
Owned<IPropertyTreeIterator> compIter = software->getElements(m_processName);
const char *instance = (instanceXMLTagName)? instanceXMLTagName: m_instanceElemName.str();
synchronized block(mutex);
ForEach (*compIter)
{
IPropertyTree *comp = &compIter->query();
Owned<IPropertyTreeIterator> instanceIter = comp->getElements(instance);
ForEach (*instanceIter)
{
IPropertyTree *instance = &instanceIter->query();
if (instance->hasProp(XML_ATTR_NAME) && !stricmp(instance->queryProp(XML_ATTR_NAME), oldName))
{
if (stricmp(computerNode->queryProp(XML_ATTR_NAME), instance->queryProp(XML_ATTR_NAME)))
instance->setProp(XML_ATTR_NAME, computerNode->queryProp(XML_ATTR_NAME));
if (instance->hasProp(m_ipAttribute.str()) && stricmp(computerNode->queryProp(XML_ATTR_NETADDRESS), instance->queryProp(m_ipAttribute.str())))
instance->setProp(m_ipAttribute.str(), computerNode->queryProp(XML_ATTR_NETADDRESS));
if (instance->hasProp("@computer") && stricmp(computerNode->queryProp(XML_ATTR_NAME), instance->queryProp("@computer")))
instance->setProp("@computer", computerNode->queryProp(XML_ATTR_NAME));
}
else if (instance->hasProp(m_ipAttribute.str()) && !stricmp(instance->queryProp(m_ipAttribute.str()), oldIp))
{
instance->setProp(m_ipAttribute.str(), computerNode->queryProp(XML_ATTR_NETADDRESS));
}
}
}
}
//---------------------------------------------------------------------------
// createInstallFileMap
//---------------------------------------------------------------------------
int CEspDeploymentEngine::determineInstallFiles(IPropertyTree& node, CInstallFiles& installFiles) const
{
m_pCallback->printStatus(STATUS_NORMAL, NULL, NULL, NULL, "Merging file lists for ESP server and its bound service(s) ...");
const char* myBuild = m_process.queryProp("@build");
//process bindings for this esp process and add files for each service used by
//each binding before adding files for this esp process
Owned<IPropertyTreeIterator> iBinding = m_process.getElements("EspBinding");
ForEach(*iBinding)
{
IPropertyTree* pBinding = &iBinding->query();
const char* szService = pBinding->queryProp("@service");
// Lookup plugin process
IPropertyTree* pService = lookupProcess("EspService", szService);
if (!pService)
throw MakeStringException(0, "Process %s references unknown esp service '%s'", m_name.get(), szService);
const char* pszBuild = pService->queryProp("@build");
if (!pszBuild || 0 != strcmp(pszBuild, myBuild))
throw MakeStringException(0, "ESP service '%s' used by ESP process '%s'\n has a different build (%s) to its ESP process!",
szService, m_name.get(), pszBuild);
// Get plugin file list from the plugin process
CDeploymentEngine::determineInstallFiles(*pService, installFiles);
}
int rc = CDeploymentEngine::determineInstallFiles(node, installFiles);
m_pCallback->printStatus(STATUS_NORMAL, NULL, NULL, NULL, "determineInstallFiles complete");
return rc;
}
bool CESPServerLoggingAgent::init(const char * name, const char * type, IPropertyTree * cfg, const char * process)
{
if (!cfg)
return false;
IPropertyTree* espServer = cfg->queryBranch(PropESPServer);
if(!espServer)
throw MakeStringException(-1,"Unable to find ESPServer settings for log agent %s:%s", name, type);
const char* url = espServer->queryProp(PropServerUrl);
if (url && *url)
serverUrl.set(url);
const char* userID = espServer->queryProp(PropServerUserID);
const char* password = espServer->queryProp(PropServerPassword);
if (userID && *userID && password && *password)
{
serverUserID.set(userID);
decrypt(serverPassword, password);
}
maxServerWaitingSeconds = cfg->getPropInt(PropServerWaitingSeconds);
maxGTSRetries = cfg->getPropInt(MaxTriesGTS, DefaultMaxTriesGTS);
readAllLogFilters(cfg);
return true;
}
CDaliServixFilter(IPropertyTree &filter)
{
const char *subnet = filter.queryProp("@subnet");
const char *mask = filter.queryProp("@mask");
if (!ipSubNet.set(subnet, mask))
throw MakeStringException(0, "Invalid sub net definition: %s, %s", subnet, mask);
dir.set(filter.queryProp("@directory"));
trace = filter.getPropBool("@trace");
}
void SWProcess::checkInstanceAttributes(IPropertyTree *instanceNode, IPropertyTree *parent)
{
assert(instanceNode);
if (portIsRequired() && !instanceNode->hasProp("@port"))
{
int port = getDefaultPort();
if (!port)
throw MakeStringException(CfgEnvErrorCode::InvalidParams, "Miss port attribute in instance");
instanceNode->addPropInt("@port", port);
}
StringBuffer xpath;
xpath.clear().appendf("xs:element/xs:complexType/xs:sequence/xs:element[@name=\"%s\"]",m_instanceElemName.str());
IPropertyTree * instanceSchemaNode = m_pSchema->queryPropTree(xpath.str());
if (!instanceSchemaNode) return;
bool needDirProp = false;
Owned<IPropertyTreeIterator> attrIter = instanceSchemaNode->getElements("xs:complexType/xs:attribute");
ForEach(*attrIter)
{
IPropertyTree * attr = &attrIter->query();
const char *attrName = attr->queryProp("@name");
if (!stricmp(attrName, "directory"))
{
needDirProp = true;
continue;
}
const char *defaultValue = attr->queryProp("@default");
if (!defaultValue) continue;
xpath.clear().appendf("@%s", attrName);
if (instanceNode->hasProp(xpath.str())) continue;
const char *use = attr->queryProp("@use");
if (!use || !stricmp(use, "required") || !stricmp(use, "optional"))
{
StringBuffer sbDefaultValue;
sbDefaultValue.clear().append(defaultValue);
sbDefaultValue.replaceString("\\", "\\\\");
instanceNode->addProp(xpath.str(), sbDefaultValue.str());
}
}
if (needDirProp && !instanceNode->hasProp("@directory"))
{
const IProperties *props = m_envHelper->getEnvConfigOptions().getProperties();
StringBuffer sb;
sb.clear().appendf("%s/%s",
props->queryProp("runtime"), parent->queryProp(XML_ATTR_NAME));
instanceNode->addProp("@directory", sb.str());
}
}
//---------------------------------------------------------------------------
// check
//---------------------------------------------------------------------------
void CEspDeploymentEngine::check()
{
CDeploymentEngine::check();
// Make sure all protocol and service referenced by bindings are valid
Owned<IPropertyTreeIterator> iter = m_process.getElements("EspBinding");
for (iter->first(); iter->isValid(); iter->next())
{
IPropertyTree* pBinding = &iter->query();
const char* service = pBinding->queryProp("@service");
if (service)
{
if (!lookupProcess("EspService", service))
throw MakeStringException(0, "Process %s references unknown service %s", m_name.get(), service);
}
else
throw MakeStringException(-1, "The ESP binding %s for ESP %s has missing service information!",
pBinding->queryProp("@name"), m_name.get());
}
// Make sure DaliServers are valid
iter.setown(m_process.getElements(".//*[@daliServers]"));
ForEach(*iter)
{
const char* name = iter->query().queryProp("@daliServers");
if (name && *name && !lookupProcess("DaliServerProcess", name))
throw MakeStringException(0, "Process %s references unknown DaliServers %s", m_name.get(), name);
}
// Make sure EclServer is valid
iter.setown(m_process.getElements(".//*[@eclServer]"));
ForEach(*iter)
{
const char* name = iter->query().queryProp("@eclServer");
if (name && *name && !lookupProcess("EclServerProcess", name))
throw MakeStringException(0, "Process %s references unknown EclServer %s", m_name.get(), name);
}
// Make sure AttributeServer is valid
iter.setown(m_process.getElements(".//*[@attributeServer]"));
ForEach(*iter)
{
const char* name = iter->query().queryProp("@attributeServer");
if (name && *name && !lookupProcess("AttrServerProcess", name))
throw MakeStringException(0, "Process %s references unknown AttributeServer %s", m_name.get(), name);
}
}
bool ResourceManifest::loadInclude(IPropertyTree &include, const char *dir)
{
const char *filename = include.queryProp("@filename");
StringBuffer includePath;
makeAbsolutePath(filename, dir, includePath);
VStringBuffer xpath("Include[@originalFilename='%s']", includePath.str());
if (manifest->hasProp(xpath.str()))
return false;
include.setProp("@originalFilename", includePath.str());
StringBuffer includeDir;
splitDirTail(includePath, includeDir);
Owned<IPropertyTree> manifestInclude = createPTreeFromXMLFile(includePath.str());
Owned<IPropertyTreeIterator> it = manifestInclude->getElements("*");
ForEach(*it)
{
IPropertyTree &item = it->query();
if (streq(item.queryName(), "Resource"))
updateResourcePaths(item, includeDir.str());
else if (streq(item.queryName(), "Include"))
{
if (!loadInclude(item, includeDir.str()))
continue;
}
manifest->addPropTree(item.queryName(), LINK(&item));
}
return true;
}
static bool ensureThorIsDown(const char *cluster, bool nofail, bool wait)
{
bool retry = false;
do {
Owned<IRemoteConnection> pStatus = querySDS().connect("/Status/Servers", myProcessSession(), RTM_NONE, SDS_LOCK_TIMEOUT);
Owned<IPropertyTreeIterator> it = pStatus->queryRoot()->getElements("Server[@name='ThorMaster']");
retry = false;
ForEach(*it) {
IPropertyTree* pServer = &it->query();
if (pServer->hasProp("@cluster") && !strcmp(pServer->queryProp("@cluster"), cluster)) {
if (nofail) {
WARNLOG("A Thor on cluster %s is still active", cluster);
if (!wait)
return false;
Sleep(1000*10);
PROGLOG("Retrying...");
retry = true;
break;
}
throw MakeStringException(-1, "A Thor cluster node swap requires the cluster to be offline. Please stop the Thor cluster '%s' and try again.", cluster);
}
}
} while (retry);
return true;
}
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");
}
CWsMachineSoapBindingEx::CWsMachineSoapBindingEx(IPropertyTree* cfg,
const char *bindname/*=NULL*/,
const char *procname/*=NULL*/)
:Cws_machineSoapBinding(cfg, bindname, procname)
{
StringBuffer xpath;
xpath.appendf("Software/EspProcess[@name=\"%s\"]", procname);
IPropertyTree* pEspProcess = cfg->queryPropTree(xpath.str());
if (pEspProcess)
{
xpath.clear().appendf("EspBinding[@name=\"%s\"]/@service", bindname);
const char* service = pEspProcess->queryProp(xpath.str());
if (service)
{
xpath.clear().appendf("EspService[@name=\"%s\"]/MachineInfo/Software/*", service);
Owned<IPropertyTreeIterator> it = pEspProcess->getElements(xpath.str());
ForEach(*it)
{
m_processTypes.append(it->query().queryName());
}
m_processTypes.sort(SortFunction);
}
}
}
void appendSchemaResource(IPropertyTree &res, ILoadedDllEntry *dll)
{
if (!dll || (flags & WWV_OMIT_SCHEMAS))
return;
if (res.getPropInt("@seq", -1)>=0 && res.hasProp("@id"))
{
int id = res.getPropInt("@id");
size32_t len = 0;
const void *data = NULL;
if (dll->getResource(len, data, "RESULT_XSD", (unsigned) id) && len>0)
{
buffer.append("<XmlSchema name=\"").append(res.queryProp("@name")).append("\">");
if (res.getPropBool("@compressed"))
{
StringBuffer decompressed;
decompressResource(len, data, decompressed);
if (flags & WWV_CDATA_SCHEMAS)
buffer.append("<![CDATA[");
buffer.append(decompressed.str());
if (flags & WWV_CDATA_SCHEMAS)
buffer.append("]]>");
}
else
buffer.append(len, (const char *)data);
buffer.append("</XmlSchema>");
}
}
}
bool CLogThread::FlattenTree(IArrayOf<IEspLogInfo>& valueArray,IPropertyTree& tree,StringBuffer& RootName)
{
StringBuffer Value,Name;
if (tree.hasChildren() == true)
{
Owned<IPropertyTreeIterator> itr = tree.getElements("*");
itr->first();
while(itr->isValid())
{
IPropertyTree &node = itr->query();
if(RootName.length() > 0)
Name.appendf("%s_",RootName.str());
Name.appendf("%s",node.queryName());
if (node.hasChildren() == true)
{
if(IsArray(node)==true)
FlattenArray(valueArray,node,Name);
else
FlattenTree(valueArray,node,Name);
}
else
{
const char* _value = tree.queryProp(node.queryName());
if(tree.hasProp(node.queryName())==true && _value!=0 && _value!='\0')
{
Value.appendf("%s",tree.queryProp(node.queryName()));
IClientLogInfo& logElement = addLogInfoElement(valueArray);
logElement.setName(Name.str());
logElement.setValue(Value.str());
//DBGLOG("Add log element: %s, %s", Name.str(), Value.str());
Value.clear();
}
}
Name.clear();
itr->next();
}
}
else
{
return false;
}
return true;
}
CLocalDataLogger::CLocalDataLogger(IPropertyTree *cfg, const char *process, const char *service, const char* UrlRoot)
{
StringBuffer _directoryCache,xpath;
xpath.appendf("Software/EspProcess[@name=\"%s\"]/EspService[@name=\"%s\"]/localCache/", process, service);
IPropertyTree* cacheprop = cfg->queryBranch(xpath.str());
if(cacheprop==0)
{
WARNLOG(-1,"No local cache defined for %s service.",service);
return;
}
Init(cacheprop->queryProp("@cache"),cacheprop->queryProp("@fileExtension"),UrlRoot,cacheprop->getPropInt("@timerPeriod"),cacheprop->getPropInt("@cacheTimeout"));
}
void SWProcess::processNameChanged(const char* process, const char *newName, const char* oldName)
{
StringBuffer xpath;
xpath.clear().appendf("@%s", process);
IPropertyTree * swTree = m_envHelper->getEnvTree()->queryPropTree("/Software");
Owned<IPropertyTreeIterator> compIter = swTree->getElements(m_envHelper->getXMLTagName(m_name.str()));
synchronized block(mutex);
ForEach(*compIter)
{
IPropertyTree * compTree = &compIter->query();
if ((oldName != NULL) && strcmp(oldName, compTree->queryProp(xpath.str())))
continue;
if (compTree->queryProp(xpath.str()))
compTree->setProp(xpath.str(), newName);
}
}
bool XmlEclRepository::doLoadModule(IPropertyTree * repository, IHqlRemoteScope * rScope, IErrorReceiver *errs)
{
IHqlScope * scope = rScope->queryScope();
const char * scopeName = scope->queryName()->getAtomNamePtr();
StringBuffer s;
const char * modName = scope->queryFullName();
IPropertyTree* module = repository->queryPropTree(s.append("./Module[@name=\"").append(modName).append("\"]").str());
if(!module)
{
if (logging())
DBGLOG("No data for module %s",scopeName);
return false;
}
int access = module->getPropInt("@access",cs_full);
if(module->queryProp("Text"))
{
const char * path = module->queryProp("@sourcePath");
Owned<ISourcePath> sourcePath = createSourcePath(path ? path : modName);
Owned<IFileContents> text = createFileContentsFromText(module->queryProp("Text"), sourcePath);
rScope->setText(text);
}
else
{
StringBuffer buf("./Attribute");
Owned<IPropertyTreeIterator> it = module->getElements(buf.str());
if (it->first())
{
for(;it->isValid();it->next())
{
Owned<IHqlExpression> item = toNamedSymbol(&it->query(), *scope->queryName(), access);
((CHqlScope*)scope)->defineSymbol(LINK(item));
}
}
else
{
if (logging())
DBGLOG("No definitions were added for module %s", scopeName);
}
}
return true;
}
void updateManifestResourcePaths(IPropertyTree &resource, const char *dir)
{
StringBuffer filepath;
makeAbsolutePath(resource.queryProp("@filename"), dir, filepath);
resource.setProp("@originalFilename", filepath.str());
StringBuffer respath;
makePathUniversal(filepath.str(), respath);
resource.setProp("@resourcePath", respath.str());
}
bool SWProcess::portIsRequired()
{
IPropertyTree * portAttrNode = getPortDefinition();
if (!portAttrNode) return false;
const char* portUseAttr = portAttrNode->queryProp("@use");
if (portUseAttr && stricmp(portUseAttr, "required"))
return false;
return true;
}
void ResourceManager::addManifestInclude(IPropertyTree &include, const char *dir)
{
StringBuffer includePath;
makeAbsolutePath(include.queryProp("@filename"), dir, includePath);
VStringBuffer xpath("Include[@originalFilename='%s']", includePath.str());
if (manifest->hasProp(xpath.str()))
return;
include.setProp("@originalFilename", includePath.str());
manifest->addPropTree("Include", LINK(&include));
addManifestFile(includePath.str());
}
void SWProcess::computerDeleted(const char* ipAddress, const char* computerName, const char *instanceXMLTagName)
{
IPropertyTree * software = m_envHelper->getEnvTree()->queryPropTree(XML_TAG_SOFTWARE);
Owned<IPropertyTreeIterator> compIter = software->getElements(m_processName);
const char *instance = (instanceXMLTagName)? instanceXMLTagName: m_instanceElemName.str();
synchronized block(mutex);
ForEach (*compIter)
{
IPropertyTree * comp = &compIter->query();
Owned<IPropertyTreeIterator> instanceIter = comp->getElements(instance);
ForEach (*instanceIter)
{
IPropertyTree * instance = &instanceIter->query();
if ((instance->hasProp(m_ipAttribute.str()) && stricmp(instance->queryProp(m_ipAttribute.str()), ipAddress)) ||
(instance->hasProp("@computer") && stricmp(instance->queryProp("@computer"), computerName)))
comp->removeTree(instance);
}
}
}
IPropertyTree * SWProcess::findInstance(IPropertyTree *comp, IPropertyTree *computerNode)
{
Owned<IPropertyTreeIterator> instanceIter = comp->getElements(m_instanceElemName);
ForEach (*instanceIter)
{
IPropertyTree * instance = &instanceIter->query();
if (!stricmp(instance->queryProp("@computer"), computerNode->queryProp(XML_ATTR_NAME)))
return instance;
}
return NULL;
}
bool CBuildSetManager::populateBuildSet()
{
StringBuffer xpath;
if (m_buildSetTree.get() != nullptr)
return false;
try
{
m_buildSetTree.set(createPTreeFromXMLFile(m_buildSetPath.str()));
}
catch(...)
{
return false;
}
xpath.setf("./%s/%s/%s", XML_TAG_PROGRAMS, XML_TAG_BUILD, XML_TAG_BUILDSET);
Owned<IPropertyTreeIterator> iter = m_buildSetTree->getElements(xpath.str());
ForEach(*iter)
{
IPropertyTree* pTree = &iter->query();
if ( pTree->queryProp(XML_ATTR_PROCESS_NAME) == nullptr || pTree->queryProp(XML_ATTR_OVERRIDE) != nullptr || ( (pTree->queryProp(XML_ATTR_DEPLOYABLE) != nullptr && \
stricmp(pTree->queryProp(XML_ATTR_DEPLOYABLE), "no") == 0 && stricmp(pTree->queryProp(XML_ATTR_PROCESS_NAME), XML_TAG_ESPSERVICE) != 0) ) )
continue;
Owned<CBuildSet> pBuildSet = new CBuildSet(pTree->queryProp(XML_ATTR_INSTALLSET), pTree->queryProp(XML_ATTR_NAME), pTree->queryProp(XML_ATTR_PROCESS_NAME),\
pTree->queryProp(XML_ATTR_SCHEMA), pTree->queryProp(XML_ATTR_DEPLOYABLE), pTree->queryProp(XML_ATTR_OVERRIDE));
m_buildSetArray.append(*pBuildSet.getLink());
}
return true;
}
static void appendNodeEndpoint(IPropertyTree& node,SocketEndpointArray &eps)
{
const char *computer = node.queryProp("@computer");
CMachineEntryPtr *m = machinemap.getValue(computer);
if (!m) {
ERRLOG("Computer name %s not found",computer);
return;
}
SocketEndpoint ep = (*m)->ep;
if (ep.port==0)
ep.port = getDaliServixPort();
eps.append(ep);
}
//---------------------------------------------------------------------------
// copyInstallFiles
//---------------------------------------------------------------------------
void CDaliDeploymentEngine::copyInstallFiles(IPropertyTree& instanceNode, const char* destPath)
{
const char* computer = instanceNode.queryProp("@computer");
if ((m_deployFlags & DEFLAGS_CONFIGFILES) && computer && *computer)
{
// Create dalisds.xml is not already exists
StringBuffer hostRoot(getHostRoot(computer, NULL));
const char* dir = m_process.queryProp("@dataPath");
if (!dir || !*dir)
dir = instanceNode.queryProp("@directory");
if (dir)
{
if (isPathSepChar(*dir))
dir++;
StringBuffer sDir( dir );
sDir.replace(':', '$');
sDir.replace('/', '\\');
sDir.insert(0, hostRoot.str());
if (!checkFileExists( sDir.str() ))
{
Owned<IPropertyTree> tree = &m_environment.getPTree();
StringBuffer xml("<SDS>");
toXML(tree, xml);
xml.append("</SDS>");
sDir.append( "\\dalisds.xml" );
writeFile(sDir.str(), xml.str());
}
}
}
// Copy install files to deploy subdir
CDeploymentEngine::copyInstallFiles(instanceNode, destPath);
}
IPropertyTree * SWProcess::addComponent(IPropertyTree *params)
{
const char* clone = params->queryProp("@clone");
if (clone)
{
return SWComponentBase::cloneComponent(params);
}
IPropertyTree * pCompTree = SWComponentBase::addComponent(params);
if (pCompTree->hasProp("@daliServers") && !strcmp(pCompTree->queryProp("@daliServers"), ""))
{
IPropertyTree * envTree = m_envHelper->getEnvTree();
StringBuffer xpath;
xpath.clear().appendf(XML_TAG_SOFTWARE "/DaliServerProcess/@name");
const char *daliName = envTree->queryProp(xpath.str());
if (daliName)
{
pCompTree->setProp("@daliServers", daliName);
}
}
removeInstancesFromComponent(pCompTree);
return pCompTree;
}
IConfigComp* SWProcess::getInstanceNetAddresses(StringArray& ipList, const char* clusterName)
{
IPropertyTree * envTree = m_envHelper->getEnvTree();
StringBuffer xpath;
if (clusterName)
xpath.clear().appendf(XML_TAG_SOFTWARE "/%s[@name=\"%s\"]", m_processName.str(), clusterName);
else
xpath.clear().appendf(XML_TAG_SOFTWARE "/%s[1]", m_processName.str());
IPropertyTree *compTree = envTree->queryPropTree(xpath.str());
Owned<IPropertyTreeIterator> iter = compTree->getElements(m_instanceElemName.str());
ForEach (*iter)
{
IPropertyTree *instance = &iter->query();
ipList.append(instance->queryProp("@netAddress"));
}
return (IConfigComp*)this;
}
static bool checkScopeAuthorized(IUserDescriptor *user,IPropertyTree &pt,bool &securitydisabled)
{
if (securitydisabled)
return true;
unsigned auditflags = DALI_LDAP_AUDIT_REPORT|DALI_LDAP_READ_WANTED;
int perm = 255;
const char *scopename = pt.queryProp("@scope");
if (scopename&&*scopename) {
perm = querySessionManager().getPermissionsLDAP("workunit",scopename,user,auditflags);
if (perm<0) {
if (perm==-1) {
perm = 255;
securitydisabled = true;
}
else
perm = 0;
}
if (!HASREADPERMISSION(perm))
return false;
}
return true;
}
void SWProcess::modifyInstance(IPropertyTree *parent, IPropertyTree *params)
{
IPropertyTree* pAttrs = params->queryPropTree("Attributes");
if (!pAttrs)
throw MakeStringException(CfgEnvErrorCode::InvalidParams, "Miss instance attributes input");
const char * instanceXMLTagName = getInstanceXMLTagName(pAttrs->queryProp("@selector"));
Owned<IPropertyTreeIterator> iter = pAttrs->getElements("Attribute");
ForEach (*iter)
{
IPropertyTree *attr = &iter->query();
const char* propName = attr->queryProp("@name");
if (stricmp(propName, "ip"))
continue;
StringBuffer xpath;
IPropertyTree *instanceToModify;
const char* oldIp = attr->queryProp("@oldValue");
if ((!oldIp || !(*oldIp)) && m_singleInstanceList.find(m_name.str()) == NotFound)
throw MakeStringException(CfgEnvErrorCode::InvalidParams, "Miss instance current ip to change");
else if (oldIp && *oldIp)
{
xpath.clear().appendf("%s[%s=\"%s\"]", instanceXMLTagName, m_ipAttribute.str(), oldIp);
instanceToModify = parent->queryPropTree(xpath.str());
}
else
{
xpath.clear().appendf("%s[1]", instanceXMLTagName);
instanceToModify = parent->queryPropTree(xpath.str());
}
if (!instanceToModify)
throw MakeStringException(CfgEnvErrorCode::InvalidParams, "Cannot find instance node to modify");
IPropertyTree * computerNode = addComputer(attr->queryProp("@value"));
instanceToModify->setProp("@computer", computerNode->queryProp(XML_ATTR_NAME));
instanceToModify->setProp(m_ipAttribute.str(), computerNode->queryProp(XML_ATTR_NETADDRESS));
}
}
inline bool isPartTLK(IPropertyTree &pt) { const char *kind = pt.queryProp("@kind"); return kind&&strieq(kind,"topLevelKey"); }
