IPropertyTree *getPkgSetRegistry(const char *process, bool readonly)
{
Owned<IRemoteConnection> globalLock = querySDS().connect("/PackageSets/", myProcessSession(), RTM_LOCK_WRITE|RTM_CREATE_QUERY, SDS_LOCK_TIMEOUT);
if (!globalLock)
throw MakeStringException(PKG_DALI_LOOKUP_ERROR, "Unable to connect to PackageSet information in dali /PackageSets");
IPropertyTree *pkgSets = globalLock->queryRoot();
if (!pkgSets)
throw MakeStringException(PKG_DALI_LOOKUP_ERROR, "Unable to open PackageSet information in dali /PackageSets");
if (!process || !*process)
process = "*";
StringBuffer id;
buildPkgSetId(id, process);
//Only lock the branch for the target we're interested in.
VStringBuffer xpath("/PackageSets/PackageSet[@id='%s']", id.str());
Owned<IRemoteConnection> conn = querySDS().connect(xpath.str(), myProcessSession(), readonly ? RTM_LOCK_READ : RTM_LOCK_WRITE, SDS_LOCK_TIMEOUT);
if (!conn)
{
if (readonly)
return NULL;
Owned<IPropertyTree> pkgSet = createPTree();
pkgSet->setProp("@id", id.str());
pkgSet->setProp("@process", process);
pkgSets->addPropTree("PackageSet", pkgSet.getClear());
globalLock->commit();
conn.setown(querySDS().connect(xpath.str(), myProcessSession(), RTM_LOCK_WRITE, SDS_LOCK_TIMEOUT));
}
return (conn) ? conn->getRoot() : NULL;
}
IRemoteConnection * getEntryConnection(const char * name, unsigned mode)
{
StringBuffer xpath;
getNewXPath(xpath, name);
Owned<IRemoteConnection> connection = querySDS().connect(xpath.str(), myProcessSession(), mode, CONNECTION_TIMEOUT);
if (connection)
return connection.getClear();
//Retain backwards compatibility for the moment
getOldXPath(xpath.clear(), name);
return querySDS().connect(xpath.str(), myProcessSession(), mode, CONNECTION_TIMEOUT);
}
bool deletePkgInfo(const char *name, const char *target, const char *process, bool globalScope)
{
Owned<IRemoteConnection> pkgSetsConn = querySDS().connect("/PackageSets/", myProcessSession(), RTM_LOCK_WRITE, SDS_LOCK_TIMEOUT);
if (!pkgSetsConn)
throw MakeStringException(PKG_NONE_DEFINED, "No package sets defined");
IPropertyTree* packageSets = pkgSetsConn->queryRoot();
StringBuffer pkgSetId;
buildPkgSetId(pkgSetId, process);
VStringBuffer pkgSet_xpath("PackageSet[@id='%s']", pkgSetId.str());
IPropertyTree *pkgSetRegistry = packageSets->queryPropTree(pkgSet_xpath.str());
if (!pkgSetRegistry)
throw MakeStringException(PKG_TARGET_NOT_DEFINED, "No package sets defined for %s", process);
StringBuffer lcTarget(target);
target = lcTarget.toLowerCase().str();
StringBuffer lcName(name);
name = lcName.toLowerCase().str();
Owned<IPropertyTree> mapEntry;
StringBuffer xpath;
if (!globalScope)
{
xpath.appendf("PackageMap[@id='%s::%s'][@querySet='%s']", target, name, target);
mapEntry.setown(pkgSetRegistry->getPropTree(xpath.str()));
}
if (!mapEntry)
{
xpath.clear().appendf("PackageMap[@id='%s'][@querySet='%s']", name, target);
mapEntry.setown(pkgSetRegistry->getPropTree(xpath.str()));
if (!mapEntry)
throw MakeStringException(PKG_DELETE_NOT_FOUND, "Unable to delete %s - information not found", lcName.str());
}
StringAttr pmid(mapEntry->queryProp("@id"));
pkgSetRegistry->removeTree(mapEntry);
xpath.clear().appendf("PackageSet/PackageMap[@id='%s']", pmid.get());
if (!packageSets->hasProp(xpath))
{
Owned<IRemoteConnection> pkgMapsConn = querySDS().connect("/PackageMaps/", myProcessSession(), RTM_LOCK_WRITE, SDS_LOCK_TIMEOUT);
if (!pkgMapsConn)
throw MakeStringException(PKG_DALI_LOOKUP_ERROR, "Unable to retrieve PackageMaps information from dali [/PackageMaps]");
IPropertyTree *pkgMaps = pkgMapsConn->queryRoot();
if (!pkgMaps)
throw MakeStringException(PKG_DALI_LOOKUP_ERROR, "Unable to retrieve PackageMaps information from dali [/PackageMaps]");
IPropertyTree *mapTree = pkgMaps->queryPropTree(xpath.clear().appendf("PackageMap[@id='%s']", pmid.get()).str());
if (mapTree)
pkgMaps->removeTree(mapTree);
}
return true;
}
IRemoteConnection* CWSESPControlEx::querySDSConnection(const char* xpath, unsigned mode, unsigned timeout)
{
Owned<IRemoteConnection> globalLock = querySDS().connect(xpath, myProcessSession(), mode, timeout);
if (!globalLock)
throw MakeStringException(ECLWATCH_INTERNAL_ERROR, "Unable to connect to ESP Session information in dali %s", xpath);
return globalLock.getClear();
}
static void emptyScopes()
{
PROGLOG("Removing empty scopes");
Owned<IDFScopeIterator> iter = queryDistributedFileDirectory().getScopeIterator(NULL,true,true);
CDfsLogicalFileName dlfn;
StringBuffer s;
StringArray toremove;
ForEach(*iter) {
CDfsLogicalFileName dlfn;
StringBuffer scope;
scope.append(iter->query());
dlfn.set(scope.str(),"x");
dlfn.makeScopeQuery(s.clear(),true);
Owned<IRemoteConnection> conn = querySDS().connect(s.str(),myProcessSession(),RTM_LOCK_READ, INFINITE);
if (!conn)
DBGLOG("Could not connect to '%s' using %s",iter->query(),s.str());
else {
if (recursiveCheckEmptyScope(*conn->queryRoot())) {
PROGLOG("Empty scope %s",iter->query());
toremove.append(iter->query());
}
}
}
iter.clear();
ForEachItemIn(i,toremove) {
PROGLOG("Removed scope %s",toremove.item(i));
queryDistributedFileDirectory().removeEmptyScope(toremove.item(i));
}
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;
}
bool isScheduledWorkUnit(char const * wuid)
{
Owned<IRemoteConnection> conn = querySDS().connect("/Schedule", myProcessSession(), RTM_LOCK_WRITE | RTM_CREATE_QUERY, connectionTimeout);
StringBuffer xpath("*/*/*/");
ncnameEscape(wuid, xpath);
return conn->queryRoot()->hasProp(xpath.str());
}
virtual void unsubscribe()
{
CriticalBlock b(crit);
try
{
if (pmChange)
querySDS().unsubscribe(pmChange);
if (psChange)
querySDS().unsubscribe(psChange);
}
catch (IException *E)
{
E->Release();
}
pmChange = 0;
psChange = 0;
}
COnlineWorkunitIterator (
IUserDescriptor* _user,
const char *_namelo,
const char *_namehi,
const char *user,
const char *cluster,
const char *jobname,
const char *state,
const char *priority,
const char *fileread,
const char *filewritten,
const char *roxiecluster,
const char *ecl
) : user(_user), namelo(_namelo), namehi(_namehi)
{
securitydisabled = false;
if (namelo.isEmpty())
namelo.set("W");
if (namehi.isEmpty()) {
StringBuffer tmp;
namehi.set(getWUIDdaysAgo(tmp,-1).str());
}
const char *lo = namelo;
const char *hi = namehi;
StringBuffer query;
while (*lo&&(toupper(*lo)==toupper(*hi))) {
query.append((char)toupper(*lo));
lo++;
hi++;
}
if (*lo||*hi)
query.append("*");
if (user&&*user)
query.appendf("[@submitID=~?\"%s\"]",user);
if (cluster&&*cluster)
query.appendf("[@clusterName=~?\"%s\"]",cluster);
if (jobname&&*jobname)
query.appendf("[@jobName=~?\"%s\"]",jobname);
if (state&&*state)
query.appendf("[@state=?\"%s\"]",state);
if (priority&&*priority)
query.appendf("[@priorityClass=?\"%s\"]",priority);
if (fileread&&*fileread)
query.appendf("[FilesRead/File/@name=~?\"%s\"]",fileread);
if (filewritten&&*filewritten)
query.appendf("[Files/File/@name=~?\"%s\"]",filewritten);
if (roxiecluster&&*roxiecluster)
query.appendf("[RoxieQueryInfo/@roxieClusterName=~?\"%s\"]",roxiecluster);
if (ecl&&*ecl)
query.appendf("[Query/Text=?~\"*%s*\"]",ecl);
conn.setown(querySDS().connect("WorkUnits", myProcessSession(), 0, SDS_LOCK_TIMEOUT));
if (conn.get()) {
iter.setown(conn->getElements(query.str()));
if (!iter.get())
conn.clear();
}
}
static unsigned fn2(unsigned n, unsigned m, unsigned seed, unsigned depth, StringBuffer &parentname)
{
if (!Rconn)
return 0;
if ((n+m+seed)%25==0) {
Rconn->commit();
Rconn->Release();
Rconn = querySDS().connect("/DAREGRESS",myProcessSession(), 0, 1000000);
if (!Rconn) {
ERROR("Failed to connect to /DAREGRESS");
return 0;
}
}
IPropertyTree *parent = parentname.length()?Rconn->queryRoot()->queryPropTree(parentname.str()):Rconn->queryRoot();
if (!parent) {
ERROR1("Failed to connect to %s",parentname.str());
Rconn->Release();
Rconn = NULL;
return 0;
}
__int64 val = parent->getPropInt64("val",0);
parent->setPropInt64("val",n+val);
val = parent->getPropInt64("@val",0);
parent->setPropInt64("@val",m+val);
val = parent->getPropInt64(NULL,0);
parent->setPropInt64(NULL,seed+val);
if (!seed)
return m+n;
if (n==m)
return seed;
if (depth>10)
return seed+n+m;
if (seed%7==n%7)
return n;
if (seed%7==m%7)
return m;
char name[64];
unsigned v = seed;
name[0] = 's';
name[1] = 'u';
name[2] = 'b';
unsigned i = 3;
while (v) {
name[i++] = ('A'+v%26 );
v /= 26;
}
name[i] = 0;
unsigned l = parentname.length();
if (parentname.length())
parentname.append('/');
parentname.append(name);
IPropertyTree *child = parent->queryPropTree(name);
if (!child)
child = parent->addPropTree(name, createPTree(name));
unsigned ret = fn2(fn2(n,seed,seed*17+11,depth+1,parentname),fn2(seed,m,seed*11+17,depth+1,parentname),seed*19+7,depth+1,parentname);
parentname.setLength(l);
return ret;
}
void init()
{
VStringBuffer xpath("PackageMap[@id='%s']", pmid.str());
globalLock.setown(querySDS().connect("/PackageMaps", myProcessSession(), RTM_LOCK_WRITE|RTM_CREATE_QUERY, SDS_LOCK_TIMEOUT));
packageMaps = globalLock->queryRoot();
pmExisting = packageMaps->queryPropTree(xpath);
if (pmExisting && !pmExisting->getPropBool("@multipart", false))
convertExisting();
}
void cleanupWorkUnitSchedule()
{
Owned<IRemoteConnection> conn = querySDS().connect("/Schedule", myProcessSession(), RTM_LOCK_WRITE, connectionTimeout);
if(!conn) return;
Owned<IPropertyTree> root(conn->queryRoot()->getBranch("."));
recursiveCleanup(root, 2);
conn->commit();
cleanupSchedulerList(root);
}
IXRefNode * CXRefNodeManager::CreateXRefNode(const char* NodeName)
{
Owned<IRemoteConnection> conn = querySDS().connect("/DFU/XREF",myProcessSession(),RTM_CREATE_QUERY|RTM_LOCK_WRITE ,INFINITE);
IPropertyTree* xref_ptree = conn->queryRoot();
IPropertyTree* cluster_ptree = xref_ptree->addPropTree("Cluster", createPTree());
cluster_ptree->setProp("@name",NodeName);
conn->commit();
conn->changeMode(RTM_NONE);
return new CXRefNode(NodeName,conn);
}
void PackageMapAndSet::load(const char* path, IPropertyTree* t)
{
Owned<IRemoteConnection> globalLock = querySDS().connect(path, myProcessSession(), RTM_LOCK_READ, SDS_LOCK_TIMEOUT);
if (!globalLock)
throw MakeStringException(PKG_DALI_LOOKUP_ERROR, "Unable to retrieve %s information from dali /%s", path, path);
t->removeProp(path);
IPropertyTree *root = globalLock->queryRoot();
if (root)
t->addPropTree(path, createPTreeFromIPT(root));
}
void cleanupSchedulerList(IPropertyTree * schedule)
{
Owned<IRemoteConnection> conn = querySDS().connect("/Schedulers", myProcessSession(), RTM_LOCK_WRITE, connectionTimeout);
if(!conn) return;
Owned<IPropertyTree> root(conn->queryRoot()->getBranch("."));
Owned<IPropertyTreeIterator> iter = root->getElements("*");
for(iter->first(); iter->isValid(); iter->next())
if(!schedule->hasProp(iter->query().queryName()))
iter->query().setProp("@remove", "yes");
bool more;
do more = root->removeProp("*[@remove=\"yes\"]"); while(more);
}
void descheduleNonexistentWorkUnit(char const * wuid)
{
StringBuffer xpath;
xpath.append("*/*/*/");
ncnameEscape(wuid, xpath);
Owned<IRemoteConnection> conn = querySDS().connect("/Schedule", myProcessSession(), RTM_LOCK_WRITE, connectionTimeout);
if(!conn) return;
PROGLOG("Scheduled workunit %s could not be found, and so is being descheduled", wuid);
Owned<IPropertyTree> root = conn->getRoot();
bool more;
do more = root->removeProp(xpath.str()); while(more);
}
bool updateDaliEnv(IPropertyTree *env, bool forceGroupUpdate, const char *daliIp)
{
Owned<IPropertyTreeIterator> dalis = env->getElements("Software/DaliServerProcess/Instance");
if (!dalis||!dalis->first()) {
fprintf(stderr,"Could not find DaliServerProcess\n");
return false;
}
SocketEndpoint daliep;
loop {
const char *ps = dalis->get().queryProp("@port");
unsigned port = ps?atoi(ps):0;
if (!port)
port = DALI_SERVER_PORT;
daliep.set(dalis->get().queryProp("@netAddress"),port);
if (daliIp && *daliIp) {
SocketEndpoint testep;
testep.set(daliIp,DALI_SERVER_PORT);
if (testep.equals(daliep))
break;
daliep.set(NULL,0);
}
if (!dalis->next())
break;
if (!daliep.isNull()) {
fprintf(stderr,"Ambiguous DaliServerProcess instance\n");
return false;
}
}
if (daliep.isNull()) {
fprintf(stderr,"Could not find DaliServerProcess instance\n");
return false;
}
SocketEndpointArray epa;
epa.append(daliep);
Owned<IGroup> group = createIGroup(epa);
bool ret = true;
initClientProcess(group, DCR_Util);
StringBuffer response;
if (querySDS().updateEnvironment(env, forceGroupUpdate, response))
{
StringBuffer tmp;
PROGLOG("Environment and node groups updated in dali at %s",daliep.getUrlStr(tmp).str());
}
else
ret = false;
if (response.length())
WARNLOG("%s", response.str());
closedownClientProcess();
return ret;
}
virtual void unsubscribe()
{
CriticalBlock b(crit);
notifier = NULL;
try
{
if (traceLevel > 5)
DBGLOG("unsubscribing from %s, %p", xpath.get(), this);
if (change)
{
if (isExact)
querySDS().unsubscribeExact(change);
else
querySDS().unsubscribe(change);
}
}
catch (IException *E)
{
E->Release();
}
change = 0;
}
virtual void onReconnect()
{
Linked<CDaliPackageWatcher> me = this; // Ensure that I am not released by the notify call (which would then access freed memory to release the critsec)
// It's tempting to think you can avoid holding the critsec during the notify call, and that you only need to hold it while looking up notifier
// Despite the danger of deadlocks (that requires careful code in the notifier to avoid), I think it is neccessary to hold the lock during the call,
// as otherwise notifier may point to a deleted object.
CriticalBlock b(crit);
if (traceLevel > 5)
DBGLOG("resubscribing to %s, %p", xpath.get(), this);
change = querySDS().subscribe(xpath, *this, true);
if (notifier)
notifier->notify(0, NULL, SDSNotify_None);
}
void findUnusedFilesInDFS(StringArray &unusedFiles, const char *process, const MapStringTo<bool> &usedFileMap)
{
Owned<IRemoteConnection> globalLock = querySDS().connect("/Files/", myProcessSession(), RTM_LOCK_READ, SDS_LOCK_TIMEOUT);
Owned<IPropertyTree> root = globalLock->getRoot();
VStringBuffer xpath("//File[Cluster/@name='%s']/OrigName", process);
Owned<IPropertyTreeIterator> files = root->getElements(xpath);
ForEach(*files)
{
const char *lfn = skipTilda(files->query().queryProp(NULL));
if (lfn && !usedFileMap.getValue(lfn))
unusedFiles.append(lfn);
}
}
bool getAllClusters(SocketEndpointArray &eps)
{
Owned<IRemoteConnection> conn = querySDS().connect("/Environment/Software", myProcessSession(), RTM_LOCK_READ, SDS_CONNECT_TIMEOUT);
if (!conn)
return false;
IPropertyTree* root = conn->queryRoot();
Owned<IPropertyTreeIterator> clusters= root->getElements("ThorCluster");
if (clusters->first()) {
do {
IPropertyTree &cluster = clusters->query();
if (!getCluster(cluster.queryProp("@name"),eps))
ERRLOG("Cluster %s not found",cluster.queryProp("@name"));
} while (clusters->next());
}
return eps.ordinality()!=0;
}
void init()
{
StringBuffer xpath("Software/ThorCluster[@name=\"");
xpath.append(clusterName).append("\"]");
Owned<IRemoteConnection> conn = querySDS().connect("/Environment", myProcessSession(), RTM_LOCK_READ, SDS_LOCK_TIMEOUT);
environment.setown(createPTreeFromIPT(conn->queryRoot()));
options = environment->queryPropTree(xpath.str());
if (!options)
throwUnexpected();
groupName.set(options->queryProp("@nodeGroup"));
if (groupName.isEmpty())
groupName.set(options->queryProp("@name"));
VStringBuffer spareS("%s_spares", groupName.get());
spareGroupName.set(spareS);
group.setown(queryNamedGroupStore().lookup(groupName));
spareGroup.setown(queryNamedGroupStore().lookup(spareGroupName));
}
CSDSServerStatus::CSDSServerStatus(const char *servername)
{
conn = querySDS().connect("Status/Servers/Server", myProcessSession(), RTM_CREATE_ADD | RTM_LOCK_READ | RTM_DELETE_ON_DISCONNECT, 5*60*1000);
if (conn) {
IPropertyTree &root = *conn->queryRoot();
root.setProp("@name",servername);
StringBuffer node;
queryMyNode()->endpoint().getIpText(node);
root.setProp("@node",node.str());
root.setPropInt("@mpport",queryMyNode()->endpoint().port);
CDateTime dt;
dt.setNow();
StringBuffer str;
root.setProp("@started",dt.getString(str).str());
conn->commit();
}
}
void activatePackageMapInfo(const char *target, const char *name, const char *process, bool globalScope, bool activate)
{
if (!target || !*target)
throw MakeStringExceptionDirect(PKG_TARGET_NOT_DEFINED, "No target defined");
if (!name || !*name)
throw MakeStringExceptionDirect(PKG_MISSING_PARAM, "No pmid specified");
Owned<IRemoteConnection> globalLock = querySDS().connect("PackageSets", myProcessSession(), RTM_LOCK_WRITE|RTM_CREATE_QUERY, SDS_LOCK_TIMEOUT);
if (!globalLock)
throw MakeStringException(PKG_DALI_LOOKUP_ERROR, "Unable to retrieve PackageSets information from dali /PackageSets");
StringBuffer lcTarget(target);
target = lcTarget.toLowerCase().str();
StringBuffer lcName(name);
name = lcName.toLowerCase().str();
IPropertyTree *root = globalLock->queryRoot();
if (!root)
throw MakeStringException(PKG_ACTIVATE_NOT_FOUND, "Unable to retrieve PackageSet information");
StringBuffer pkgSetId;
buildPkgSetId(pkgSetId, process);
VStringBuffer xpath("PackageSet[@id='%s']", pkgSetId.str());
IPropertyTree *pkgSetTree = root->queryPropTree(xpath);
if (pkgSetTree)
{
IPropertyTree *mapTree = NULL;
if (!globalScope)
{
xpath.clear().appendf("PackageMap[@querySet='%s'][@id='%s::%s']", target, target, name);
mapTree = pkgSetTree->queryPropTree(xpath);
}
if (!mapTree)
{
xpath.clear().appendf("PackageMap[@querySet='%s'][@id='%s']", target, name);
mapTree = pkgSetTree->queryPropTree(xpath);
}
if (!mapTree)
throw MakeStringException(PKG_ACTIVATE_NOT_FOUND, "PackageMap %s not found on target %s", name, target);
makePackageActive(pkgSetTree, mapTree, target, activate);
}
}
IXRefNode * CXRefNodeManager::getXRefNode(const char* NodeName)
{
//DBGLOG("Node Name %s:",NodeName);
StringBuffer xpath;
xpath.appendf("Cluster[@name=\"%s\"]", NodeName);
//if not exists, add DFU/XREF/ClusterName branch to SDS
//not linked
Owned<IRemoteConnection> conn = querySDS().connect("/DFU/XREF",myProcessSession(),RTM_CREATE_QUERY|RTM_NONE ,INFINITE);
IPropertyTree* cluster_ptree = conn->queryRoot()->queryPropTree(xpath.str());
conn->commit();
if (cluster_ptree==0)
{
DBGLOG("Cluster[@name=%s] can't be found under /DFU/XREF", NodeName);
return 0 ;
}
return new CXRefNode(NodeName,conn);
}
IPropertyTree *getSwapNodeInfo(bool create)
{
Owned<IRemoteConnection> conn = querySDS().connect("/SwapNode", myProcessSession(), RTM_LOCK_WRITE|(create?RTM_CREATE_QUERY:0), 1000*60*5);
if (!conn) {
ERRLOG("SWAPNODE: could not connect to /SwapNode branch");
return NULL;
}
StringBuffer xpath;
xpath.appendf("Thor[@group=\"%s\"]",groupName.get());
Owned<IPropertyTree> info = conn->queryRoot()->getPropTree(xpath.str());
if (!info) {
if (!create) {
PROGLOG("SWAPNODE: no information for group %s",groupName.get());
return NULL;
}
info.set(conn->queryRoot()->addPropTree("Thor",createPTree("Thor")));
info->setProp("@group",groupName.get());
}
return info.getClear();
}
void doStuff()
{
Owned<IRemoteConnection> conn = querySDS().connect("/Orbit", myProcessSession(), RTM_LOCK_WRITE|RTM_CREATE_QUERY, DALI_TIMEOUT);
IPropertyTree *root = conn->queryRoot();
StringBuffer s;
if (root->getProp("TestBranch1",s)) {
printf("TestBranch1: read %s\n",s.str());
}
else {
// save as string
printf("TestBranch1: set (as string)\n",s.str());
root->setProp("TestBranch1",MyTestXML);
}
MemoryBuffer m;
if (root->getPropBin("TestBranch2",m)) {
m.append((byte)0); // add a NULL to returned data
const char *str = m.toByteArray();
printf("TestBranch2: read %s\n",str);
}
else {
// save as raw binary
printf("TestBranch2: set (as blob)\n",s.str());
root->setPropBin("TestBranch2",strlen(MyTestXML),MyTestXML); // include NULL
}
IPropertyTree *br3 = root->queryPropTree("TestBranch3");
if (br3) {
printf("read TestBranch3 as tree\n");
printf("Hello = %s\n",br3->queryProp("Hello"));
int n = br3->getPropInt("Bye/@num"); // update
printf("Bye num = %d\n",n);
br3->setPropInt("Bye/@num",n+1);
}
else {
// save as tree
printf("TestBranch3: set (as tree)\n",s.str());
br3 = createPTreeFromXMLString(MyTestXML); // parses and creates object tree
root->setPropTree("TestBranch3", br3);
}
}
static void loadMachineMap()
{
if (machinelist.ordinality())
return;
Owned<IRemoteConnection> conn = querySDS().connect("/Environment/Hardware", myProcessSession(), RTM_LOCK_READ, SDS_LOCK_TIMEOUT);
if (!conn)
return;
IPropertyTree* root = conn->queryRoot();
Owned<IPropertyTreeIterator> machines= root->getElements("Computer");
if (machines->first()) {
do {
IPropertyTree &machine = machines->query();
SocketEndpoint ep(machine.queryProp("@netAddress"));
ep.port = getDaliServixPort();
const char *name = machine.queryProp("@name");
const char *state=machine.queryProp("@state");
CMachineEntry *entry = new CMachineEntry(name,ep,!state||stricmp(state,"Available")==0);
machinemap.setValue(name, entry);
machinelist.append(*entry);
} while (machines->next());
}
}
static void test1()
{
printf("Test SDS read/write\n");
Owned<IPropertyTree> ref = createPTree("DAREGRESS");
fn(1,2,3,0,ref);
StringBuffer refstr;
toXML(ref,refstr,0,XML_SortTags|XML_Format);
printf("Created reference size %d\n",refstr.length());
Owned<IRemoteConnection> conn = querySDS().connect("/DAREGRESS",myProcessSession(), RTM_CREATE, 1000000);
Rconn = conn;
IPropertyTree *root = conn->queryRoot();
fn(1,2,3,0,root);
conn.clear();
printf("Created test branch 1\n");
conn.setown(querySDS().connect("/DAREGRESS",myProcessSession(), RTM_DELETE_ON_DISCONNECT, 1000000));
root = conn->queryRoot();
StringBuffer s;
toXML(root,s,0,XML_SortTags|XML_Format);
if (strcmp(s.str(),refstr.str())!=0) {
ERROR("Branch 1 does not match");
}
else
printf("Branch 1 matches\n");
conn.clear();
conn.setown(querySDS().connect("/DAREGRESS",myProcessSession(), 0, 1000000));
if (conn)
ERROR("RTM_DELETE_ON_DISCONNECT failed");
Rconn = querySDS().connect("/DAREGRESS",myProcessSession(), RTM_CREATE, 1000000);
StringBuffer pn;
fn2(1,2,3,0,pn);
::Release(Rconn);
printf("Created test branch 2\n");
Rconn = NULL;
conn.setown(querySDS().connect("/DAREGRESS",myProcessSession(), RTM_DELETE_ON_DISCONNECT, 1000000));
root = conn->queryRoot();
toXML(root,s.clear(),0,XML_SortTags|XML_Format);
if (strcmp(s.str(),refstr.str())!=0) {
ERROR("Branch 2 does not match");
}
else
printf("Branch 2 matches\n");
conn.clear();
conn.setown(querySDS().connect("/DAREGRESS",myProcessSession(), 0, 1000000));
if (conn)
ERROR("RTM_DELETE_ON_DISCONNECT failed");
}
void unsubscribe()
{
if (sub_id) {
if (sub_id) { querySDS().unsubscribe(sub_id); sub_id = 0; }
}
}