Merge branch 'candidate-7.10.x'

Signed-off-by: Richard Chapman <rchapman@hpccsystems.com>

common/workunit/workunit.cpp

@@ -2724,6 +2724,7 @@ WuScopeFilter::WuScopeFilter(const char * filter)
 
 WuScopeFilter & WuScopeFilter::addFilter(const char * filter)
 {
+    checkModifiable();
     if (!filter)
         return *this;
 
@@ -2829,6 +2830,7 @@ WuScopeFilter & WuScopeFilter::addFilter(const char * filter)
 
 WuScopeFilter & WuScopeFilter::addScope(const char * scope)
 {
+    checkModifiable();
     if (scope)
     {
         validateScope(scope);
@@ -2837,8 +2839,16 @@ WuScopeFilter & WuScopeFilter::addScope(const char * scope)
     return *this;
 }
 
+WuScopeFilter & WuScopeFilter::addScopeType(StatisticScopeType scopeType)
+{
+    checkModifiable();
+    scopeFilter.addScopeType(scopeType);
+    return *this;
+}
+
 WuScopeFilter & WuScopeFilter::addScopeType(const char * scopeType)
 {
+    checkModifiable();
     if (scopeType)
     {
         StatisticScopeType sst = queryScopeType(scopeType, SSTmax);
@@ -2852,6 +2862,7 @@ WuScopeFilter & WuScopeFilter::addScopeType(const char * scopeType)
 
 WuScopeFilter & WuScopeFilter::addId(const char * id)
 {
+    checkModifiable();
     validateScopeId(id);
     scopeFilter.addId(id);
     return *this;
@@ -2859,6 +2870,7 @@ WuScopeFilter & WuScopeFilter::addId(const char * id)
 
 WuScopeFilter & WuScopeFilter::addOutput(const char * prop)
 {
+    checkModifiable();
     WuAttr attr = queryWuAttribute(prop, WaNone);
     if (attr != WaNone)
     {
@@ -2877,6 +2889,7 @@ WuScopeFilter & WuScopeFilter::addOutput(const char * prop)
 
 WuScopeFilter & WuScopeFilter::addOutputStatistic(const char * prop)
 {
+    checkModifiable();
     if (!prop)
         return *this;
 
@@ -2889,6 +2902,7 @@ WuScopeFilter & WuScopeFilter::addOutputStatistic(const char * prop)
 
 WuScopeFilter & WuScopeFilter::addOutputStatistic(StatisticKind stat)
 {
+    checkModifiable();
     if (stat != StKindNone)
     {
         if (stat != StKindAll)
@@ -2904,6 +2918,7 @@ WuScopeFilter & WuScopeFilter::addOutputStatistic(StatisticKind stat)
 
 WuScopeFilter & WuScopeFilter::addOutputAttribute(const char * prop)
 {
+    checkModifiable();
     if (!prop)
         return *this;
 
@@ -2916,6 +2931,7 @@ WuScopeFilter & WuScopeFilter::addOutputAttribute(const char * prop)
 
 WuScopeFilter & WuScopeFilter::addOutputAttribute(WuAttr attr)
 {
+    checkModifiable();
     if (attr != WaNone)
     {
         if (attr != WaAll)
@@ -2932,6 +2948,7 @@ WuScopeFilter & WuScopeFilter::addOutputAttribute(WuAttr attr)
 
 WuScopeFilter & WuScopeFilter::addOutputHint(const char * prop)
 {
+    checkModifiable();
     if (strieq(prop, "none"))
     {
         desiredHints.kill();
@@ -2950,18 +2967,21 @@ WuScopeFilter & WuScopeFilter::addOutputHint(const char * prop)
 
 WuScopeFilter & WuScopeFilter::setIncludeMatch(bool value)
 {
+    checkModifiable();
     include.matchedScope = value;
     return *this;
 }
 
 WuScopeFilter & WuScopeFilter::setIncludeNesting(unsigned depth)
 {
+    checkModifiable();
     include.nestedDepth = depth;
     return *this;
 }
 
 WuScopeFilter & WuScopeFilter::setIncludeScopeType(const char * scopeType)
 {
+    checkModifiable();
     if (scopeType)
     {
         StatisticScopeType sst = queryScopeType(scopeType, SSTmax);
@@ -2975,6 +2995,7 @@ WuScopeFilter & WuScopeFilter::setIncludeScopeType(const char * scopeType)
 
 WuScopeFilter & WuScopeFilter::setMeasure(const char * measure)
 {
+    checkModifiable();
     if (measure)
     {
         desiredMeasure = queryMeasure(measure, SMeasureNone);
@@ -2987,6 +3008,7 @@ WuScopeFilter & WuScopeFilter::setMeasure(const char * measure)
 
 WuScopeFilter & WuScopeFilter::addOutputProperties(WuPropertyTypes mask)
 {
+    checkModifiable();
     if (properties == PTnone)
         properties = mask;
     else
@@ -2996,18 +3018,21 @@ WuScopeFilter & WuScopeFilter::addOutputProperties(WuPropertyTypes mask)
 
 WuScopeFilter & WuScopeFilter::addRequiredStat(StatisticKind statKind, stat_type lowValue, stat_type highValue)
 {
+    checkModifiable();
     requiredStats.emplace_back(statKind, lowValue, highValue);
     return *this;
 }
 
 WuScopeFilter & WuScopeFilter::addRequiredStat(StatisticKind statKind)
 {
+    checkModifiable();
     requiredStats.emplace_back(statKind, 0, MaxStatisticValue);
     return *this;
 }
 
 WuScopeFilter & WuScopeFilter::addRequiredAttr(WuAttr attr, const char * value)
 {
+    checkModifiable();
     requiredAttrs.emplace_back(attr, value);
     return *this;
 }
@@ -3019,6 +3044,7 @@ WuScopeFilter & WuScopeFilter::addRequiredAttr(WuAttr attr, const char * value)
 
 void WuScopeFilter::addRequiredStat(const char * filter)
 {
+    checkModifiable();
     const char * stat = filter;
     const char * cur = stat;
     while (isalpha(*cur))
@@ -3117,6 +3143,7 @@ void WuScopeFilter::addRequiredStat(const char * filter)
 
 WuScopeFilter & WuScopeFilter::addSource(const char * source)
 {
+    checkModifiable();
     WuScopeSourceFlags mask = querySource(source);
     if (mask == SSFunknown)
         throw makeStringExceptionV(0, "Unexpected source '%s'", source);
@@ -3129,6 +3156,7 @@ WuScopeFilter & WuScopeFilter::addSource(const char * source)
 
 WuScopeFilter & WuScopeFilter::setDepth(unsigned low, unsigned high)
 {
+    checkModifiable();
     scopeFilter.setDepth(low, high);
     return *this;
 }
@@ -3148,14 +3176,19 @@ bool WuScopeFilter::matchOnly(StatisticScopeType scopeType) const
     return false;
 }
 
+void WuScopeFilter::reportModifyTooLate()
+{
+    throw makeStringException(WUERR_ModifyFilterAfterFinalize, "Attempting to modify WuScopefilter after finish() has been called");
+}
+
 
 //Called once the filter has been updated to optimize the filter
 void WuScopeFilter::finishedFilter()
 {
-    scopeFilter.finishedFilter();
+    if (optimized)
+        throw makeStringException(WUERR_FinalizeAfterFinalize, "Calling finishedFilter() more than once");
 
-    assertex(!optimized);
-    optimized = true;
+    scopeFilter.finishedFilter();
 
     if ((include.nestedDepth == 0) && !include.matchedScope)
         include.nestedDepth = UINT_MAX;
@@ -3259,6 +3292,8 @@ void WuScopeFilter::finishedFilter()
     {
         sourceFlags &= ~(SSFsearchGraph|SSFsearchWorkflow);
     }
+
+    optimized = true;
 }
 
 
@@ -8492,7 +8527,7 @@ bool CLocalWorkUnit::getStatistic(stat_type & value, const char * scope, Statist
 IConstWUScopeIterator & CLocalWorkUnit::getScopeIterator(const WuScopeFilter & filter) const
 {
     assertex(filter.isOptimized());
-    WuScopeSourceFlags sources = filter.sourceFlags;
+    WuScopeSourceFlags sources = filter.querySources();
 
     Owned<CompoundStatisticsScopeIterator> compoundIter = new CompoundStatisticsScopeIterator(filter);
     if (sources & SSFsearchGlobalStats)
@@ -8506,7 +8541,7 @@ IConstWUScopeIterator & CLocalWorkUnit::getScopeIterator(const WuScopeFilter & f
     if (sources & SSFsearchGraphStats)
     {
         const char * wuid = p->queryName();
-        Owned<IConstWUScopeIterator> scopeIter(new CConstGraphProgressScopeIterator(wuid, filter.queryIterFilter(), filter.minVersion));
+        Owned<IConstWUScopeIterator> scopeIter(new CConstGraphProgressScopeIterator(wuid, filter.queryIterFilter(), filter.queryMinVersion()));
         compoundIter->addIter(scopeIter);
     }
 

common/workunit/workunit.hpp

@@ -52,6 +52,12 @@ typedef unsigned short UChar;
 #endif //_WIN32
 
 
+enum : unsigned
+{
+    WUERR_ModifyFilterAfterFinalize = WORKUNIT_ERROR_START,
+    WUERR_FinalizeAfterFinalize,
+};
+
 // error codes
 #define QUERRREG_ADD_NAMEDQUERY     QUERYREGISTRY_ERROR_START
 #define QUERRREG_REMOVE_NAMEDQUERY  QUERYREGISTRY_ERROR_START+1
@@ -1049,12 +1055,14 @@ protected:
  */
 class WORKUNIT_API WuScopeFilter
 {
+    friend class CompoundStatisticsScopeIterator;
 public:
     WuScopeFilter() = default;
     WuScopeFilter(const char * filter);
 
     WuScopeFilter & addFilter(const char * filter);
     WuScopeFilter & addScope(const char * scope);
+    WuScopeFilter & addScopeType(StatisticScopeType scopeType);
     WuScopeFilter & addScopeType(const char * scopeType);
     WuScopeFilter & addId(const char * id);
     WuScopeFilter & setDepth(unsigned low, unsigned high);
@@ -1089,13 +1097,17 @@ public:
     const ScopeFilter & queryIterFilter() const;
     bool isOptimized() const { return optimized; }
     bool onlyIncludeScopes() const { return (properties & ~PTscope) == 0; }
+    WuScopeSourceFlags querySources() const { return sourceFlags; }
+    unsigned queryMinVersion() const { return minVersion; }
+    bool outputDefined() const { return properties != PTnone; }
 
 protected:
     void addRequiredStat(const char * filter);
+    void checkModifiable() { if (unlikely(optimized)) reportModifyTooLate(); }
     bool matchOnly(StatisticScopeType scopeType) const;
+    void reportModifyTooLate();
 
-    //MORE: Make the following protected/private
-public:
+protected:
 //The following members control which scopes are matched by the iterator
     ScopeFilter scopeFilter;                            // Filter that must be matched by a scope
     std::vector<StatisticValueFilter> requiredStats;    // The attributes that must be present for a particular scope

dali/base/dasess.cpp

@@ -61,7 +61,7 @@ static std::unordered_map<std::string, DaliClientRole> daliClientRoleMap = {
     { "EspServer", DCR_EspServer },
     { "Config", DCR_Config },
     { "SchedulerAdmin", DCR_ScheduleAdmin },
-    { "RoxieMaster", DCR_RoxyMaster },
+    { "Roxie", DCR_Roxie },
     { "BackupGen", DCR_BackupGen },
     { "DaFsControl", DCR_DaFsControl },
     { "SwapNode", DCR_SwapNode },
@@ -103,7 +103,7 @@ const char *queryRoleName(DaliClientRole role)
     case DCR_EspServer: return "EspServer";
     case DCR_Config: return "Config";
     case DCR_ScheduleAdmin: return "SchedulerAdmin";
-    case DCR_RoxyMaster: return "RoxieMaster";
+    case DCR_Roxie: return "Roxie";
     case DCR_BackupGen: return "BackupGen";
     case DCR_DaFsControl: return "DaFsControl";
     case DCR_SwapNode: return "SwapNode";

dali/base/dasess.hpp

@@ -61,7 +61,7 @@ enum DaliClientRole // if changed must update queryRoleName()
     DCR_Deprecated7,
     DCR_Config,
     DCR_Deprecated8,
-    DCR_RoxyMaster,
+    DCR_Roxie,
     DCR_Deprecated9,
     DCR_Deprecated10,
     DCR_BackupGen,

dali/server/daserver.cpp

@@ -251,7 +251,7 @@ static bool populateWhiteListFromEnvironment(IWhiteListWriter &writer)
                         StringBuffer ipSB;
                         const char *ip = resolveComputer(serverCompName, server.queryProp("@netAddress"), ipSB);
                         if (ip)
-                            writer.add(ip, DCR_RoxyMaster);
+                            writer.add(ip, DCR_Roxie);
                     }
                     break;
                 }

ecl/eclccserver/eclccserver.cpp

@@ -192,9 +192,10 @@ class EclccCompileThread : implements IPooledThread, implements IErrorReporter,
 
     virtual void reportError(const char *errStr, unsigned retcode)
     {
-        RegExpr errCount, errParse, timings;
+        RegExpr errParse, timings, summaryParse;
         timings.init("^<stat");
         errParse.init("^<exception");
+        summaryParse.init("^<summary");
         try
         {
             if (timings.find(errStr))
@@ -223,7 +224,7 @@ class EclccCompileThread : implements IPooledThread, implements IErrorReporter,
                     associateLocalFile(query, FileTypeCpp, filename, pathTail(filename), 0, 0, 0);
                 }
             }
-            else
+            else if (!summaryParse.find(errStr))
                 IERRLOG("Unrecognised error: %s", errStr);
         }
         catch (IException *E)

esp/scm/ws_workunits_req_resp.ecm

@@ -352,6 +352,7 @@ ESPrequest WUInfoRequest
     [min_ver("1.66")] bool IncludeHelpers(true);
     [min_ver("1.66")] bool IncludeAllowedClusters(true);
     [min_ver("1.73")] bool IncludeTotalClusterTime(true);
+    [min_ver("1.78")] bool IncludeServiceNames(false);
     [min_ver("1.16")] bool SuppressResultSchemas(false);
     [min_ver("1.25")] string ThorSlaveIP;
 };

esp/scm/ws_workunits_struct.ecm

@@ -438,6 +438,7 @@ ESPStruct [nil_remove] ECLWorkunit
     [min_ver("1.50")] int DebugValueCount;
     [min_ver("1.50")] int WorkflowCount;
     [min_ver("1.67")] int HelpersCount;
+    [min_ver("1.78")] ESParray<string> ServiceNames;
 };
 
 ESPStruct [nil_remove] WUECLAttribute

esp/services/ws_workunits/ws_workunitsHelpers.cpp

@@ -898,6 +898,27 @@ void WsWuInfo::getGraphTimingData(IArrayOf<IConstECLTimingData> &timingData)
         it->playProperties(visitor);
 }
 
+void WsWuInfo::getServiceNames(IEspECLWorkunit &info, unsigned long flags)
+{
+    if (!(flags & WUINFO_IncludeServiceNames))
+        return;
+
+    StringArray serviceNames;
+    WuScopeFilter filter;
+    filter.addScopeType("activity");
+    filter.addOutputAttribute(WaServiceName);
+    filter.addRequiredAttr(WaServiceName);
+    filter.finishedFilter();
+    Owned<IConstWUScopeIterator> it = &cw->getScopeIterator(filter);
+    ForEach(*it)
+    {
+        StringBuffer serviceName;
+        const char *value = it->queryAttribute(WaServiceName, serviceName);
+        if (!isEmptyString(value))
+            serviceNames.append(value);
+    }
+    info.setServiceNames(serviceNames);
+}
 
 void WsWuInfo::getEventScheduleFlag(IEspECLWorkunit &info)
 {
@@ -1056,6 +1077,7 @@ void WsWuInfo::getInfo(IEspECLWorkunit &info, unsigned long flags)
     getDebugValues(info, flags);
     getApplicationValues(info, flags);
     getWorkflow(info, flags);
+    getServiceNames(info, flags);
 }
 
 unsigned WsWuInfo::getWorkunitThorLogInfo(IArrayOf<IEspECLHelpFile>& helpers, IEspECLWorkunit &info, unsigned long flags, unsigned& helpersCount)

esp/services/ws_workunits/ws_workunitsHelpers.hpp

@@ -134,6 +134,7 @@ private:
 #define WUINFO_IncludeHelpers           0x8000
 #define WUINFO_IncludeAllowedClusters   0x10000
 #define WUINFO_IncludeTotalClusterTime  0x20000
+#define WUINFO_IncludeServiceNames      0x40000
 #define WUINFO_All                      0xFFFFFFFF
 
 class WsWuInfo
@@ -199,6 +200,7 @@ public:
     bool getResultEclSchemas(IConstWUResult &r, IArrayOf<IEspECLSchemaItem>& schemas);
     void getResult(IConstWUResult &r, IArrayOf<IEspECLResult>& results, unsigned long flags);
     void getStats(const WuScopeFilter & filter, const StatisticsFilter& statsFilter, bool createDescriptions, IArrayOf<IEspWUStatisticItem>& statistics);
+    void getServiceNames(IEspECLWorkunit &info, unsigned long flags);
 
     void getWorkunitEclAgentLog(const char* eclAgentInstance, const char* agentPid, MemoryBuffer& buf, const char* outFile);
     void getWorkunitThorLog(const char *processName, MemoryBuffer& buf, const char* outFile);

esp/services/ws_workunits/ws_workunitsService.cpp

@@ -1622,6 +1622,8 @@ bool CWsWorkunitsEx::onWUInfo(IEspContext &context, IEspWUInfoRequest &req, IEsp
                     flags|=WUINFO_IncludeAllowedClusters;
                 if (req.getIncludeTotalClusterTime())
                     flags|=WUINFO_IncludeTotalClusterTime;
+                if (req.getIncludeServiceNames())
+                    flags|=WUINFO_IncludeServiceNames;
 
                 PROGLOG("WUInfo: %s %lx", wuid.str(), flags);
 

roxie/ccd/ccd.hpp

@@ -96,7 +96,7 @@ void setMulticastEndpoints(unsigned numChannels);
 
 //#define TIME_PACKETS
 
-#define ROXIE_FASTLANE      0x8000u         // mask in retries indicating slave reply goes on the fast queue
+#define ROXIE_FASTLANE      0x8000u         // mask in retries indicating agent reply goes on the fast queue
 #define ROXIE_BROADCAST     0x4000u         // mask in retries indicating original request was a broadcast
 #define ROXIE_RETRIES_MASK  (~(ROXIE_FASTLANE|ROXIE_BROADCAST)) // retries bits mask
 #define QUERY_ABORTED       0xffffu         // special value for retries to indicate abandoned query
@@ -145,7 +145,7 @@ public:
     unsigned packetlength;
     unsigned short retries;         // how many retries on this query, the high bits are used as flags, see above
     unsigned short overflowSequence;// Used if more than one packet-worth of data from server - eg keyed join. We don't mind if we wrap...
-    unsigned short continueSequence;// Used if more than one chunk-worth of data from slave. We don't mind if we wrap
+    unsigned short continueSequence;// Used if more than one chunk-worth of data from agent. We don't mind if we wrap
     unsigned short channel;         // multicast family to send on
     unsigned activityId;            // identifies the helper factory to be used (activityId in graph)
     hash64_t queryHash;             // identifies the query
@@ -235,7 +235,7 @@ extern bool debugPermitted;
 extern bool useRemoteResources;
 extern bool checkFileDate;
 extern bool lazyOpen;
-extern bool localSlave;
+extern bool localAgent;
 extern bool useAeron;
 extern bool ignoreOrphans;
 extern bool doIbytiDelay;
@@ -267,7 +267,7 @@ extern unsigned minFilesOpen[2];
 extern unsigned maxFilesOpen[2];
 extern RelaxedAtomic<unsigned> restarts;
 extern bool checkCompleted;
-extern bool prestartSlaveThreads;
+extern bool prestartAgentThreads;
 extern unsigned preabortKeyedJoinsThreshold;
 extern unsigned preabortIndexReadsThreshold;
 extern bool traceStartStop;
@@ -277,7 +277,7 @@ extern bool defaultTimeActivities;
 extern bool defaultTraceEnabled;
 extern unsigned defaultTraceLimit;
 extern unsigned watchActivityId;
-extern unsigned testSlaveFailure;
+extern unsigned testAgentFailure;
 extern unsigned dafilesrvLookupTimeout;
 extern bool fastLaneQueue;
 extern unsigned mtu_size;
@@ -296,14 +296,14 @@ extern bool steppingEnabled;
 extern bool simpleLocalKeyedJoins;
 extern bool enableKeyDiff;
 extern PTreeReaderOptions defaultXmlReadFlags;
-extern bool mergeSlaveStatistics;
+extern bool mergeAgentStatistics;
 extern bool defaultNoSeekBuildIndex;
 extern unsigned parallelLoadQueries;
 
 #ifdef _CONTAINERIZED
 static constexpr bool roxieMulticastEnabled = false;
 #else
-extern bool roxieMulticastEnabled;   // enable use of multicast for sending requests to slaves
+extern bool roxieMulticastEnabled;   // enable use of multicast for sending requests to agents
 #endif
 extern bool preloadOnceData;
 extern bool reloadRetriesFailed;
@@ -350,7 +350,7 @@ extern unsigned defaultHeapFlags;
 extern bool defaultCheckingHeap;
 extern bool defaultDisableLocalOptimizations;
 
-extern unsigned slaveQueryReleaseDelaySeconds;
+extern unsigned agentQueryReleaseDelaySeconds;
 extern unsigned coresPerQuery;
 
 extern StringBuffer logDirectory;
@@ -391,7 +391,7 @@ extern void saveTopology();
 
 class LogItem : public CInterface
 {
-    friend class SlaveContextLogger;
+    friend class AgentContextLogger;
 
     TracingCategory category;
     StringAttr prefix;
@@ -557,7 +557,7 @@ public:
     }
     virtual void CTXLOGl(LogItem *logItem) const
     {
-        // NOTE - we don't actually print anything to logfile here - was already printed on slave
+        // NOTE - we don't actually print anything to logfile here - was already printed on agent
         CriticalBlock b(crit);
         log.append(*logItem);
     }
@@ -678,7 +678,7 @@ public:
     virtual bool collectingDetailedStatistics() const { return false; }
 };
 
-class SlaveContextLogger : public StringContextLogger
+class AgentContextLogger : public StringContextLogger
 {
     Owned<IMessagePacker> output;
     mutable bool anyOutput; // messy
@@ -687,8 +687,8 @@ class SlaveContextLogger : public StringContextLogger
     IpAddress ip;
     StringAttr wuid;
 public:
-    SlaveContextLogger();
-    SlaveContextLogger(IRoxieQueryPacket *packet);
+    AgentContextLogger();
+    AgentContextLogger(IRoxieQueryPacket *packet);
     void set(IRoxieQueryPacket *packet);
     void putStatProcessed(unsigned subGraphId, unsigned actId, unsigned idx, unsigned processed, unsigned strands) const;
     void putStats(unsigned subGraphId, unsigned actId, const CRuntimeStatisticCollection &stats) const;

roxie/ccd/ccdactivities.cpp

@@ -52,7 +52,7 @@ using roxiemem::OwnedConstRoxieRow;
 using roxiemem::OwnedRoxieString;
 using roxiemem::IRowManager;
 
-#define maxContinuationSize 48000 // note - must fit in the 2-byte length field... but also needs to be possible to send back from Roxie server->slave in one packet
+#define maxContinuationSize 48000 // note - must fit in the 2-byte length field... but also needs to be possible to send back from Roxie server->agent in one packet
 
 size32_t serializeRow(IOutputRowSerializer * serializer, IMessagePacker *output, const void *unserialized)
 {
@@ -135,13 +135,13 @@ ActivityArray *CActivityFactory::queryChildQuery(unsigned idx, unsigned &id)
 }
 
 
-class CSlaveActivityFactory : public CActivityFactory, implements ISlaveActivityFactory
+class CAgentActivityFactory : public CActivityFactory, implements IAgentActivityFactory
 {
 
 public:
     IMPLEMENT_IINTERFACE
 
-    CSlaveActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory) 
+    CAgentActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory) 
         : CActivityFactory(_graphNode.getPropInt("@id", 0), _subgraphId, _queryFactory, _helperFactory, getActivityKind(_graphNode), _graphNode)
     {
     }
@@ -202,16 +202,16 @@ public:
     {
         CActivityFactory::getActivityMetrics(reply);
     }
-    IRoxieSlaveContext *createSlaveContext(const SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    IRoxieAgentContext *createAgentContext(const AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
-        return queryFactory.createSlaveContext(logctx, packet, childQueries.length()!=0);
+        return queryFactory.createAgentContext(logctx, packet, childQueries.length()!=0);
     }
     virtual void getXrefInfo(IPropertyTree &reply, const IRoxieContextLogger &logctx) const
     {
         if (datafile)
             addXrefFileInfo(reply, datafile);
     }
-    void createChildQueries(IRoxieSlaveContext *ctx, IArrayOf<IActivityGraph> &childGraphs, IHThorArg *colocalArg, IProbeManager *_probeManager, IRoxieSlaveContext *queryContext, const SlaveContextLogger &logctx) const
+    void createChildQueries(IRoxieAgentContext *ctx, IArrayOf<IActivityGraph> &childGraphs, IHThorArg *colocalArg, IProbeManager *_probeManager, IRoxieAgentContext *queryContext, const AgentContextLogger &logctx) const
     {
         if (childQueries.length())
         {
@@ -284,13 +284,13 @@ protected:
 
 //================================================================================================
 
-class CRoxieSlaveActivity : implements CInterfaceOf<IRoxieSlaveActivity>, implements ICodeContext
+class CRoxieAgentActivity : implements CInterfaceOf<IRoxieAgentActivity>, implements ICodeContext
 {
 protected:
-    SlaveContextLogger &logctx;
+    AgentContextLogger &logctx;
     Linked<IRoxieQueryPacket> packet;
-    mutable Owned<IRoxieSlaveContext> queryContext; // bit of a hack but easier than changing the ICodeContext callback interface to remove const
-    const CSlaveActivityFactory *basefactory;
+    mutable Owned<IRoxieAgentContext> queryContext; // bit of a hack but easier than changing the ICodeContext callback interface to remove const
+    const CAgentActivityFactory *basefactory;
     IArrayOf<IActivityGraph> childGraphs;
     IHThorArg *basehelper;
     PartNoType lastPartNo;
@@ -329,7 +329,7 @@ protected:
 
     virtual void onCreate()
     {
-        queryContext.setown(basefactory->createSlaveContext(logctx, packet));
+        queryContext.setown(basefactory->createAgentContext(logctx, packet));
 #ifdef _DEBUG
         // MORE - need to consider debugging....
         if (probeAllRows)
@@ -354,7 +354,7 @@ protected:
             unsigned checksum;
             serializedCreate.read(checksum);
             OwnedRoxieString fname(queryDynamicFileName());
-            varFileInfo.setown(querySlaveDynamicFileCache()->lookupDynamicFile(logctx, fname, cacheDate, checksum, &packet->queryHeader(), isOpt, true));
+            varFileInfo.setown(queryAgentDynamicFileCache()->lookupDynamicFile(logctx, fname, cacheDate, checksum, &packet->queryHeader(), isOpt, true));
             setVariableFileInfo();
         }
     }
@@ -363,7 +363,7 @@ protected:
     {
     }
 
-    CRoxieSlaveActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_factory)
+    CRoxieAgentActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_factory)
         : logctx(_logctx), packet(_packet), basefactory(_factory)
     {
         allowFieldTranslation = _factory->getEnableFieldTranslation();
@@ -380,7 +380,7 @@ protected:
         meta.set(basehelper->queryOutputMeta());
     }
 
-    ~CRoxieSlaveActivity()
+    ~CRoxieAgentActivity()
     {
         ::Release(basehelper);
     }
@@ -394,7 +394,7 @@ protected:
     }
 
 public:
-    IMPLEMENT_IINTERFACE_USING(CInterfaceOf<IRoxieSlaveActivity>)
+    IMPLEMENT_IINTERFACE_USING(CInterfaceOf<IRoxieAgentActivity>)
 
     virtual const char *queryDynamicFileName() const = 0;
     virtual void setVariableFileInfo() = 0;
@@ -821,7 +821,7 @@ private:
 
 //================================================================================================
 
-class CRoxieDiskReadBaseActivity : public CRoxieSlaveActivity, implements IIndexReadContext//, implements IDiskReadActivity
+class CRoxieDiskReadBaseActivity : public CRoxieAgentActivity, implements IIndexReadContext//, implements IDiskReadActivity
 {
 protected:
     IHThorDiskReadBaseArg *helper;
@@ -843,11 +843,11 @@ protected:
     CriticalSection pcrit;
 
 public:
-    CRoxieDiskReadBaseActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieDiskReadBaseActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager,
         ITranslatorSet *_translators,
         unsigned _parallelPartNo, unsigned _numParallel, bool _forceUnkeyed)
-        : CRoxieSlaveActivity(_logctx, _packet, _hFactory, _aFactory),
+        : CRoxieAgentActivity(_logctx, _packet, _hFactory, _aFactory),
         parallelPartNo(_parallelPartNo),
         numParallel(_numParallel),
         forceUnkeyed(_forceUnkeyed),
@@ -868,7 +868,7 @@ public:
 
     virtual void onCreate()
     {
-        CRoxieSlaveActivity::onCreate();
+        CRoxieAgentActivity::onCreate();
         helper->createSegmentMonitors(this);
         const IKeyTranslator *keyTranslator = translators->queryKeyTranslator(0);  // any part would do - in-memory requires all actuals to have same layout
         if (keyTranslator)
@@ -944,7 +944,7 @@ public:
 
     virtual void abort() 
     {
-        CRoxieSlaveActivity::abort();
+        CRoxieAgentActivity::abort();
         CriticalBlock p(pcrit);
         if (processor)
             processor->abort();
@@ -983,14 +983,14 @@ public:
 
 };
 
-class CRoxieDiskBaseActivityFactory : public CSlaveActivityFactory
+class CRoxieDiskBaseActivityFactory : public CAgentActivityFactory
 {
 protected:
     Owned<ITranslatorSet> translators;
     Owned<IInMemoryIndexManager> manager;
 public:
     CRoxieDiskBaseActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
-        : CSlaveActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
+        : CAgentActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
     {
         Owned<IHThorDiskReadBaseArg> helper = (IHThorDiskReadBaseArg *) helperFactory();
         bool variableFileName = allFilesDynamic || queryFactory.isDynamic() || ((helper->getFlags() & (TDXvarfilename|TDXdynamicfilename)) != 0);
@@ -1053,7 +1053,7 @@ protected:
     IHThorDiskReadArg *helper;
 
 public:
-    CRoxieDiskReadActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieDiskReadActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager, ITranslatorSet *_translators)
         : CRoxieDiskReadBaseActivity(_logctx, _packet, _hFactory, _aFactory, _manager, _translators, 0, 1, false)
     {
@@ -1103,7 +1103,7 @@ protected:
     size32_t maxRowSize;
 
 public:
-    CRoxieCsvReadActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieCsvReadActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
                           IInMemoryIndexManager *_manager, ITranslatorSet *_translators, const IResolvedFile *_datafile, size32_t _maxRowSize)
         : CRoxieDiskReadBaseActivity(_logctx, _packet, _hFactory, _aFactory, _manager, _translators, 0, 1, true), datafile(_datafile), maxRowSize(_maxRowSize)
     {
@@ -1152,7 +1152,7 @@ protected:
     Owned<IDirectReader> ownedReader; // Ensure that the byte stream reader is released
 
 public:
-    CRoxieXmlReadActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieXmlReadActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager, ITranslatorSet *_translators)
         : CRoxieDiskReadBaseActivity(_logctx, _packet, _hFactory, _aFactory, _manager, _translators, 0, 1, true)
     {
@@ -1194,14 +1194,14 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieDiskReadActivity(logctx, packet, helperFactory, this, manager, translators);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskRead "));
+        return CAgentActivityFactory::toString(s.append("DiskRead "));
     }
 
 };
@@ -1220,14 +1220,14 @@ public:
             maxRowSize = workunit->getDebugValueInt(OPT_MAXCSVROWSIZE, defaultMaxCsvRowSize) * 1024 * 1024;
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieCsvReadActivity(logctx, packet, helperFactory, this, manager, translators, datafile, maxRowSize);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskRead "));
+        return CAgentActivityFactory::toString(s.append("DiskRead "));
     }
 
 };
@@ -1240,14 +1240,14 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieXmlReadActivity(logctx, packet, helperFactory, this, manager, translators);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskRead "));
+        return CAgentActivityFactory::toString(s.append("DiskRead "));
     }
 
 };
@@ -1531,17 +1531,17 @@ IInMemoryFileProcessor *createXmlRecordProcessor(CRoxieXmlReadActivity &owner, I
     return new XmlRecordProcessor(owner, _reader);
 }
 
-ISlaveActivityFactory *createRoxieCsvReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieCsvReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieCsvReadActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
 
-ISlaveActivityFactory *createRoxieXmlReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieXmlReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieXmlReadActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
 
-ISlaveActivityFactory *createRoxieDiskReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieDiskReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieDiskReadActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -1560,7 +1560,7 @@ protected:
     IHThorDiskNormalizeArg *helper;
 
 public:
-    CRoxieDiskNormalizeActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieDiskNormalizeActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager, ITranslatorSet *_translators)
         : CRoxieDiskReadBaseActivity(_logctx, _packet, _hFactory, _aFactory, _manager, _translators, 0, 1, false)
     {
@@ -1601,19 +1601,19 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieDiskNormalizeActivity(logctx, packet, helperFactory, this, manager, translators);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskNormalize "));
+        return CAgentActivityFactory::toString(s.append("DiskNormalize "));
     }
 
 };
 
-ISlaveActivityFactory *createRoxieDiskNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieDiskNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieDiskNormalizeActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -1701,7 +1701,7 @@ protected:
     IHThorDiskCountArg *helper;
 
 public:
-    CRoxieDiskCountActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieDiskCountActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager, ITranslatorSet *_translators)
         : CRoxieDiskReadBaseActivity(_logctx, _packet, _hFactory, _aFactory, _manager, _translators, 0, 1, false)
     {
@@ -1733,14 +1733,14 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieDiskCountActivity(logctx, packet, helperFactory, this, manager, translators);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskRead "));
+        return CAgentActivityFactory::toString(s.append("DiskRead "));
     }
 
 };
@@ -1801,7 +1801,7 @@ IInMemoryFileProcessor *createCountRecordProcessor(CRoxieDiskCountActivity &owne
     return new CountRecordProcessor(owner, reader);
 }
 
-ISlaveActivityFactory *createRoxieDiskCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieDiskCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieDiskCountActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -1820,7 +1820,7 @@ protected:
     IHThorDiskAggregateArg *helper;
 
 public:
-    CRoxieDiskAggregateActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieDiskAggregateActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager,
         ITranslatorSet *_translators,
         unsigned _parallelPartNo, unsigned _numParallel, bool _forceUnkeyed)
@@ -1852,17 +1852,17 @@ public:
 
 //================================================================================================
 
-class CParallelRoxieActivity : public CRoxieSlaveActivity
+class CParallelRoxieActivity : public CRoxieAgentActivity
 {
 protected:
-    IBasedArrayOf<CRoxieDiskReadBaseActivity, IRoxieSlaveActivity> parts;
+    IBasedArrayOf<CRoxieDiskReadBaseActivity, IRoxieAgentActivity> parts;
     unsigned numParallel;
     CriticalSection parCrit;
     Owned<IOutputRowDeserializer> deserializer;
 
 public:
-    CParallelRoxieActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_factory, unsigned _numParallel)
-        : CRoxieSlaveActivity(_logctx, _packet, _hFactory, _factory), numParallel(_numParallel)
+    CParallelRoxieActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_factory, unsigned _numParallel)
+        : CRoxieAgentActivity(_logctx, _packet, _hFactory, _factory), numParallel(_numParallel)
     {
         assertex(numParallel > 1);
     }
@@ -1907,10 +1907,10 @@ public:
             Owned<IMessagePacker> output = ROQ->createOutputStream(packet->queryHeader(), false, logctx);
             class casyncfor: public CAsyncFor
             {
-                IBasedArrayOf<CRoxieDiskReadBaseActivity, IRoxieSlaveActivity> &parts;
+                IBasedArrayOf<CRoxieDiskReadBaseActivity, IRoxieAgentActivity> &parts;
                 CParallelRoxieActivity &parent;
             public:
-                casyncfor(IBasedArrayOf<CRoxieDiskReadBaseActivity, IRoxieSlaveActivity> &_parts, CParallelRoxieActivity &_parent)
+                casyncfor(IBasedArrayOf<CRoxieDiskReadBaseActivity, IRoxieAgentActivity> &_parts, CParallelRoxieActivity &_parent)
                     : parts(_parts), parent(_parent)
                 {
                 }
@@ -1953,7 +1953,7 @@ protected:
     IHThorDiskAggregateArg *helper;
     OwnedConstRoxieRow finalRow;
 public:
-    CParallelRoxieDiskAggregateActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CParallelRoxieDiskAggregateActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager, ITranslatorSet *_translators, unsigned _numParallel) :
         CParallelRoxieActivity(_logctx, _packet, _hFactory, _aFactory, _numParallel)
     {
@@ -2077,7 +2077,7 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         if (parallelAggregate > 1)
             return new CParallelRoxieDiskAggregateActivity(logctx, packet, helperFactory, this, manager, translators, parallelAggregate);
@@ -2087,7 +2087,7 @@ public:
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskRead "));
+        return CAgentActivityFactory::toString(s.append("DiskRead "));
     }
 
 };
@@ -2138,7 +2138,7 @@ IInMemoryFileProcessor *createAggregateRecordProcessor(CRoxieDiskAggregateActivi
     return new AggregateRecordProcessor(_owner, _reader);
 }
 
-ISlaveActivityFactory *createRoxieDiskAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieDiskAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieDiskAggregateActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -2178,7 +2178,7 @@ protected:
     }
 
 public:
-    CRoxieDiskGroupAggregateActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CRoxieDiskGroupAggregateActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager,
         ITranslatorSet *_translators,
         unsigned partNo, unsigned numParts, bool _forceUnkeyed)
@@ -2222,7 +2222,7 @@ protected:
     Owned<IRowManager> rowManager;
 
 public:
-    CParallelRoxieDiskGroupAggregateActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory,
+    CParallelRoxieDiskGroupAggregateActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory,
         IInMemoryIndexManager *_manager, ITranslatorSet *_translators, unsigned _numParallel) :
         CParallelRoxieActivity(_logctx, _packet, _hFactory, _aFactory, _numParallel),
         helper((IHThorDiskGroupAggregateArg *) basehelper),
@@ -2327,7 +2327,7 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         if (parallelAggregate > 1)
             return new CParallelRoxieDiskGroupAggregateActivity(logctx, packet, helperFactory, this, manager, translators, parallelAggregate);
@@ -2337,7 +2337,7 @@ public:
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("DiskRead "));
+        return CAgentActivityFactory::toString(s.append("DiskRead "));
     }
 };
 
@@ -2382,7 +2382,7 @@ IInMemoryFileProcessor *createGroupAggregateRecordProcessor(RowAggregator &resul
     return new GroupAggregateRecordProcessor(results, helper, reader);
 }
 
-ISlaveActivityFactory *createRoxieDiskGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieDiskGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieDiskGroupAggregateActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -2390,7 +2390,7 @@ ISlaveActivityFactory *createRoxieDiskGroupAggregateActivityFactory(IPropertyTre
 
 //================================================================================================
 
-class CRoxieKeyedActivityFactory : public CSlaveActivityFactory
+class CRoxieKeyedActivityFactory : public CAgentActivityFactory
 {
     friend class CRoxieKeyedActivity;
 protected:
@@ -2402,7 +2402,7 @@ protected:
     IOutputMetaData *expectedMeta = nullptr;
 
     CRoxieKeyedActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
-        : CSlaveActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
+        : CAgentActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
     {
     }
 };
@@ -2437,7 +2437,7 @@ public:
     }
 };
 
-class CRoxieKeyedActivity : public CRoxieSlaveActivity
+class CRoxieKeyedActivity : public CRoxieAgentActivity
 {
     // Common base class for all activities that deal with keys - keyed join or indexread and its allies
 protected:
@@ -2506,8 +2506,8 @@ protected:
         logctx.noteStatistic(StNumIndexRowsRead, accepted+rejected);
     }
 
-    CRoxieKeyedActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieKeyedActivityFactory *_aFactory)
-        : CRoxieSlaveActivity(_logctx, _packet, _hFactory, _aFactory), 
+    CRoxieKeyedActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieKeyedActivityFactory *_aFactory)
+        : CRoxieAgentActivity(_logctx, _packet, _hFactory, _aFactory), 
         translators(_aFactory->translators),
         keyArray(_aFactory->keyArray),
         createSegmentMonitorsPending(true)
@@ -2574,7 +2574,7 @@ protected:
     }
 
 public:
-    CRoxieIndexActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory, unsigned _steppingOffset)
+    CRoxieIndexActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory, unsigned _steppingOffset)
         : CRoxieKeyedActivity(_logctx, _packet, _hFactory, _aFactory),
         steppingOffset(_steppingOffset),
         stepExtra(SSEFreadAhead, NULL)
@@ -2751,7 +2751,7 @@ protected:
     IHThorIndexReadArg * readHelper;
 
 public:
-    CRoxieIndexReadActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory, unsigned _steppingOffset)
+    CRoxieIndexReadActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory, unsigned _steppingOffset)
         : CRoxieIndexActivity(_logctx, _packet, _hFactory, _aFactory, _steppingOffset)
     {
         onCreate();
@@ -3034,18 +3034,18 @@ public:
         }
     }
     
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieIndexReadActivity(logctx, packet, helperFactory, this, steppingOffset);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("INDEXREAD "));
+        return CAgentActivityFactory::toString(s.append("INDEXREAD "));
     }
 };
 
-ISlaveActivityFactory *createRoxieIndexReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieIndexReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieIndexReadActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -3059,7 +3059,7 @@ protected:
     IHThorCompoundNormalizeExtra * normalizeHelper;
 
 public:
-    CRoxieIndexNormalizeActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory)
+    CRoxieIndexNormalizeActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory)
         : CRoxieIndexActivity(_logctx, _packet, _hFactory, _aFactory, 0) //MORE - stepping?
     {
         onCreate();
@@ -3185,18 +3185,18 @@ public:
         init(helper, graphNode);
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieIndexNormalizeActivity(logctx, packet, helperFactory, this);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("IndexNormalize "));
+        return CAgentActivityFactory::toString(s.append("IndexNormalize "));
     }
 };
 
-ISlaveActivityFactory *createRoxieIndexNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieIndexNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieIndexNormalizeActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -3212,7 +3212,7 @@ protected:
     unsigned __int64 keyedLimit;
 
 public:
-    CRoxieIndexCountActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory)
+    CRoxieIndexCountActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory)
         : CRoxieIndexActivity(_logctx, _packet, _hFactory, _aFactory, 0)
     {
         onCreate();
@@ -3320,18 +3320,18 @@ public:
         init(helper, graphNode);
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieIndexCountActivity(logctx, packet, helperFactory, this);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("INDEXCOUNT "));
+        return CAgentActivityFactory::toString(s.append("INDEXCOUNT "));
     }
 };
 
-ISlaveActivityFactory *createRoxieIndexCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieIndexCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieIndexCountActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -3344,7 +3344,7 @@ protected:
     IHThorCompoundAggregateExtra * aggregateHelper;
 
 public:
-    CRoxieIndexAggregateActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory)
+    CRoxieIndexAggregateActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory)
         : CRoxieIndexActivity(_logctx, _packet, _hFactory, _aFactory, 0)
     {
         onCreate();
@@ -3415,18 +3415,18 @@ public:
         init(helper, graphNode);
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieIndexAggregateActivity(logctx, packet, helperFactory, this);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("INDEXAGGREGATE "));
+        return CAgentActivityFactory::toString(s.append("INDEXAGGREGATE "));
     }
 };
 
-ISlaveActivityFactory *createRoxieIndexAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieIndexAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieIndexAggregateActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -3444,7 +3444,7 @@ protected:
 public:
     IMPLEMENT_IINTERFACE_USING(CRoxieIndexActivity)
 
-    CRoxieIndexGroupAggregateActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory, ThorActivityKind _kind)
+    CRoxieIndexGroupAggregateActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieIndexActivityFactory *_aFactory, ThorActivityKind _kind)
         : CRoxieIndexActivity(_logctx, _packet, _hFactory, _aFactory, 0),
           aggregateHelper((IHThorIndexGroupAggregateArg *) basehelper),
           results(*aggregateHelper, *aggregateHelper), kind(_kind)
@@ -3577,32 +3577,32 @@ public:
         init(helper, graphNode);
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieIndexGroupAggregateActivity(logctx, packet, helperFactory, this, kind);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("INDEXGROUPAGGREGATE "));
+        return CAgentActivityFactory::toString(s.append("INDEXGROUPAGGREGATE "));
     }
 };
 
-ISlaveActivityFactory *createRoxieIndexGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory, ThorActivityKind _kind)
+IAgentActivityFactory *createRoxieIndexGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory, ThorActivityKind _kind)
 {
     return new CRoxieIndexGroupAggregateActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory, _kind);
 }
 
 //================================================================================================
 
-class CRoxieFetchActivityFactory : public CSlaveActivityFactory
+class CRoxieFetchActivityFactory : public CAgentActivityFactory
 {
 public:
     Owned<ITranslatorSet> translators;
     Owned<IFileIOArray> fileArray;
 
     CRoxieFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
-        : CSlaveActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
+        : CAgentActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
     {
         Owned<IHThorFetchBaseArg> helper = (IHThorFetchBaseArg *) helperFactory();
         bool variableFileName = allFilesDynamic || queryFactory.isDynamic() || ((helper->getFetchFlags() & (FFvarfilename|FFdynamicfilename)) != 0);
@@ -3622,15 +3622,15 @@ public:
         }
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const;
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const;
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("FETCH "));
+        return CAgentActivityFactory::toString(s.append("FETCH "));
     }
 };
 
-class CRoxieFetchActivityBase : public CRoxieSlaveActivity
+class CRoxieFetchActivityBase : public CRoxieAgentActivity
 {
 protected:
     IHThorFetchBaseArg *helper;
@@ -3648,11 +3648,11 @@ protected:
     virtual size32_t doFetch(ARowBuilder & rowBuilder, offset_t pos, offset_t rawpos, void *inputData) = 0;
 
 public:
-    CRoxieFetchActivityBase(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet,  HelperFactory *_hFactory,
+    CRoxieFetchActivityBase(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet,  HelperFactory *_hFactory,
                             const CRoxieFetchActivityFactory *_aFactory,
                             ITranslatorSet *_translators,
                             IFileIOArray *_files)
-        : CRoxieSlaveActivity(_logctx, _packet, _hFactory, _aFactory), factory(_aFactory), translators(_translators), files(_files)
+        : CRoxieAgentActivity(_logctx, _packet, _hFactory, _aFactory), factory(_aFactory), translators(_translators), files(_files)
     {
         helper = (IHThorFetchBaseArg *) basehelper;
         base = 0;
@@ -3750,7 +3750,7 @@ class CRoxieFetchActivity : public CRoxieFetchActivityBase
     Owned<ISourceRowPrefetcher> rowPrefetcher;
 
 public:
-    CRoxieFetchActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory,
+    CRoxieFetchActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory,
                         const CRoxieFetchActivityFactory *_aFactory,
                         ITranslatorSet *_translators,
                         IFileIOArray *_files)
@@ -3793,7 +3793,7 @@ public:
     }
 };
 
-IRoxieSlaveActivity *CRoxieFetchActivityFactory::createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+IRoxieAgentActivity *CRoxieFetchActivityFactory::createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
 {
     return new CRoxieFetchActivity(logctx, packet, helperFactory, this, translators, fileArray);
 }
@@ -3807,7 +3807,7 @@ class CRoxieCSVFetchActivity : public CRoxieFetchActivityBase
     CThorStreamDeserializerSource deserializeSource;
 
 public:
-    CRoxieCSVFetchActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory,
+    CRoxieCSVFetchActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory,
                            const CRoxieFetchActivityFactory *_aFactory,
                            ITranslatorSet *_translators,
                            IFileIOArray *_files,
@@ -3878,7 +3878,7 @@ class CRoxieXMLFetchActivity : public CRoxieFetchActivityBase, implements IXMLSe
 public:
     IMPLEMENT_IINTERFACE_USING(CRoxieFetchActivityBase)
 
-    CRoxieXMLFetchActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory,
+    CRoxieXMLFetchActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory,
                            const CRoxieFetchActivityFactory *_aFactory,
                            ITranslatorSet *_translators,
                            IFileIOArray *_files,
@@ -3953,7 +3953,7 @@ public:
             maxRowSize = workunit->getDebugValueInt(OPT_MAXCSVROWSIZE, defaultMaxCsvRowSize) * 1024 * 1024;
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieCSVFetchActivity(logctx, packet, helperFactory, this, translators, fileArray, maxColumns, maxRowSize);
     }
@@ -3967,24 +3967,24 @@ public:
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieXMLFetchActivity(logctx, packet, helperFactory, this, translators, fileArray, 4096);
     }
 };
 
 
-ISlaveActivityFactory *createRoxieFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieFetchActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
 
-ISlaveActivityFactory *createRoxieCSVFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieCSVFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieCSVFetchActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
 
-ISlaveActivityFactory *createRoxieXMLFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieXMLFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieXMLFetchActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -4018,11 +4018,11 @@ public:
         }
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const;
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const;
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("KEYEDJOIN INDEX "));
+        return CAgentActivityFactory::toString(s.append("KEYEDJOIN INDEX "));
     }
 
 };
@@ -4035,7 +4035,7 @@ class CRoxieKeyedJoinIndexActivity : public CRoxieKeyedActivity
 
     unsigned inputLength;
     char *inputData;
-    Owned<IRoxieSlaveActivity> rootIndexActivity;
+    Owned<IRoxieAgentActivity> rootIndexActivity;
     IIndexReadActivityInfo *rootIndex;
 
     unsigned processed;
@@ -4044,7 +4044,7 @@ class CRoxieKeyedJoinIndexActivity : public CRoxieKeyedActivity
     unsigned inputDone;
 
 public:
-    CRoxieKeyedJoinIndexActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieKeyedJoinIndexActivityFactory *_aFactory)
+    CRoxieKeyedJoinIndexActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieKeyedJoinIndexActivityFactory *_aFactory)
         : CRoxieKeyedActivity(_logctx, _packet, _hFactory, _aFactory), factory(_aFactory)
     {
         helper = (IHThorKeyedJoinArg *) basehelper;
@@ -4106,7 +4106,7 @@ public:
             newHeader->queryHash = indexActivityId.queryHash;
 
             Owned<IRoxieQueryPacket> indexPacket = createRoxiePacket(indexPacketData);
-            Owned<ISlaveActivityFactory> indexActivityFactory = factory->queryQueryFactory().getSlaveActivityFactory(indexActivityId.activityId);
+            Owned<IAgentActivityFactory> indexActivityFactory = factory->queryQueryFactory().getAgentActivityFactory(indexActivityId.activityId);
             assertex(indexActivityFactory != NULL);
             rootIndexActivity.setown(indexActivityFactory->createActivity(logctx, indexPacket));
             rootIndex = rootIndexActivity->queryIndexReadActivity();
@@ -4140,7 +4140,7 @@ public:
     }
 };
 
-IRoxieSlaveActivity *CRoxieKeyedJoinIndexActivityFactory::createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+IRoxieAgentActivity *CRoxieKeyedJoinIndexActivityFactory::createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
 {
     return new CRoxieKeyedJoinIndexActivity(logctx, packet, helperFactory, this);
 }
@@ -4324,21 +4324,21 @@ IMessagePacker *CRoxieKeyedJoinIndexActivity::process()
 
 //================================================================================================
 
-ISlaveActivityFactory *createRoxieKeyedJoinIndexActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieKeyedJoinIndexActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieKeyedJoinIndexActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
 
 //================================================================================================
 
-class CRoxieKeyedJoinFetchActivityFactory : public CSlaveActivityFactory
+class CRoxieKeyedJoinFetchActivityFactory : public CAgentActivityFactory
 {
 public:
     Owned<ITranslatorSet> translators;
     Owned<IFileIOArray> files;
 
     CRoxieKeyedJoinFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
-        : CSlaveActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
+        : CAgentActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory)
     {
         Owned<IHThorKeyedJoinArg> helper = (IHThorKeyedJoinArg *) helperFactory();
         assertex(helper->diskAccessRequired());
@@ -4360,15 +4360,15 @@ public:
 
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const;
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const;
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("KEYEDJOIN FETCH "));
+        return CAgentActivityFactory::toString(s.append("KEYEDJOIN FETCH "));
     }
 };
 
-class CRoxieKeyedJoinFetchActivity : public CRoxieSlaveActivity
+class CRoxieKeyedJoinFetchActivity : public CRoxieAgentActivity
 {
     IHThorKeyedJoinArg *helper;
     Owned<IFileIO> rawFile;
@@ -4392,9 +4392,9 @@ class CRoxieKeyedJoinFetchActivity : public CRoxieSlaveActivity
     }
 
 public:
-    CRoxieKeyedJoinFetchActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieKeyedJoinFetchActivityFactory *_aFactory,
+    CRoxieKeyedJoinFetchActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CRoxieKeyedJoinFetchActivityFactory *_aFactory,
                                  IFileIOArray *_files, ITranslatorSet *_translators)
-        : CRoxieSlaveActivity(_logctx, _packet, _hFactory, _aFactory),
+        : CRoxieAgentActivity(_logctx, _packet, _hFactory, _aFactory),
           translators(_translators),
           files(_files)
     {
@@ -4518,12 +4518,12 @@ IMessagePacker *CRoxieKeyedJoinFetchActivity::process()
         return output.getClear();
 }
 
-IRoxieSlaveActivity *CRoxieKeyedJoinFetchActivityFactory::createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+IRoxieAgentActivity *CRoxieKeyedJoinFetchActivityFactory::createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
 {
     return new CRoxieKeyedJoinFetchActivity(logctx, packet, helperFactory, this, files, translators);
 }
 
-ISlaveActivityFactory *createRoxieKeyedJoinFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
+IAgentActivityFactory *createRoxieKeyedJoinFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory)
 {
     return new CRoxieKeyedJoinFetchActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory);
 }
@@ -4531,7 +4531,7 @@ ISlaveActivityFactory *createRoxieKeyedJoinFetchActivityFactory(IPropertyTree &_
 
 //================================================================================================
 
-class CRoxieRemoteActivity : public CRoxieSlaveActivity
+class CRoxieRemoteActivity : public CRoxieAgentActivity
 {
 protected:
     IHThorRemoteArg * remoteHelper;
@@ -4539,8 +4539,8 @@ protected:
     unsigned remoteId;
 
 public:
-    CRoxieRemoteActivity(SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CSlaveActivityFactory *_aFactory, unsigned _remoteId)
-        : CRoxieSlaveActivity(_logctx, _packet, _hFactory, _aFactory), 
+    CRoxieRemoteActivity(AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, HelperFactory *_hFactory, const CAgentActivityFactory *_aFactory, unsigned _remoteId)
+        : CRoxieAgentActivity(_logctx, _packet, _hFactory, _aFactory), 
         remoteId(_remoteId)
     {
         remoteHelper = (IHThorRemoteArg *) basehelper;
@@ -4641,28 +4641,28 @@ public:
 
 //================================================================================================
 
-class CRoxieRemoteActivityFactory : public CSlaveActivityFactory
+class CRoxieRemoteActivityFactory : public CAgentActivityFactory
 {
     unsigned remoteId;
 
 public:
     CRoxieRemoteActivityFactory(IPropertyTree &graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory, unsigned _remoteId)
-        : CSlaveActivityFactory(graphNode, _subgraphId, _queryFactory, _helperFactory), remoteId(_remoteId)
+        : CAgentActivityFactory(graphNode, _subgraphId, _queryFactory, _helperFactory), remoteId(_remoteId)
     {
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         return new CRoxieRemoteActivity(logctx, packet, helperFactory, this, remoteId);
     }
 
     virtual StringBuffer &toString(StringBuffer &s) const
     {
-        return CSlaveActivityFactory::toString(s.append("Remote "));
+        return CAgentActivityFactory::toString(s.append("Remote "));
     }
 };
 
-ISlaveActivityFactory *createRoxieRemoteActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory, unsigned _remoteId)
+IAgentActivityFactory *createRoxieRemoteActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, HelperFactory *_helperFactory, unsigned _remoteId)
 {
     return new CRoxieRemoteActivityFactory(_graphNode, _subgraphId, _queryFactory, _helperFactory, _remoteId);
 }
@@ -4670,7 +4670,7 @@ ISlaveActivityFactory *createRoxieRemoteActivityFactory(IPropertyTree &_graphNod
 
 //================================================================================================
 
-class CRoxieDummyActivityFactory : public CSlaveActivityFactory  // not a real activity - just used to properly link files
+class CRoxieDummyActivityFactory : public CAgentActivityFactory  // not a real activity - just used to properly link files
 {
 protected:
     Owned<const IResolvedFile> indexfile;
@@ -4679,7 +4679,7 @@ protected:
 
 public:
     CRoxieDummyActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, bool isLoadDataOnly)
-        : CSlaveActivityFactory(_graphNode, _subgraphId, _queryFactory, NULL)
+        : CAgentActivityFactory(_graphNode, _subgraphId, _queryFactory, NULL)
     {
         if (_graphNode.getPropBool("att[@name='_isSpill']/@value", false) || _graphNode.getPropBool("att[@name='_isSpillGlobal']/@value", false))
             return;  // ignore 'spills'
@@ -4719,7 +4719,7 @@ public:
         }
     }
 
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const
     {
         throwUnexpected();  // don't actually want to create an activity
     }
@@ -4727,7 +4727,7 @@ public:
 };
 //================================================================================================
 
-ISlaveActivityFactory *createRoxieDummyActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, bool isLoadDataOnly)
+IAgentActivityFactory *createRoxieDummyActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, bool isLoadDataOnly)
 {
     // MORE - bool isLoadDataOnly may need to be an enum if more than just LOADDATAONLY and suspended queries use this
     return new CRoxieDummyActivityFactory(_graphNode, _subgraphId, _queryFactory, isLoadDataOnly);

roxie/ccd/ccdactivities.hpp

@@ -32,7 +32,7 @@ interface IRoxiePackage;
 interface IQueryFactory;
 interface IIndexReadActivityInfo;
 
-// That which is common between Activity factory on slave and Roxie server....
+// That which is common between Activity factory on agent and Roxie server....
 
 interface IActivityFactory : extends IInterface
 {
@@ -49,7 +49,7 @@ interface IActivityFactory : extends IInterface
     virtual void mergeStats(const CRuntimeStatisticCollection &from) const = 0;
 };
 
-interface IRoxieSlaveActivity : extends IInterface
+interface IRoxieAgentActivity : extends IInterface
 {
     virtual IMessagePacker *process() = 0;
     virtual bool check() = 0;
@@ -60,9 +60,9 @@ interface IRoxieSlaveActivity : extends IInterface
     virtual IIndexReadActivityInfo *queryIndexReadActivity() = 0;
 };
 
-interface ISlaveActivityFactory : extends IActivityFactory
+interface IAgentActivityFactory : extends IActivityFactory
 {
-    virtual IRoxieSlaveActivity *createActivity(SlaveContextLogger &logctx, IRoxieQueryPacket *packet) const = 0;
+    virtual IRoxieAgentActivity *createActivity(AgentContextLogger &logctx, IRoxieQueryPacket *packet) const = 0;
     virtual StringBuffer &toString(StringBuffer &ret) const = 0;
     virtual const char *queryQueryName() const = 0;
     virtual void addChildQuery(unsigned id, ActivityArray *childQuery) = 0;
@@ -85,29 +85,29 @@ static inline int KEYEDJOIN_RECORD_SIZE(int dataSize)
     return offsetof(KeyedJoinHeader, rhsdata) + dataSize;
 }
 
-ISlaveActivityFactory *createRoxieCsvReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieXmlReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieDiskReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieDiskNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieDiskCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieDiskAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieDiskGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieIndexReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieIndexNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieIndexCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieIndexAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieIndexGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory, ThorActivityKind _kind);
-ISlaveActivityFactory *createRoxieFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieXMLFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieCSVFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieKeyedJoinIndexActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieKeyedJoinFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
-ISlaveActivityFactory *createRoxieRemoteActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory, unsigned _remoteId);
-
-ISlaveActivityFactory *createRoxieDummyActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, bool isLoadDataOnly);
-
-
-// Code for processing in-memory data quickly, shared between Roxie server and slave implementations
+IAgentActivityFactory *createRoxieCsvReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieXmlReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieDiskReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieDiskNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieDiskCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieDiskAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieDiskGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieIndexReadActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieIndexNormalizeActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieIndexCountActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieIndexAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieIndexGroupAggregateActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory, ThorActivityKind _kind);
+IAgentActivityFactory *createRoxieFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieXMLFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieCSVFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieKeyedJoinIndexActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieKeyedJoinFetchActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory);
+IAgentActivityFactory *createRoxieRemoteActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &queryFactory, HelperFactory *_factory, unsigned _remoteId);
+
+IAgentActivityFactory *createRoxieDummyActivityFactory(IPropertyTree &_graphNode, unsigned _subgraphId, IQueryFactory &_queryFactory, bool isLoadDataOnly);
+
+
+// Code for processing in-memory data quickly, shared between Roxie server and agent implementations
 
 interface IInMemoryFileProcessor : extends IInterface
 {

roxie/ccd/ccdcontext.cpp

@@ -49,17 +49,17 @@ using roxiemem::IRowManager;
 //=======================================================================================================================
 
 #define DEBUGEE_TIMEOUT 10000
-class CSlaveDebugContext : public CBaseDebugContext
+class CAgentDebugContext : public CBaseDebugContext
 {
     /*
 
-    Some thoughts on slave debugging
-    1. Something like a ping can be used to get data from slave when needed
+    Some thoughts on agent debugging
+    1. Something like a ping can be used to get data from agent when needed
     2. Should disable IBYTI processing (always use primary) - DONE
        and server-side caching - DONE
-    3. Roxie server can know what slave transactions are pending by intercepting the sends - no need for slave to call back just to indicate start of slave subgraph
-    4. There is a problem when a slave hits a breakpoint in that the breakpoint cound have been deleted by the time it gets a chance to tell the Roxie server - can't
-       happen in local case because of the critical block at the head of checkBreakpoint but the local copy of BPs out on slave CAN get out of date. Should we care?
+    3. Roxie server can know what agent transactions are pending by intercepting the sends - no need for agent to call back just to indicate start of agent subgraph
+    4. There is a problem when a agent hits a breakpoint in that the breakpoint cound have been deleted by the time it gets a chance to tell the Roxie server - can't
+       happen in local case because of the critical block at the head of checkBreakpoint but the local copy of BPs out on agent CAN get out of date. Should we care?
        Should there be a "Sorry, your breakpoints are out of date, here's the new set" response?
        Actually what we do is recheck the BP on the server, and ensure that breakpoint indexes are persistent. DONE
     5. We need to serialize over our graph info if changed since last time.
@@ -75,7 +75,7 @@ class CSlaveDebugContext : public CBaseDebugContext
     const IRoxieContextLogger &logctx; // hides base class definition with more derived class pointer
 
 public:
-    CSlaveDebugContext(IRoxieSlaveContext *_ctx, const IRoxieContextLogger &_logctx, RoxiePacketHeader &_header)
+    CAgentDebugContext(IRoxieAgentContext *_ctx, const IRoxieContextLogger &_logctx, RoxiePacketHeader &_header)
         : CBaseDebugContext(_logctx), header(_header), logctx(_logctx)
     {
         channel = header.channel;
@@ -167,7 +167,7 @@ public:
 
     virtual IRoxieQueryPacket *onDebugCallback(const RoxiePacketHeader &header, size32_t len, char *data)
     {
-        // MORE - Implies a server -> slave child -> slave grandchild type situation - need to pass call on to Roxie server (rather as I do for file callback)
+        // MORE - Implies a server -> agent child -> agent grandchild type situation - need to pass call on to Roxie server (rather as I do for file callback)
         UNIMPLEMENTED;
     }
 
@@ -1157,7 +1157,7 @@ public:
 //---------------------------------------------------------------------------------------
 
 static const StatisticsMapping graphStatistics({});
-class CRoxieContextBase : implements IRoxieSlaveContext, implements ICodeContext, implements roxiemem::ITimeLimiter, implements IRowAllocatorMetaActIdCacheCallback, public CInterface
+class CRoxieContextBase : implements IRoxieAgentContext, implements ICodeContext, implements roxiemem::ITimeLimiter, implements IRowAllocatorMetaActIdCacheCallback, public CInterface
 {
 protected:
     Owned<IWUGraphStats> graphStats;   // This needs to be destroyed very late (particularly, after the childgraphs)
@@ -1172,7 +1172,7 @@ protected:
     Owned<IPropertyTree> probeQuery;
     unsigned lastWuAbortCheck;
     unsigned startTime;
-    unsigned totSlavesReplyLen;
+    unsigned totAgentsReplyLen;
     CCycleTimer elapsedTimer;
 
     QueryOptions options;
@@ -1251,7 +1251,7 @@ public:
         xmlStoredDatasetReadFlags = ptr_none;
         aborted = false;
         exceptionLogged = false;
-        totSlavesReplyLen = 0;
+        totAgentsReplyLen = 0;
 
         allocatorMetaCache.setown(createRowAllocatorCache(this));
         rowManager.setown(roxiemem::createRowManager(options.memoryLimit, this, logctx, allocatorMetaCache, false));
@@ -1374,7 +1374,7 @@ public:
 
     virtual void checkAbort()
     {
-        // MORE - really should try to apply limits at slave end too
+        // MORE - really should try to apply limits at agent end too
 #ifdef __linux__
         if (linuxYield)
             sched_yield();
@@ -1471,7 +1471,7 @@ public:
     virtual void noteChildGraph(unsigned id, IActivityGraph *childGraph)
     {
         if (queryTraceLevel() > 10)
-            CTXLOG("CSlaveContext %p noteChildGraph %d=%p", this, id, childGraph);
+            CTXLOG("CAgentContext %p noteChildGraph %d=%p", this, id, childGraph);
         childGraphs.setValue(id, childGraph);
     }
 
@@ -1644,7 +1644,7 @@ public:
     virtual IActivityGraph * queryChildGraph(unsigned  id)
     {
         if (queryTraceLevel() > 10)
-            CTXLOG("CSlaveContext %p resolveChildGraph %d", this, id);
+            CTXLOG("CAgentContext %p resolveChildGraph %d", this, id);
         if (id == 0)
             return graph;
         IActivityGraph *childGraph = childGraphs.getValue(id);
@@ -1668,10 +1668,10 @@ public:
         return *rowManager;
     }
 
-    virtual void addSlavesReplyLen(unsigned len)
+    virtual void addAgentsReplyLen(unsigned len)
     {
         CriticalBlock b(statsCrit); // MORE: change to atomic_add, or may not need it at all?
-        totSlavesReplyLen += len;
+        totAgentsReplyLen += len;
     }
 
     virtual const char *loadResource(unsigned id)
@@ -1716,7 +1716,7 @@ public:
     virtual char *getDaliServers() { throwUnexpected(); }
     virtual unsigned getWorkflowId() { return 0; } // this is a virtual which is implemented in IGlobalContext
 
-    // The following from ICodeContext should never be executed in slave activity. If we are on Roxie server, they will be implemented by more derived CRoxieServerContext class
+    // The following from ICodeContext should never be executed in agent activity. If we are on Roxie server, they will be implemented by more derived CRoxieServerContext class
     virtual void setResultBool(const char *name, unsigned sequence, bool value) { throwUnexpected(); }
     virtual void setResultData(const char *name, unsigned sequence, int len, const void * data) { throwUnexpected(); }
     virtual void setResultDecimal(const char * stepname, unsigned sequence, int len, int precision, bool isSigned, const void *val) { throwUnexpected(); }
@@ -2102,7 +2102,7 @@ protected:
             if (context)
                 return *context;
             else
-                throw MakeStringException(ROXIE_CODEGEN_ERROR, "Code generation error - attempting to access stored variable on slave");
+                throw MakeStringException(ROXIE_CODEGEN_ERROR, "Code generation error - attempting to access stored variable on agent");
         case ResultSequencePersist:
             {
                 CriticalBlock b(contextCrit);
@@ -2278,27 +2278,27 @@ protected:
 
 //-----------------------------------------------------------------------------------------------
 
-class CSlaveContext : public CRoxieContextBase
+class CAgentContext : public CRoxieContextBase
 {
 protected:
     RoxiePacketHeader *header;
 
 public:
-    CSlaveContext(const IQueryFactory *_factory, const SlaveContextLogger &_logctx, IRoxieQueryPacket *_packet, bool _hasChildren)
+    CAgentContext(const IQueryFactory *_factory, const AgentContextLogger &_logctx, IRoxieQueryPacket *_packet, bool _hasChildren)
     : CRoxieContextBase(_factory, _logctx)
     {
         if (_packet)
         {
             header = &_packet->queryHeader();
             const byte *traceInfo = _packet->queryTraceInfo();
-            options.setFromSlaveLoggingFlags(*traceInfo);
+            options.setFromAgentLoggingFlags(*traceInfo);
             bool debuggerActive = (*traceInfo & LOGGING_DEBUGGERACTIVE) != 0 && _hasChildren;  // No option to debug simple remote activity
             if (debuggerActive)
             {
-                CSlaveDebugContext *slaveDebugContext = new CSlaveDebugContext(this, logctx, *header);
-                slaveDebugContext->init(_packet);
-                debugContext.setown(slaveDebugContext);
-                probeManager.setown(createDebugManager(debugContext, "slaveDebugger"));
+                CAgentDebugContext *agentDebugContext = new CAgentDebugContext(this, logctx, *header);
+                agentDebugContext->init(_packet);
+                debugContext.setown(agentDebugContext);
+                probeManager.setown(createDebugManager(debugContext, "agentDebugger"));
             }
         }
         else
@@ -2323,7 +2323,7 @@ public:
     virtual const IResolvedFile *resolveLFN(const char *filename, bool isOpt, bool isPrivilegedUser)
     {
         CDateTime cacheDate; // Note - this is empty meaning we don't know...
-        return querySlaveDynamicFileCache()->lookupDynamicFile(*this, filename, cacheDate, 0, header, isOpt, false);
+        return queryAgentDynamicFileCache()->lookupDynamicFile(*this, filename, cacheDate, 0, header, isOpt, false);
     }
 
     virtual IRoxieWriteHandler *createLFN(const char *filename, bool overwrite, bool extend, const StringArray &clusters, bool isPrivilegedUser)
@@ -2333,7 +2333,7 @@ public:
 
     virtual void onFileCallback(const RoxiePacketHeader &header, const char *lfn, bool isOpt, bool isLocal, bool isPrivilegedUser)
     {
-        // On a slave, we need to request info using our own header (not the one passed in) and need to get global rather than just local info
+        // On a agent, we need to request info using our own header (not the one passed in) and need to get global rather than just local info
         // (possibly we could get just local if the channel matches but not sure there is any point)
         Owned<const IResolvedFile> dFile = resolveLFN(lfn, isOpt, isPrivilegedUser);
         if (dFile)
@@ -2354,20 +2354,20 @@ public:
 
     virtual void noteProcessed(unsigned subgraphId, unsigned activityId, unsigned _idx, unsigned _processed, unsigned _strands) const
     {
-        const SlaveContextLogger &slaveLogCtx = static_cast<const SlaveContextLogger &>(logctx);
-        slaveLogCtx.putStatProcessed(subgraphId, activityId, _idx, _processed, _strands);
+        const AgentContextLogger &agentLogCtx = static_cast<const AgentContextLogger &>(logctx);
+        agentLogCtx.putStatProcessed(subgraphId, activityId, _idx, _processed, _strands);
     }
 
     virtual void mergeActivityStats(const CRuntimeStatisticCollection &fromStats, unsigned subgraphId, unsigned activityId) const
     {
-        const SlaveContextLogger &slaveLogCtx = static_cast<const SlaveContextLogger &>(logctx);
-        slaveLogCtx.putStats(subgraphId, activityId, fromStats);
+        const AgentContextLogger &agentLogCtx = static_cast<const AgentContextLogger &>(logctx);
+        agentLogCtx.putStats(subgraphId, activityId, fromStats);
     }
 };
 
-IRoxieSlaveContext *createSlaveContext(const IQueryFactory *_factory, const SlaveContextLogger &_logctx, IRoxieQueryPacket *packet, bool hasChildren)
+IRoxieAgentContext *createAgentContext(const IQueryFactory *_factory, const AgentContextLogger &_logctx, IRoxieQueryPacket *packet, bool hasChildren)
 {
-    return new CSlaveContext(_factory, _logctx, packet, hasChildren);
+    return new CAgentContext(_factory, _logctx, packet, hasChildren);
 }
 
 //-----------------------------------------------------------------------------------------------
@@ -2381,9 +2381,9 @@ class CRoxieServerDebugContext : extends CBaseServerDebugContext
     //    semaphore and it all becomes easier to code... Anything calling checkBreakPoint while program state is "in debugger" will block on that critSec.
     // 3. I think we need to recheck breakpoints on Roxie server but just check not deleted
 public:
-    IRoxieSlaveContext *ctx;
+    IRoxieAgentContext *ctx;
 
-    CRoxieServerDebugContext(IRoxieSlaveContext *_ctx, const IContextLogger &_logctx, IPropertyTree *_queryXGMML)
+    CRoxieServerDebugContext(IRoxieAgentContext *_ctx, const IContextLogger &_logctx, IPropertyTree *_queryXGMML)
         : CBaseServerDebugContext(_logctx, _queryXGMML), ctx(_ctx)
     {
     }
@@ -2433,45 +2433,45 @@ public:
 
     virtual IRoxieQueryPacket *onDebugCallback(const RoxiePacketHeader &header, size32_t len, char *data)
     {
-        MemoryBuffer slaveInfo;
-        slaveInfo.setBuffer(len, data, false);
+        MemoryBuffer agentInfo;
+        agentInfo.setBuffer(len, data, false);
         unsigned debugSequence;
-        slaveInfo.read(debugSequence);
+        agentInfo.read(debugSequence);
         {
             CriticalBlock b(breakCrit); // we want to wait until it's our turn before updating the graph info or the counts get ahead of the current row and life is confusing
-            char slaveStateChar;
-            slaveInfo.read(slaveStateChar);
-            DebugState slaveState = (DebugState) slaveStateChar;
-            if (slaveState==DebugStateGraphFinished)
+            char agentStateChar;
+            agentInfo.read(agentStateChar);
+            DebugState agentState = (DebugState) agentStateChar;
+            if (agentState==DebugStateGraphFinished)
             {
                 unsigned numCounts;
-                slaveInfo.read(numCounts);
+                agentInfo.read(numCounts);
                 while (numCounts)
                 {
                     StringAttr edgeId;
                     unsigned edgeCount;
-                    slaveInfo.read(edgeId);
-                    slaveInfo.read(edgeCount);
+                    agentInfo.read(edgeId);
+                    agentInfo.read(edgeCount);
                     Owned<IGlobalEdgeRecord> thisEdge = getEdgeRecord(edgeId);
                     thisEdge->incrementCount(edgeCount, sequence);
                     numCounts--;
                 }
             }
-            slaveInfo.read(currentBreakpointUID);
-            memsize_t slaveActivity;
+            agentInfo.read(currentBreakpointUID);
+            memsize_t agentActivity;
             unsigned channel;
             __uint64 tmp;
-            slaveInfo.read(tmp);
-            slaveActivity = (memsize_t)tmp;
-            slaveInfo.read(channel);
+            agentInfo.read(tmp);
+            agentActivity = (memsize_t)tmp;
+            agentInfo.read(channel);
             assertex(currentGraph);
-            currentGraph->deserializeProxyGraphs(slaveState, slaveInfo, (IActivityBase *) slaveActivity, channel);
-            if (slaveState != DebugStateGraphFinished) // MORE - this is debatable - may (at least sometimes) want a child graph finished to be a notified event...
+            currentGraph->deserializeProxyGraphs(agentState, agentInfo, (IActivityBase *) agentActivity, channel);
+            if (agentState != DebugStateGraphFinished) // MORE - this is debatable - may (at least sometimes) want a child graph finished to be a notified event...
             {
-                StringBuffer slaveActivityId;
-                slaveInfo.read(slaveActivityId);
-                IActivityDebugContext *slaveActivityCtx = slaveActivityId.length() ? currentGraph->lookupActivityByEdgeId(slaveActivityId.str()) : NULL;
-                checkBreakpoint(slaveState, slaveActivityCtx , NULL);
+                StringBuffer agentActivityId;
+                agentInfo.read(agentActivityId);
+                IActivityDebugContext *agentActivityCtx = agentActivityId.length() ? currentGraph->lookupActivityByEdgeId(agentActivityId.str()) : NULL;
+                checkBreakpoint(agentState, agentActivityCtx , NULL);
             }
         }
         MemoryBuffer mb;
@@ -2573,7 +2573,7 @@ protected:
 
     void init()
     {
-        totSlavesReplyLen = 0;
+        totAgentsReplyLen = 0;
         isRaw = false;
         isBlocked = false;
         isNative = true;
@@ -2784,9 +2784,9 @@ public:
         return rowManager->getMemoryUsage();
     }
 
-    virtual unsigned getSlavesReplyLen()
+    virtual unsigned getAgentsReplyLen()
     {
-        return totSlavesReplyLen;
+        return totAgentsReplyLen;
     }
 
     virtual void process()

roxie/ccd/ccdcontext.hpp

@@ -43,7 +43,7 @@ interface IWorkUnitRowReader : public IInterface
 
 interface IRoxieServerContext;
 
-interface IRoxieSlaveContext : extends IRoxieContextLogger
+interface IRoxieAgentContext : extends IRoxieContextLogger
 {
     virtual ICodeContext *queryCodeContext() = 0;
     virtual void checkAbort() = 0;
@@ -52,7 +52,7 @@ interface IRoxieSlaveContext : extends IRoxieContextLogger
     virtual void noteChildGraph(unsigned id, IActivityGraph *childGraph) = 0;
     virtual roxiemem::IRowManager &queryRowManager() = 0;
     virtual const QueryOptions &queryOptions() const = 0;
-    virtual void addSlavesReplyLen(unsigned len) = 0;
+    virtual void addAgentsReplyLen(unsigned len) = 0;
     virtual const char *queryAuthToken() = 0;
     virtual const IResolvedFile *resolveLFN(const char *filename, bool isOpt, bool isPrivilegedUser) = 0;
     virtual IRoxieWriteHandler *createLFN(const char *filename, bool overwrite, bool extend, const StringArray &clusters, bool isPrivilegedUser) = 0;
@@ -83,7 +83,7 @@ interface IRoxieServerContext : extends IInterface
     virtual void done(bool failed) = 0;
     virtual void finalize(unsigned seqNo) = 0;
     virtual memsize_t getMemoryUsage() = 0;
-    virtual unsigned getSlavesReplyLen() = 0;
+    virtual unsigned getAgentsReplyLen() = 0;
 
     virtual unsigned getXmlFlags() const = 0;
     virtual IConstWorkUnit *queryWorkUnit() const = 0;
@@ -107,7 +107,7 @@ typedef IEclProcess* (* EclProcessFactory)();
 class CRoxieWorkflowMachine;
 
 extern IDeserializedResultStore *createDeserializedResultStore();
-extern IRoxieSlaveContext *createSlaveContext(const IQueryFactory *factory, const SlaveContextLogger &logctx, IRoxieQueryPacket *packet, bool hasRemoteChildren);
+extern IRoxieAgentContext *createAgentContext(const IQueryFactory *factory, const AgentContextLogger &logctx, IRoxieQueryPacket *packet, bool hasRemoteChildren);
 extern IRoxieServerContext *createRoxieServerContext(IPropertyTree *context, IHpccProtocolResponse *protocol, const IQueryFactory *factory, unsigned flags, const ContextLogger &logctx, PTreeReaderOptions xmlReadFlags, const char *querySetName);
 extern IRoxieServerContext *createOnceServerContext(const IQueryFactory *factory, const IRoxieContextLogger &_logctx);
 extern IRoxieServerContext *createWorkUnitServerContext(IConstWorkUnit *wu, const IQueryFactory *factory, const ContextLogger &logctx);

roxie/ccd/ccddali.cpp

@@ -768,7 +768,7 @@ public:
                         throw MakeStringException(ROXIE_DALI_ERROR, "Could not instantiate dali IGroup");
 
                     // Initialize client process
-                    if (!initClientProcess(serverGroup, DCR_RoxyMaster, 0, NULL, NULL, timeout))
+                    if (!initClientProcess(serverGroup, DCR_Roxie, 0, NULL, NULL, timeout))
                         throw MakeStringException(ROXIE_DALI_ERROR, "Could not initialize dali client");
                     serverStatus = new CSDSServerStatus("RoxieServer");
                     serverStatus->queryProperties()->setProp("@cluster", roxieName.str());

roxie/ccd/ccddebug.cpp

@@ -80,11 +80,11 @@ public:
         return in->gatherConjunctions(collector);
     }
 
-    virtual IStrandJunction *getOutputStreams(IRoxieSlaveContext *ctx, unsigned idx, PointerArrayOf<IEngineRowStream> &streams, const StrandOptions * consumerOptions, bool consumerOrdered, IOrderedCallbackCollection * orderedCallbacks)
+    virtual IStrandJunction *getOutputStreams(IRoxieAgentContext *ctx, unsigned idx, PointerArrayOf<IEngineRowStream> &streams, const StrandOptions * consumerOptions, bool consumerOrdered, IOrderedCallbackCollection * orderedCallbacks)
     {
         assertex (!idx);
         //Need to call
-        //extern IEngineRowStream *connectSingleStream(IRoxieSlaveContext *ctx, IFinalRoxieInput *input, unsigned idx, Owned<IStrandJunction> &junction, bool consumerOrdered)
+        //extern IEngineRowStream *connectSingleStream(IRoxieAgentContext *ctx, IFinalRoxieInput *input, unsigned idx, Owned<IStrandJunction> &junction, bool consumerOrdered)
         PointerArrayOf<IEngineRowStream> instreams;
         Owned<IStrandJunction> junction = in->getOutputStreams(ctx, sourceIdx, instreams, NULL, consumerOrdered, nullptr);
         //MORE: This needs to create a junction if instreams > 1
@@ -1537,7 +1537,7 @@ public:
     virtual unsigned queryHistoryCapacity() const { UNIMPLEMENTED; };
     virtual IBreakpointInfo *debuggerCallback(unsigned sequence, const void *row)
     {
-        // was done on slave, don't do here too
+        // was done on agent, don't do here too
         return NULL;
     };
     virtual void setHistoryCapacity(unsigned newCapacity) { UNIMPLEMENTED; };
@@ -1634,7 +1634,7 @@ public:
         // MORE - should I do anything here?
         return NULL;
     }
-    virtual void noteSlaveGraph(IActivityBase *parentActivity, unsigned graphId, unsigned channel, memsize_t remoteGraphId)
+    virtual void noteAgentGraph(IActivityBase *parentActivity, unsigned graphId, unsigned channel, memsize_t remoteGraphId)
     {
         UNIMPLEMENTED; // MORE - can this happen? nested graphs?
     }

roxie/ccd/ccdfile.cpp

@@ -1172,7 +1172,7 @@ public:
                 if ((dfsSize != (offset_t) -1 && dfsSize != f->getSize()) ||
                     (!dfsDate.isNull() && !dfsDate.equals(*f->queryDateTime(), false)))
                 {
-                    releaseSlaveDynamicFileCache();  // Slave dynamic file cache or...
+                    releaseAgentDynamicFileCache();  // Agent dynamic file cache or...
                     if (fileType == ROXIE_KEY)       // ...jhtree cache can keep files active and thus prevent us from loading a new version
                         clearKeyStoreCacheEntry(f);  // Will release iff that is the only link
                     f.clear(); // Note - needs to be done before calling getValue() again, hence the need to make it separate from the f.set below
@@ -1817,7 +1817,7 @@ protected:
     IResolvedFileCache *cached;
     StringAttr lfn;
     StringAttr physicalName;
-    Owned<IDistributedFile> dFile; // NULL on copies serialized to slaves. Note that this implies we keep a lock on dali file for the lifetime of this object.
+    Owned<IDistributedFile> dFile; // NULL on copies serialized to agents. Note that this implies we keep a lock on dali file for the lifetime of this object.
     CDateTime fileTimeStamp;
     offset_t fileSize;
     unsigned fileCheckSum;
@@ -1825,8 +1825,8 @@ protected:
     bool isSuper;
 
     StringArray subNames;
-    IPointerArrayOf<IFileDescriptor> subFiles; // note - on slaves, the file descriptors may have incomplete info. On originating server is always complete
-    IPointerArrayOf<IFileDescriptor> remoteSubFiles; // note - on slaves, the file descriptors may have incomplete info. On originating server is always complete
+    IPointerArrayOf<IFileDescriptor> subFiles; // note - on agents, the file descriptors may have incomplete info. On originating server is always complete
+    IPointerArrayOf<IFileDescriptor> remoteSubFiles; // note - on agents, the file descriptors may have incomplete info. On originating server is always complete
     IntArray formatCrcs;
     IPointerArrayOf<IOutputMetaData> diskTypeInfo;  // New info using RtlTypeInfo structures
     IArrayOf<IDistributedFile> subDFiles;  // To make sure subfiles get locked too
@@ -2543,7 +2543,7 @@ MORE
     - on remote() calls we can't pass the expected file date but we will pass it back with the file info.
 ------------------------------------------------------------------------------------------------------------*/
 
-class CSlaveDynamicFile : public CResolvedFile
+class CAgentDynamicFile : public CResolvedFile
 {
 public:
     bool isOpt; // MORE - this is not very good. Needs some thought unless you cache opt / nonOpt separately which seems wasteful
@@ -2552,7 +2552,7 @@ public:
     ServerIdentifier serverId;
 
 public:
-    CSlaveDynamicFile(const IRoxieContextLogger &logctx, const char *_lfn, RoxiePacketHeader *header, bool _isOpt, bool _isLocal)
+    CAgentDynamicFile(const IRoxieContextLogger &logctx, const char *_lfn, RoxiePacketHeader *header, bool _isOpt, bool _isLocal)
         : CResolvedFile(_lfn, NULL, NULL, ROXIE_FILE, NULL, true, false, false, false), isOpt(_isOpt), isLocal(_isLocal), channel(header->channel), serverId(header->serverId)
     {
         // call back to the server to get the info
@@ -2677,15 +2677,15 @@ extern IResolvedFile *createResolvedFile(const char *lfn, const char *physical,
     return new CResolvedFile(lfn, physical, dFile, kind && stricmp(kind, "key")==0 ? ROXIE_KEY : ROXIE_FILE, daliHelper, isDynamic, cacheIt, writeAccess, false);
 }
 
-class CSlaveDynamicFileCache : implements ISlaveDynamicFileCache, public CInterface
+class CAgentDynamicFileCache : implements IAgentDynamicFileCache, public CInterface
 {
     unsigned tableSize;
     mutable CriticalSection crit;
-    CIArrayOf<CSlaveDynamicFile> files; // expect numbers to be small - probably not worth hashing
+    CIArrayOf<CAgentDynamicFile> files; // expect numbers to be small - probably not worth hashing
 
 public:
     IMPLEMENT_IINTERFACE;
-    CSlaveDynamicFileCache(unsigned _limit) : tableSize(_limit) {}
+    CAgentDynamicFileCache(unsigned _limit) : tableSize(_limit) {}
 
     virtual IResolvedFile *lookupDynamicFile(const IRoxieContextLogger &logctx, const char *lfn, CDateTime &cacheDate, unsigned checksum, RoxiePacketHeader *header, bool isOpt, bool isLocal) override
     {
@@ -2701,7 +2701,7 @@ public:
             unsigned idx = 0;
             while (files.isItem(idx))
             {
-                CSlaveDynamicFile &f = files.item(idx);
+                CAgentDynamicFile &f = files.item(idx);
                 if (f.channel==header->channel && f.serverId==header->serverId && stricmp(f.queryFileName(), lfn)==0)
                 {
                     if (!cacheDate.equals(f.queryTimeStamp()) || checksum != f.queryCheckSum())
@@ -2720,11 +2720,11 @@ public:
                 idx++;
             }
         }
-        Owned<CSlaveDynamicFile> ret;
+        Owned<CAgentDynamicFile> ret;
         {
             // Don't prevent access to the cache while waiting for server to reply. Can deadlock if you do, apart from being inefficient
             CriticalUnblock b1(crit);
-            ret.setown(new CSlaveDynamicFile(logctx, lfn, header, isOpt, isLocal));
+            ret.setown(new CAgentDynamicFile(logctx, lfn, header, isOpt, isLocal));
         }
         if (!ret->isSuperFile())
         {
@@ -2745,25 +2745,25 @@ public:
     }
 };
 
-static CriticalSection slaveDynamicFileCacheCrit;
-static Owned<ISlaveDynamicFileCache> slaveDynamicFileCache;
+static CriticalSection agentDynamicFileCacheCrit;
+static Owned<IAgentDynamicFileCache> agentDynamicFileCache;
 
-extern ISlaveDynamicFileCache *querySlaveDynamicFileCache()
+extern IAgentDynamicFileCache *queryAgentDynamicFileCache()
 {
-    if (!slaveDynamicFileCache)
+    if (!agentDynamicFileCache)
     {
-        CriticalBlock b(slaveDynamicFileCacheCrit);
-        if (!slaveDynamicFileCache)
-            slaveDynamicFileCache.setown(new CSlaveDynamicFileCache(20));
+        CriticalBlock b(agentDynamicFileCacheCrit);
+        if (!agentDynamicFileCache)
+            agentDynamicFileCache.setown(new CAgentDynamicFileCache(20));
     }
-    return slaveDynamicFileCache;
+    return agentDynamicFileCache;
 }
 
-extern void releaseSlaveDynamicFileCache()
+extern void releaseAgentDynamicFileCache()
 {
-    CriticalBlock b(slaveDynamicFileCacheCrit);
-    if (slaveDynamicFileCache)
-        slaveDynamicFileCache->releaseAll();
+    CriticalBlock b(agentDynamicFileCacheCrit);
+    if (agentDynamicFileCache)
+        agentDynamicFileCache->releaseAll();
 }
 
 

roxie/ccd/ccdkey.cpp

@@ -258,7 +258,7 @@ public:
     void serializeCursorPos(MemoryBuffer &mb) const
     {
         // We are saving a unique signature of this index that can be used to ensure that any continuation will identify the same index
-        // Note that the continuation may be executed by a different slave
+        // Note that the continuation may be executed by a different agent
         // This code is not great but is probably ok.
         StringBuffer b;
         toString(b);

roxie/ccd/ccdlistener.cpp

@@ -73,7 +73,7 @@ class CascadeManager : public CInterface
     UnsignedArray activeIdxes;
     bool entered;
     bool connected;
-    bool isMaster;
+    bool isOriginal;
     CriticalSection revisionCrit;
     int myEndpoint;
     const IRoxieContextLogger &logctx;
@@ -293,7 +293,7 @@ public:
     {
         entered = false;
         connected = false;
-        isMaster = false;
+        isOriginal = false;
         myEndpoint = -1;
         logctx.Link();
     }
@@ -308,7 +308,7 @@ public:
     {
         if (traceLevel > 5)
             DBGLOG("doLockChild: %s", logText);
-        isMaster = false;
+        isOriginal = false;
         bool unlock = xml->getPropBool("@unlock", false);
         if (unlock)
         {
@@ -353,7 +353,7 @@ public:
     {
         assertex(!entered);
         assertex(!connected);
-        isMaster = true;
+        isOriginal = true;
         myEndpoint = -1;
         unsigned attemptsLeft = maxLockAttempts;
         connectChild(0);
@@ -407,7 +407,7 @@ public:
     void doControlQuery(SocketEndpoint &ep, IPropertyTree *xml, const char *queryText, StringBuffer &reply)
     {
         if (logctx.queryTraceLevel() > 5)
-            logctx.CTXLOG("doControlQuery (%d): %.80s", isMaster, queryText);
+            logctx.CTXLOG("doControlQuery (%d): %.80s", isOriginal, queryText);
         // By this point we should have cascade-connected thanks to a prior <control:lock>
         // So do the query ourselves and in all child threads;
         const char *name = xml->queryName();
@@ -505,12 +505,12 @@ public:
                     reply.append(myReply);
             }
         } afor(xml, queryText, this, mergedReply, mergeType, reply, ep, activeChildren.ordinality(), logctx);
-        afor.For(activeChildren.ordinality()+(isMaster ? 0 : 1), 10);
+        afor.For(activeChildren.ordinality()+(isOriginal ? 0 : 1), 10);
         activeChildren.kill();
         if (mergedReply)
             toXML(mergedReply, reply, 0, (mergeType == CascadeMergeQueries) ? XML_Embed|XML_LineBreak|XML_SortTags : XML_Format);
         if (logctx.queryTraceLevel() > 5)
-            logctx.CTXLOG("doControlQuery (%d) finished: %.80s", isMaster, queryText);
+            logctx.CTXLOG("doControlQuery (%d) finished: %.80s", isOriginal, queryText);
     }
 
 };
@@ -965,11 +965,11 @@ public:
         worker->threadmain();
     }
 
-    virtual void noteQuery(IHpccProtocolMsgContext *msgctx, const char *peer, bool failed, unsigned bytesOut, unsigned elapsed, unsigned memused, unsigned slavesReplyLen, bool continuationNeeded)
+    virtual void noteQuery(IHpccProtocolMsgContext *msgctx, const char *peer, bool failed, unsigned bytesOut, unsigned elapsed, unsigned memused, unsigned agentsReplyLen, bool continuationNeeded)
     {
     }
 
-    virtual void onQueryMsg(IHpccProtocolMsgContext *msgctx, IPropertyTree *msg, IHpccProtocolResponse *protocol, unsigned flags, PTreeReaderOptions readFlags, const char *target, unsigned idx, unsigned &memused, unsigned &slaveReplyLen)
+    virtual void onQueryMsg(IHpccProtocolMsgContext *msgctx, IPropertyTree *msg, IHpccProtocolResponse *protocol, unsigned flags, PTreeReaderOptions readFlags, const char *target, unsigned idx, unsigned &memused, unsigned &agentReplyLen)
     {
         UNIMPLEMENTED;
     }
@@ -1126,11 +1126,11 @@ protected:
  * workunit via a job queue. A temporary IQueryFactory object is created for the
  * workunit and then executed.
  *
- * Any slaves that need to load the query do so using a lazy load mechanism, checking
+ * Any agents that need to load the query do so using a lazy load mechanism, checking
  * whether the wuid named in the logging prefix info can be loaded any time a query
- * is received for which no factory exists. Any query that a slave loads as a
+ * is received for which no factory exists. Any query that a agent loads as a
  * result is added to a cache to ensure that it stays around until the server's query
- * terminates - a ROXIE_UNLOAD message is broadcast at that time to allow the slaves
+ * terminates - a ROXIE_UNLOAD message is broadcast at that time to allow the agents
  * to release any cached IQueryFactory objects.
  *
  **/
@@ -1226,7 +1226,7 @@ public:
     {
         bool failed = true; // many paths to failure, only one to success...
         unsigned memused = 0;
-        unsigned slavesReplyLen = 0;
+        unsigned agentsReplyLen = 0;
         unsigned priority = (unsigned) -2;
         try
         {
@@ -1262,14 +1262,14 @@ public:
             {
                 ctx->process();
                 memused = (unsigned)(ctx->getMemoryUsage() / 0x100000);
-                slavesReplyLen = ctx->getSlavesReplyLen();
+                agentsReplyLen = ctx->getAgentsReplyLen();
                 ctx->done(false);
                 failed = false;
             }
             catch(...)
             {
                 memused = (unsigned)(ctx->getMemoryUsage() / 0x100000);
-                slavesReplyLen = ctx->getSlavesReplyLen();
+                agentsReplyLen = ctx->getAgentsReplyLen();
                 ctx->done(true);
                 throw;
             }
@@ -1292,7 +1292,7 @@ public:
 #endif
         unsigned elapsed = msTick() - qstart;
         noteQuery(failed, elapsed, priority);
-        queryFactory->noteQuery(startTime, failed, elapsed, memused, slavesReplyLen, 0);
+        queryFactory->noteQuery(startTime, failed, elapsed, memused, agentsReplyLen, 0);
         if (logctx.queryTraceLevel() && (logctx.queryTraceLevel() > 2 || logFullQueries || logctx.intercept))
         {
             StringBuffer s;
@@ -1313,7 +1313,7 @@ public:
                 txidInfo.append(']');
             }
 
-            logctx.CTXLOG("COMPLETE: %s%s complete in %d msecs memory=%d Mb priority=%d slavesreply=%d%s", wuid.get(), txidInfo.str(), elapsed, memused, priority, slavesReplyLen, s.str());
+            logctx.CTXLOG("COMPLETE: %s%s complete in %d msecs memory=%d Mb priority=%d agentsreply=%d%s", wuid.get(), txidInfo.str(), elapsed, memused, priority, agentsReplyLen, s.str());
         }
     }
 
@@ -1570,12 +1570,12 @@ public:
         }
         combinedQueryStats.noteQuery(failed, elapsedTime);
     }
-    void noteQuery(const char *peer, bool failed, unsigned elapsed, unsigned memused, unsigned slavesReplyLen, unsigned bytesOut, bool continuationNeeded)
+    void noteQuery(const char *peer, bool failed, unsigned elapsed, unsigned memused, unsigned agentsReplyLen, unsigned bytesOut, bool continuationNeeded)
     {
         noteQueryStats(failed, elapsed);
         if (queryFactory)
         {
-            queryFactory->noteQuery(startTime, failed, elapsed, memused, slavesReplyLen, bytesOut);
+            queryFactory->noteQuery(startTime, failed, elapsed, memused, agentsReplyLen, bytesOut);
             queryFactory.clear();
         }
         if (logctx && logctx->queryTraceLevel() && (logctx->queryTraceLevel() > 2 || logFullQueries() || logctx->intercept))
@@ -1597,7 +1597,7 @@ public:
                 }
                 if (txIds.length())
                     txIds.insert(0, '[').append(']');
-                logctx->CTXLOG("COMPLETE: %s %s%s from %s complete in %d msecs memory=%d Mb priority=%d slavesreply=%d resultsize=%d continue=%d%s", queryName.get(), uid.get(), txIds.str(), peer, elapsed, memused, getQueryPriority(), slavesReplyLen, bytesOut, continuationNeeded, s.str());
+                logctx->CTXLOG("COMPLETE: %s %s%s from %s complete in %d msecs memory=%d Mb priority=%d agentsreply=%d resultsize=%d continue=%d%s", queryName.get(), uid.get(), txIds.str(), peer, elapsed, memused, getQueryPriority(), agentsReplyLen, bytesOut, continuationNeeded, s.str());
             }
         }
     }
@@ -1732,7 +1732,7 @@ public:
         return checkGetRoxieMsgContext(msgctx);
     }
 
-    virtual void onQueryMsg(IHpccProtocolMsgContext *msgctx, IPropertyTree *msg, IHpccProtocolResponse *protocol, unsigned flags, PTreeReaderOptions xmlReadFlags, const char *target, unsigned idx, unsigned &memused, unsigned &slavesReplyLen)
+    virtual void onQueryMsg(IHpccProtocolMsgContext *msgctx, IPropertyTree *msg, IHpccProtocolResponse *protocol, unsigned flags, PTreeReaderOptions xmlReadFlags, const char *target, unsigned idx, unsigned &memused, unsigned &agentsReplyLen)
     {
         RoxieProtocolMsgContext *roxieMsgCtx = checkGetRoxieMsgContext(msgctx, msg);
         IQueryFactory *f = roxieMsgCtx->queryQueryFactory();
@@ -1748,7 +1748,7 @@ public:
 
             protocol->finalize(idx);
             memused += (unsigned)(ctx->getMemoryUsage() / 0x100000);
-            slavesReplyLen += ctx->getSlavesReplyLen();
+            agentsReplyLen += ctx->getAgentsReplyLen();
         }
         else
         {
@@ -1756,13 +1756,13 @@ public:
             {
                 ctx->process();
                 memused = (unsigned)(ctx->getMemoryUsage() / 0x100000);
-                slavesReplyLen = ctx->getSlavesReplyLen();
+                agentsReplyLen = ctx->getAgentsReplyLen();
                 ctx->done(false);
             }
             catch(...)
             {
                 memused = (unsigned)(ctx->getMemoryUsage() / 0x100000);
-                slavesReplyLen = ctx->getSlavesReplyLen();
+                agentsReplyLen = ctx->getAgentsReplyLen();
                 ctx->done(true);
                 throw;
             }
@@ -1861,10 +1861,10 @@ public:
         roxieMsgCtx->ensureDebugCommandHandler().doDebugCommand(msg, &roxieMsgCtx->ensureDebuggerContext(uid), out);
     }
 
-    virtual void noteQuery(IHpccProtocolMsgContext *msgctx, const char *peer, bool failed, unsigned bytesOut, unsigned elapsed, unsigned memused, unsigned slavesReplyLen, bool continuationNeeded)
+    virtual void noteQuery(IHpccProtocolMsgContext *msgctx, const char *peer, bool failed, unsigned bytesOut, unsigned elapsed, unsigned memused, unsigned agentsReplyLen, bool continuationNeeded)
     {
         RoxieProtocolMsgContext *roxieMsgCtx = checkGetRoxieMsgContext(msgctx);
-        roxieMsgCtx->noteQuery(peer, failed, elapsed, memused, slavesReplyLen, bytesOut, continuationNeeded);
+        roxieMsgCtx->noteQuery(peer, failed, elapsed, memused, agentsReplyLen, bytesOut, continuationNeeded);
     }
 
 };

roxie/ccd/ccdmain.cpp

@@ -64,8 +64,8 @@ unsigned lowTimeout = 10000;
 unsigned highTimeout = 2000;
 unsigned slaTimeout = 2000;
 unsigned numServerThreads = 30;
-unsigned numSlaveThreads = 30;
-bool prestartSlaveThreads = false;
+unsigned numAgentThreads = 30;
+bool prestartAgentThreads = false;
 unsigned numRequestArrayThreads = 5;
 unsigned headRegionSize;
 unsigned ccdMulticastPort;
@@ -87,10 +87,10 @@ bool defaultTraceEnabled = false;
 bool traceTranslations = true;
 unsigned defaultTraceLimit = 10;
 unsigned watchActivityId = 0;
-unsigned testSlaveFailure = 0;
+unsigned testAgentFailure = 0;
 RelaxedAtomic<unsigned> restarts;
 RecordTranslationMode fieldTranslationEnabled = RecordTranslationMode::Payload;
-bool mergeSlaveStatistics = true;
+bool mergeAgentStatistics = true;
 PTreeReaderOptions defaultXmlReadFlags = ptr_ignoreWhiteSpace;
 bool runOnce = false;
 bool oneShotRoxie = false;
@@ -112,7 +112,7 @@ bool lockSuperFiles;
 bool useRemoteResources;
 bool checkFileDate;
 bool lazyOpen;
-bool localSlave;
+bool localAgent;
 bool useAeron;
 bool ignoreOrphans;
 bool doIbytiDelay = true; 
@@ -156,7 +156,7 @@ unsigned defaultStrandBlockSize = 512;
 unsigned defaultForceNumStrands = 0;
 unsigned defaultHeapFlags = roxiemem::RHFnone;
 
-unsigned slaveQueryReleaseDelaySeconds = 60;
+unsigned agentQueryReleaseDelaySeconds = 60;
 unsigned coresPerQuery = 0;
 
 unsigned logQueueLen;
@@ -416,7 +416,7 @@ public:
 };
 
 static std::vector<RoxieEndpointInfo> myRoles;
-static std::vector<std::pair<unsigned, unsigned>> slaveChannels;
+static std::vector<std::pair<unsigned, unsigned>> agentChannels;
 
 #ifndef _CONTAINERIZED
 void readStaticTopology()
@@ -426,7 +426,7 @@ void readStaticTopology()
     std::vector<RoxieEndpointInfo> allRoles;
     IpAddressArray nodeTable;
     unsigned numNodes = topology->getCount("./RoxieServerProcess");
-    if (!numNodes && localSlave)
+    if (!numNodes && localAgent)
     {
         topology->addPropTree("RoxieServerProcess")->setProp("@netAddress", ".");
         numNodes = 1;
@@ -446,7 +446,7 @@ void readStaticTopology()
         {
             myNodeSet = true;
             myNode.setIp(ip);
-            mySlaveEP.set(ccdMulticastPort, myNode.getNodeAddress());
+            myAgentEP.set(ccdMulticastPort, myNode.getNodeAddress());
         }
         ForEachItemIn(idx, nodeTable)
         {
@@ -466,17 +466,19 @@ void readStaticTopology()
     if (!myNodeSet)
         throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - current node is not in server list");
 
-    // Generate the slave channels
+    // Generate the agent channels
 
     unsigned numDataCopies = topology->getPropInt("@numDataCopies", 1);
     if (!numDataCopies)
         throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - numDataCopies should be > 0");
     unsigned channelsPerNode = topology->getPropInt("@channelsPerNode", 1);
-    const char *slaveConfig = topology->queryProp("@slaveConfig");
-    if (!slaveConfig)
-        slaveConfig = "simple";
+    const char *agentConfig = topology->queryProp("@agentConfig");
+    if (!agentConfig)
+        agentConfig = topology->queryProp("@slaveConfig");  // legacy name
+    if (!agentConfig)
+        agentConfig = "simple";
 
-    if (strnicmp(slaveConfig, "cyclic", 6) == 0)
+    if (strnicmp(agentConfig, "cyclic", 6) == 0)
     {
         calcNumChannels = numNodes;
         unsigned cyclicOffset = topology->getPropInt("@cyclicOffset", 1);
@@ -489,12 +491,12 @@ void readStaticTopology()
                 int channel = (int)i+1 - (copy * cyclicOffset);
                 while (channel < 1)
                     channel = channel + numNodes;
-                RoxieEndpointInfo slave = {RoxieEndpointInfo::RoxieSlave, (unsigned) channel, { (unsigned short) ccdMulticastPort, nodeTable.item(i) }, copy};
-                allRoles.push_back(slave);
+                RoxieEndpointInfo agent = {RoxieEndpointInfo::RoxieAgent, (unsigned) channel, { (unsigned short) ccdMulticastPort, nodeTable.item(i) }, copy};
+                allRoles.push_back(agent);
             }
         }
     }
-    else if (strnicmp(slaveConfig, "overloaded", 10) == 0)
+    else if (strnicmp(agentConfig, "overloaded", 10) == 0)
     {
         if (!channelsPerNode)
             throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - channelsPerNode should be > 0");
@@ -504,8 +506,8 @@ void readStaticTopology()
             for (unsigned i=0; i<numNodes; i++)
             {
                 unsigned channel = i+1;
-                RoxieEndpointInfo slave = {RoxieEndpointInfo::RoxieSlave, channel, { (unsigned short) ccdMulticastPort, nodeTable.item(i) }, copy};
-                allRoles.push_back(slave);
+                RoxieEndpointInfo agent = {RoxieEndpointInfo::RoxieAgent, channel, { (unsigned short) ccdMulticastPort, nodeTable.item(i) }, copy};
+                allRoles.push_back(agent);
                 channel += numNodes;
             }
         }
@@ -518,8 +520,8 @@ void readStaticTopology()
         unsigned channel = 1;
         for (unsigned i=0; i<numNodes; i++)
         {
-            RoxieEndpointInfo slave = {RoxieEndpointInfo::RoxieSlave, channel, { (unsigned short) ccdMulticastPort, nodeTable.item(i) }, 0 };
-            allRoles.push_back(slave);
+            RoxieEndpointInfo agent = {RoxieEndpointInfo::RoxieAgent, channel, { (unsigned short) ccdMulticastPort, nodeTable.item(i) }, 0 };
+            allRoles.push_back(agent);
             channel++;
             if (channel > calcNumChannels)
                 channel = 1;
@@ -529,8 +531,8 @@ void readStaticTopology()
         throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - numChannels calculated at %u but specified as %u", calcNumChannels, numChannels);
     if (!calcNumChannels)
         throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - numChannels calculated at 0");
-    if (calcNumChannels > 1 && localSlave)
-        throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - localSlave requires single channel (%d channels specified)", calcNumChannels);
+    if (calcNumChannels > 1 && localAgent)
+        throw MakeStringException(MSGAUD_operator, ROXIE_INVALID_TOPOLOGY, "Invalid topology file - localAgent requires single channel (%d channels specified)", calcNumChannels);
     numChannels = calcNumChannels;
     createStaticTopology(allRoles, traceLevel);
 }
@@ -642,7 +644,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         useOldTopology = checkFileExists(topologyFile.str());
         topology = loadConfiguration(useOldTopology ? nullptr : defaultYaml, argv, "roxie", "ROXIE", topologyFile, nullptr, "@netAddress");
         saveTopology();
-        localSlave = topology->getPropBool("@localSlave", false);
+        localAgent = topology->getPropBool("@localAgent", topology->getPropBool("@localSlave", false));  // legacy name
         const char *channels = topology->queryProp("@channels");
         if (channels)
         {
@@ -660,12 +662,12 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
                 }
                 else if (*tail)
                     throw makeStringExceptionV(ROXIE_INTERNAL_ERROR, "Invalid channel specification %s", channels);
-                slaveChannels.push_back(std::pair<unsigned, unsigned>(channel, repl));
+                agentChannels.push_back(std::pair<unsigned, unsigned>(channel, repl));
             }
         }
 #ifdef _CONTAINERIZED
-        else if (localSlave)
-            slaveChannels.push_back(std::pair<unsigned, unsigned>(1, 0));
+        else if (localAgent)
+            agentChannels.push_back(std::pair<unsigned, unsigned>(1, 0));
 #endif
         const char *topos = topology->queryProp("@topologyServers");
         StringArray topoValues;
@@ -939,7 +941,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         udpFlowSocketsSize = topology->getPropInt("@udpFlowSocketsSize", 131072);
         udpLocalWriteSocketSize = topology->getPropInt("@udpLocalWriteSocketSize", 1024000);
 #ifndef _CONTAINERIZED
-        roxieMulticastEnabled = topology->getPropBool("@roxieMulticastEnabled", true) && !useAeron;   // enable use of multicast for sending requests to slaves
+        roxieMulticastEnabled = topology->getPropBool("@roxieMulticastEnabled", true) && !useAeron;   // enable use of multicast for sending requests to agents
 #endif
         if (udpSnifferEnabled && !roxieMulticastEnabled)
         {
@@ -962,14 +964,14 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
             multicastTTL = ttlTmp;
 
         indexReadChunkSize = topology->getPropInt("@indexReadChunkSize", 60000);
-        numSlaveThreads = topology->getPropInt("@slaveThreads", 30);
+        numAgentThreads = topology->getPropInt("@agentThreads", topology->getPropInt("@slaveThreads", 30));  // legacy name
         numServerThreads = topology->getPropInt("@serverThreads", 30);
         numRequestArrayThreads = topology->getPropInt("@requestArrayThreads", 5);
         maxBlockSize = topology->getPropInt("@maxBlockSize", 10000000);
         maxLockAttempts = topology->getPropInt("@maxLockAttempts", 5);
         enableHeartBeat = topology->getPropBool("@enableHeartBeat", true);
         checkCompleted = topology->getPropBool("@checkCompleted", true);
-        prestartSlaveThreads = topology->getPropBool("@prestartSlaveThreads", false);
+        prestartAgentThreads = topology->getPropBool("@prestartAgentThreads", topology->getPropBool("@prestartSlaveThreads", false));  // legacy name
         preabortKeyedJoinsThreshold = topology->getPropInt("@preabortKeyedJoinsThreshold", 100);
         preabortIndexReadsThreshold = topology->getPropInt("@preabortIndexReadsThreshold", 100);
         defaultMemoryLimit = (memsize_t) topology->getPropInt64("@defaultMemoryLimit", 0);
@@ -993,7 +995,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         defaultCheckingHeap = topology->getPropBool("@checkingHeap", false);  // NOTE - not in configmgr - too dangerous!
         defaultDisableLocalOptimizations = topology->getPropBool("@disableLocalOptimizations", false);  // NOTE - not in configmgr - too dangerous!
 
-        slaveQueryReleaseDelaySeconds = topology->getPropInt("@slaveQueryReleaseDelaySeconds", 60);
+        agentQueryReleaseDelaySeconds = topology->getPropInt("@agentQueryReleaseDelaySeconds", topology->getPropInt("@slaveQueryReleaseDelaySeconds", 60));  // legacy name
         coresPerQuery = topology->getPropInt("@coresPerQuery", 0);
 
         diskReadBufferSize = topology->getPropInt("@diskReadBufferSize", 0x10000);
@@ -1037,7 +1039,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         trapTooManyActiveQueries = topology->getPropBool("@trapTooManyActiveQueries", true);
         maxEmptyLoopIterations = topology->getPropInt("@maxEmptyLoopIterations", 1000);
         maxGraphLoopIterations = topology->getPropInt("@maxGraphLoopIterations", 1000);
-        mergeSlaveStatistics = topology->getPropBool("@mergeSlaveStatistics", true);
+        mergeAgentStatistics = topology->getPropBool("@mergeAgentStatistics", topology->getPropBool("@mergeSlaveStatistics", true));  // legacy name
         defaultCollectFactoryStatistics = topology->getPropBool("@collectFactoryStatistics", true);
         defaultNoSeekBuildIndex = topology->getPropBool("@noSeekBuildIndex", isContainerized());
         parallelLoadQueries = topology->getPropInt("@parallelLoadQueries", 8);
@@ -1147,15 +1149,15 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
                 myRoles.push_back(me);
             }
         }
-        for (std::pair<unsigned, unsigned> channel: slaveChannels)
+        for (std::pair<unsigned, unsigned> channel: agentChannels)
         {
-            mySlaveEP.set(ccdMulticastPort, myIP);
-            RoxieEndpointInfo me = { RoxieEndpointInfo::RoxieSlave, channel.first, mySlaveEP, channel.second };
+            myAgentEP.set(ccdMulticastPort, myIP);
+            RoxieEndpointInfo me = { RoxieEndpointInfo::RoxieAgent, channel.first, myAgentEP, channel.second };
             myRoles.push_back(me);
         }
 #else
-        // Set multicast base addresses - must be done before generating slave channels
-        if (roxieMulticastEnabled && !localSlave)
+        // Set multicast base addresses - must be done before generating agent channels
+        if (roxieMulticastEnabled && !localAgent)
         {
             if (topology->queryProp("@multicastBase"))
                 multicastBase.ipset(topology->queryProp("@multicastBase"));
@@ -1169,7 +1171,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         readStaticTopology();
 #endif
         // Now we know all the channels, we can open and subscribe the multicast channels
-        if (!localSlave)
+        if (!localAgent)
         {
             openMulticastSocket();
             if (roxieMulticastEnabled)
@@ -1187,7 +1189,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
 #ifdef _CONTAINERIZED
         initializeTopology(topoValues, myRoles, traceLevel);
 #endif
-        ROQ = createOutputQueueManager(snifferChannel, numSlaveThreads);
+        ROQ = createOutputQueueManager(snifferChannel, numAgentThreads);
         ROQ->setHeadRegionSize(headRegionSize);
         ROQ->start();
         Owned<IPacketDiscarder> packetDiscarder = createPacketDiscarder();
@@ -1392,7 +1394,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
     cleanupPlugins();
     unloadHpccProtocolPlugin();
     closeMulticastSockets();
-    releaseSlaveDynamicFileCache();
+    releaseAgentDynamicFileCache();
     releaseRoxieStateCache();
     setDaliServixSocketCaching(false);  // make sure it cleans up or you get bogus memleak reports
     setNodeCaching(false); // ditto
@@ -1429,7 +1431,7 @@ static constexpr const char * standaloneDefaultYaml = R"!!(
 version: "1.0"
 roxie:
   allFilesDynamic: true
-  localSlave: true
+  localAgent: true
   numChannels: 1
   queueNames: roxie.roxie
   traceLevel: 0

roxie/ccd/ccdprotocol.cpp

@@ -1366,15 +1366,15 @@ private:
     HttpHelper &httpHelper;
     PTreeReaderOptions xmlReadFlags;
     unsigned &memused;
-    unsigned &slaveReplyLen;
+    unsigned &agentReplyLen;
     CriticalSection crit;
     unsigned flags;
 
 public:
     CHttpRequestAsyncFor(const char *_queryName, IHpccProtocolMsgSink *_sink, IHpccProtocolMsgContext *_msgctx, IArrayOf<IPropertyTree> &_requestArray,
-            SafeSocket &_client, HttpHelper &_httpHelper, unsigned _flags, unsigned &_memused, unsigned &_slaveReplyLen, const char *_queryText, const IContextLogger &_logctx, PTreeReaderOptions _xmlReadFlags, const char *_querySetName)
+            SafeSocket &_client, HttpHelper &_httpHelper, unsigned _flags, unsigned &_memused, unsigned &_agentReplyLen, const char *_queryText, const IContextLogger &_logctx, PTreeReaderOptions _xmlReadFlags, const char *_querySetName)
     : querySetName(_querySetName), logctx(_logctx), requestArray(_requestArray), sink(_sink), msgctx(_msgctx), client(_client), httpHelper(_httpHelper), xmlReadFlags(_xmlReadFlags)
-      , memused(_memused), slaveReplyLen(_slaveReplyLen), flags(_flags)
+      , memused(_memused), agentReplyLen(_agentReplyLen), flags(_flags)
     {
         queryName = _queryName;
         queryText = _queryText;
@@ -1397,7 +1397,7 @@ public:
         {
             IPropertyTree &request = requestArray.item(idx);
             Owned<IHpccProtocolResponse> protocol = createProtocolResponse(request.queryName(), &client, httpHelper, logctx, flags, xmlReadFlags);
-            sink->onQueryMsg(msgctx, &request, protocol, flags, xmlReadFlags, querySetName, idx, memused, slaveReplyLen);
+            sink->onQueryMsg(msgctx, &request, protocol, flags, xmlReadFlags, querySetName, idx, memused, agentReplyLen);
         }
         catch (IException * E)
         {
@@ -1735,7 +1735,7 @@ private:
         IContextLogger &logctx = *msgctx->queryLogContext();
 
 readAnother:
-        unsigned slavesReplyLen = 0;
+        unsigned agentsReplyLen = 0;
         StringArray allTargets;
         sink->getTargetNames(allTargets);
         HttpHelper httpHelper(&allTargets);
@@ -2026,13 +2026,13 @@ readAnother:
 
                         if (isHTTP)
                         {
-                            CHttpRequestAsyncFor af(queryName, sink, msgctx, requestArray, *client, httpHelper, protocolFlags, memused, slavesReplyLen, sanitizedText, logctx, (PTreeReaderOptions)readFlags, querySetName);
+                            CHttpRequestAsyncFor af(queryName, sink, msgctx, requestArray, *client, httpHelper, protocolFlags, memused, agentsReplyLen, sanitizedText, logctx, (PTreeReaderOptions)readFlags, querySetName);
                             af.For(requestArray.length(), global->numRequestArrayThreads);
                         }
                         else
                         {
                             Owned<IHpccProtocolResponse> protocol = createProtocolResponse(queryPT->queryName(), client, httpHelper, logctx, protocolFlags, (PTreeReaderOptions)readFlags);
-                            sink->onQueryMsg(msgctx, queryPT, protocol, protocolFlags, (PTreeReaderOptions)readFlags, querySetName, 0, memused, slavesReplyLen);
+                            sink->onQueryMsg(msgctx, queryPT, protocol, protocolFlags, (PTreeReaderOptions)readFlags, querySetName, 0, memused, agentsReplyLen);
                         }
                     }
                 }
@@ -2101,7 +2101,7 @@ readAnother:
         }
         unsigned bytesOut = client? client->bytesOut() : 0;
         unsigned elapsed = msTick() - qstart;
-        sink->noteQuery(msgctx.get(), peerStr, failed, bytesOut, elapsed,  memused, slavesReplyLen, continuationNeeded);
+        sink->noteQuery(msgctx.get(), peerStr, failed, bytesOut, elapsed,  memused, agentsReplyLen, continuationNeeded);
         if (continuationNeeded)
         {
             rawText.clear();

roxie/ccd/ccdquery.cpp

@@ -73,7 +73,7 @@ unsigned ActivityArray::recursiveFindActivityIndex(unsigned id)
 //----------------------------------------------------------------------------------------------
 // Class CQueryDll maps dlls into loadable workunits, complete with caching to ensure that a refresh of the QuerySet 
 // can avoid reloading dlls, and that the same CQueryDll (and the objects it owns) can be shared between server and 
-// multiple slave channels
+// multiple agent channels
 //----------------------------------------------------------------------------------------------
 
 class CQueryDll : implements IQueryDll, public CInterface
@@ -228,7 +228,7 @@ extern void addXrefLibraryInfo(IPropertyTree &reply, const char *libraryName)
 
 //----------------------------------------------------------------------------------------------
 // Class CSharedOnceContext manages the context for a query's ONCE code, which is shared between
-// all slave and server contexts on a node
+// all agent and server contexts on a node
 //----------------------------------------------------------------------------------------------
 
 class CSharedOnceContext : public CInterfaceOf<ISharedOnceContext>
@@ -519,7 +519,7 @@ void QueryOptions::updateFromContext(bool &value, const IPropertyTree *ctx, cons
         value = ctx->getPropBool(name);
 }
 
-void QueryOptions::setFromSlaveLoggingFlags(unsigned loggingFlags)
+void QueryOptions::setFromAgentLoggingFlags(unsigned loggingFlags)
 {
     // MORE - priority/timelimit ?
     checkingHeap = (loggingFlags & LOGGING_CHECKINGHEAP) != 0;
@@ -531,7 +531,7 @@ void QueryOptions::setFromSlaveLoggingFlags(unsigned loggingFlags)
 // package context into an object that can quickly create a the query context that executes a specific
 // instance of a Roxie query. 
 // Caching is used to ensure that only queries that are affected by a package change need to be reloaded.
-// Derived classes handle the differences between slave and server side factories
+// Derived classes handle the differences between agent and server side factories
 //----------------------------------------------------------------------------------------------
 
 class CQueryFactory : implements IQueryFactory, implements IResourceContext, public CInterface
@@ -940,11 +940,11 @@ protected:
         return LINK(QUERYINTERFACE(findActivity(id), IRoxieServerActivityFactory));
     }
 
-    virtual ISlaveActivityFactory *getSlaveActivityFactory(unsigned id) const override
+    virtual IAgentActivityFactory *getAgentActivityFactory(unsigned id) const override
     {
         checkSuspended();
         IActivityFactory *f = findActivity(id);
-        return LINK(QUERYINTERFACE(f, ISlaveActivityFactory)); // MORE - don't dynamic cast yuk
+        return LINK(QUERYINTERFACE(f, IAgentActivityFactory)); // MORE - don't dynamic cast yuk
     }
 
     ActivityArray *loadChildGraph(IPropertyTree &graph)
@@ -1058,7 +1058,7 @@ protected:
         }
     }
 
-    // loadGraph loads outer level graph. This is virtual as slave is very different from Roxie server
+    // loadGraph loads outer level graph. This is virtual as agent is very different from Roxie server
     virtual ActivityArray *loadGraph(IPropertyTree &graph, const char *graphName) = 0;
 
     bool doAddDependency(unsigned sourceIdx, unsigned sourceId, unsigned targetId, int controlId, const char *edgeId, ActivityArray * activities)
@@ -1155,7 +1155,7 @@ public:
                     Owned<StringContextLogger> logctx = new StringContextLogger(id); // NB may get linked by the onceContext
                     sharedOnceContext->checkOnceDone(this, *logctx);
                 }
-                addToMap();  // Publishes for slaves to see
+                addToMap();  // Publishes for agents to see
             }
             catch (IException *E)
             {
@@ -1192,7 +1192,7 @@ public:
     }
 
     // There are two very similar-looking maps of queries - they have slightly different lifetimes and characteristics
-    // One has fully-constructed queries suitable for use responding to a slave request.
+    // One has fully-constructed queries suitable for use responding to a agent request.
     // The other has potentially partially-constructed queries, and is used for ensuring we only build them once
     // while allowing for parallelizing package loads.
 
@@ -1405,7 +1405,7 @@ static hash64_t getQueryHash(const char *id, const IQueryDll *dll, const IRoxieP
         return *graphMap.getValue(name);
     }
 
-    virtual IActivityGraph *lookupGraph(IRoxieSlaveContext *ctx, const char *name, IProbeManager *probeManager, const IRoxieContextLogger &logctx, IRoxieServerActivity *parentActivity) const override
+    virtual IActivityGraph *lookupGraph(IRoxieAgentContext *ctx, const char *name, IProbeManager *probeManager, const IRoxieContextLogger &logctx, IRoxieServerActivity *parentActivity) const override
     {
         assertex(name && *name);
         ActivityArrayPtr *graph = graphMap.getValue(name);
@@ -1497,7 +1497,7 @@ static hash64_t getQueryHash(const char *id, const IQueryDll *dll, const IRoxieP
             }
         }
     }
-    virtual void getQueryInfo(StringBuffer &reply, bool full, IArrayOf<IQueryFactory> *slaveQueries, const IRoxieContextLogger &logctx) const override
+    virtual void getQueryInfo(StringBuffer &reply, bool full, IArrayOf<IQueryFactory> *agentQueries, const IRoxieContextLogger &logctx) const override
     {
         Owned<IPropertyTree> xref = createPTree("Query", ipt_fast);
         xref->setProp("@id", id);
@@ -1515,14 +1515,15 @@ static hash64_t getQueryHash(const char *id, const IQueryDll *dll, const IRoxieP
                 f->getXrefInfo(*xref, logctx);
             }
         }
-        if (slaveQueries)
+        if (agentQueries)
         {
-            ForEachItemIn(idx, *slaveQueries)
+            ForEachItemIn(idx, *agentQueries)
             {
-                if (slaveQueries->item(idx).suspended())
+                if (agentQueries->item(idx).suspended())
                 {
                     xref->setPropBool("@suspended", true);
-                    xref->setPropBool("@slaveSuspended", true);
+                    xref->setPropBool("@agentSuspended", true);
+                    xref->setPropBool("@slaveSuspended", true);  // legacy name
                 }
             }
         }
@@ -1609,9 +1610,9 @@ static hash64_t getQueryHash(const char *id, const IQueryDll *dll, const IRoxieP
         return strdup(result ? result : defaultValue);
     }
 
-    virtual IRoxieSlaveContext *createSlaveContext(const SlaveContextLogger &logctx, IRoxieQueryPacket *packet, bool hasChildren) const override
+    virtual IRoxieAgentContext *createAgentContext(const AgentContextLogger &logctx, IRoxieQueryPacket *packet, bool hasChildren) const override
     {
-        throwUnexpected();   // only implemented in derived slave class
+        throwUnexpected();   // only implemented in derived agent class
     }
 
     virtual IRoxieServerContext *createContext(IPropertyTree *xml, IHpccProtocolResponse *protocol, unsigned flags, const ContextLogger &_logctx, PTreeReaderOptions xmlReadFlags, const char *querySetName) const override
@@ -1622,7 +1623,7 @@ static hash64_t getQueryHash(const char *id, const IQueryDll *dll, const IRoxieP
     {
         throwUnexpected();   // only implemented in derived server class
     }
-    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsed, unsigned memused, unsigned slavesReplyLen, unsigned bytesOut) override
+    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsed, unsigned memused, unsigned agentsReplyLen, unsigned bytesOut) override
     {
         throwUnexpected();   // only implemented in derived server class
     }
@@ -1703,15 +1704,15 @@ public:
     {
         queryStats.setown(createQueryStatsAggregator(id.get(), statsExpiryTime));
     }
-    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsed, unsigned memused, unsigned slavesReplyLen, unsigned bytesOut)
+    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsed, unsigned memused, unsigned agentsReplyLen, unsigned bytesOut)
     {
-        queryStats->noteQuery(startTime, failed, elapsed, memused, slavesReplyLen, bytesOut);
-        queryGlobalQueryStatsAggregator()->noteQuery(startTime, failed, elapsed, memused, slavesReplyLen, bytesOut);
+        queryStats->noteQuery(startTime, failed, elapsed, memused, agentsReplyLen, bytesOut);
+        queryGlobalQueryStatsAggregator()->noteQuery(startTime, failed, elapsed, memused, agentsReplyLen, bytesOut);
     }
 
     virtual void addDependency(unsigned sourceIdx, unsigned sourceId, unsigned targetId, int controlId, const char *edgeId, ActivityArray * activities) override
     {
-        // addDependency is expected to fail occasionally on slave, but never on Roxie server
+        // addDependency is expected to fail occasionally on agent, but never on Roxie server
         if (!doAddDependency(sourceIdx, sourceId, targetId, controlId, edgeId, activities))
             throw MakeStringException(ROXIE_ADDDEPENDENCY_ERROR, "Failed to create dependency from %u on %u", sourceId, targetId);
     }
@@ -1845,16 +1846,16 @@ extern IQueryFactory *createServerQueryFactoryFromWu(IConstWorkUnit *wu, const I
 
 //==============================================================================================================================================
 
-class CSlaveQueryFactory : public CQueryFactory
+class CAgentQueryFactory : public CQueryFactory
 {
-    void addActivity(ISlaveActivityFactory *activity, ActivityArray *activities)
+    void addActivity(IAgentActivityFactory *activity, ActivityArray *activities)
     {
         activities->append(*activity);
         unsigned activityId = activity->queryId();
         allActivities.setValue(activityId, activity);
     }
 
-    void loadSlaveNode(IPropertyTree &node, unsigned subgraphId, ActivityArray *activities)
+    void loadAgentNode(IPropertyTree &node, unsigned subgraphId, ActivityArray *activities)
     {
         ThorActivityKind kind = getActivityKind(node);
         switch (kind)
@@ -1891,7 +1892,7 @@ class CSlaveQueryFactory : public CQueryFactory
         default:
             return;
         }
-        ISlaveActivityFactory *newAct = NULL;
+        IAgentActivityFactory *newAct = NULL;
         if (kind != TAKsubgraph)
         {
             if (isSuspended)
@@ -1962,7 +1963,7 @@ class CSlaveQueryFactory : public CQueryFactory
                     newAct = createRoxieKeyedJoinIndexActivityFactory(node, subgraphId, *this, helperFactory);
                     if (node.getPropBool("att[@name=\"_diskAccessRequired\"]/@value"))
                     {
-                        ISlaveActivityFactory *newAct2 = createRoxieKeyedJoinFetchActivityFactory(node, subgraphId, *this, helperFactory);
+                        IAgentActivityFactory *newAct2 = createRoxieKeyedJoinFetchActivityFactory(node, subgraphId, *this, helperFactory);
                         unsigned activityId2 = newAct2->queryId() | ROXIE_ACTIVITY_FETCH;
                         activities->append(*newAct2);
                         allActivities.setValue(activityId2, newAct2);
@@ -1985,7 +1986,7 @@ class CSlaveQueryFactory : public CQueryFactory
         }
         else if (kind == TAKsubgraph)
         {
-            // If the subgraph belongs to a remote activity, we need to be able to execute it on the slave...
+            // If the subgraph belongs to a remote activity, we need to be able to execute it on the agent...
             IPropertyTree * childGraphNode = node.queryPropTree("att/graph");
             if (!childGraphNode->getPropBool("@child"))
             {
@@ -2004,7 +2005,7 @@ class CSlaveQueryFactory : public CQueryFactory
             ForEach(*nodes)
             {
                 IPropertyTree &node = nodes->query();
-                loadSlaveNode(node, subgraphId, activities);
+                loadAgentNode(node, subgraphId, activities);
             }
         }
     }
@@ -2016,20 +2017,20 @@ class CSlaveQueryFactory : public CQueryFactory
         ForEach(*nodes)
         {
             IPropertyTree &node = nodes->query();
-            loadSlaveNode(node, subgraphId, activities);
+            loadAgentNode(node, subgraphId, activities);
         }
-        loadSlaveNode(graph, subgraphId, activities); // MORE - not really sure why this line is here!
+        loadAgentNode(graph, subgraphId, activities); // MORE - not really sure why this line is here!
     }
 
 public:
-    CSlaveQueryFactory(const char *_id, const IQueryDll *_dll, const IRoxiePackage &_package, hash64_t _hashValue, unsigned _channelNo, ISharedOnceContext *_sharedOnceContext, bool _dynamic)
+    CAgentQueryFactory(const char *_id, const IQueryDll *_dll, const IRoxiePackage &_package, hash64_t _hashValue, unsigned _channelNo, ISharedOnceContext *_sharedOnceContext, bool _dynamic)
         : CQueryFactory(_id, _dll, _package, _hashValue, _channelNo, _sharedOnceContext, _dynamic)
     {
     }
 
-    virtual IRoxieSlaveContext *createSlaveContext(const SlaveContextLogger &logctx, IRoxieQueryPacket *packet, bool hasChildren) const
+    virtual IRoxieAgentContext *createAgentContext(const AgentContextLogger &logctx, IRoxieQueryPacket *packet, bool hasChildren) const
     {
-        return ::createSlaveContext(this, logctx, packet, hasChildren);
+        return ::createAgentContext(this, logctx, packet, hasChildren);
     }
 
     virtual ActivityArray *loadGraph(IPropertyTree &graph, const char *graphName)
@@ -2075,7 +2076,7 @@ public:
     }
 };
 
-IQueryFactory *createSlaveQueryFactory(const char *id, const IQueryDll *dll, const IRoxiePackage &package, unsigned channel, const IPropertyTree *stateInfo, bool isDynamic, bool forceRetry)
+IQueryFactory *createAgentQueryFactory(const char *id, const IQueryDll *dll, const IRoxiePackage &package, unsigned channel, const IPropertyTree *stateInfo, bool isDynamic, bool forceRetry)
 {
     IArrayOf<IResolvedFile> queryFiles; // Note - these should stay in scope long enough to ensure still cached when (if) query is loaded for real
     Owned<CQueryFactory> ret;
@@ -2092,19 +2093,19 @@ IQueryFactory *createSlaveQueryFactory(const char *id, const IQueryDll *dll, con
             checkWorkunitVersionConsistency(dll);
             Owned<IQueryFactory> serverFactory = CQueryFactory::getCachedQuery(hashValue, 0);
             assertex(serverFactory);
-            ret.setown(new CSlaveQueryFactory(id, dll, package, hashValue, channel, serverFactory->querySharedOnceContext(), isDynamic));
+            ret.setown(new CAgentQueryFactory(id, dll, package, hashValue, channel, serverFactory->querySharedOnceContext(), isDynamic));
         }
         else
-            ret.setown(new CSlaveQueryFactory(id, NULL, package, hashValue, channel, NULL, isDynamic));
+            ret.setown(new CAgentQueryFactory(id, NULL, package, hashValue, channel, NULL, isDynamic));
     }
     ret->init(stateInfo);
     return ret.getClear();
 }
 
-extern IQueryFactory *createSlaveQueryFactoryFromWu(IConstWorkUnit *wu, unsigned channelNo)
+extern IQueryFactory *createAgentQueryFactoryFromWu(IConstWorkUnit *wu, unsigned channelNo)
 {
     Owned<const IQueryDll> dll = createWuQueryDll(wu);
     if (!dll)
         return NULL;
-    return createSlaveQueryFactory(wu->queryWuid(), dll.getClear(), queryRootRoxiePackage(), channelNo, NULL, true, false);  // MORE - if use a constant for id might cache better?
+    return createAgentQueryFactory(wu->queryWuid(), dll.getClear(), queryRootRoxiePackage(), channelNo, NULL, true, false);  // MORE - if use a constant for id might cache better?
 }

roxie/ccd/ccdquery.hpp

@@ -47,7 +47,7 @@ interface IActivityGraph : extends IInterface
     virtual IThorChildGraph * queryChildGraph() = 0;
     virtual IEclGraphResults * queryLocalGraph() = 0;
     virtual IRoxieServerChildGraph * queryLoopGraph() = 0;
-    virtual IRoxieServerChildGraph * createGraphLoopInstance(IRoxieSlaveContext *ctx, unsigned loopCounter, unsigned parentExtractSize, const byte * parentExtract, const IRoxieContextLogger &logctx) = 0;
+    virtual IRoxieServerChildGraph * createGraphLoopInstance(IRoxieAgentContext *ctx, unsigned loopCounter, unsigned parentExtractSize, const byte * parentExtract, const IRoxieContextLogger &logctx) = 0;
     virtual const char *queryName() const = 0;
     virtual void gatherStatistics(IStatisticGatherer * statsBuilder) const = 0;
     virtual void setPrefix(const char *prefix) = 0;
@@ -78,7 +78,7 @@ public:
 
     void setFromWorkUnit(IConstWorkUnit &wu, const IPropertyTree *stateInfo);
     void setFromContext(const IPropertyTree *ctx);
-    void setFromSlaveLoggingFlags(unsigned loggingFlags);
+    void setFromAgentLoggingFlags(unsigned loggingFlags);
 
 
     unsigned priority;
@@ -127,9 +127,9 @@ private:
 
 interface IQueryFactory : extends IInterface
 {
-    virtual IRoxieSlaveContext *createSlaveContext(const SlaveContextLogger &logctx, IRoxieQueryPacket *packet, bool hasChildren) const = 0;
-    virtual IActivityGraph *lookupGraph(IRoxieSlaveContext *ctx, const char *name, IProbeManager *probeManager, const IRoxieContextLogger &logctx, IRoxieServerActivity *parentActivity) const = 0;
-    virtual ISlaveActivityFactory *getSlaveActivityFactory(unsigned id) const = 0;
+    virtual IRoxieAgentContext *createAgentContext(const AgentContextLogger &logctx, IRoxieQueryPacket *packet, bool hasChildren) const = 0;
+    virtual IActivityGraph *lookupGraph(IRoxieAgentContext *ctx, const char *name, IProbeManager *probeManager, const IRoxieContextLogger &logctx, IRoxieServerActivity *parentActivity) const = 0;
+    virtual IAgentActivityFactory *getAgentActivityFactory(unsigned id) const = 0;
     virtual IRoxieServerActivityFactory *getRoxieServerActivityFactory(unsigned id) const = 0;
     virtual hash64_t queryHash() const = 0;
     virtual const char *queryQueryName() const = 0;
@@ -159,12 +159,12 @@ interface IQueryFactory : extends IInterface
 
     virtual IRoxieServerContext *createContext(IPropertyTree *xml, IHpccProtocolResponse *protocol, unsigned flags, const ContextLogger &_logctx, PTreeReaderOptions xmlReadFlags, const char *querySetName) const = 0;
     virtual IRoxieServerContext *createContext(IConstWorkUnit *wu, const ContextLogger &_logctx) const = 0;
-    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsed, unsigned memused, unsigned slavesReplyLen, unsigned bytesOut) = 0;
+    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsed, unsigned memused, unsigned agentsReplyLen, unsigned bytesOut) = 0;
     virtual IPropertyTree *getQueryStats(time_t from, time_t to) = 0;
     virtual void getGraphNames(StringArray &ret) const = 0;
 
     virtual IQueryFactory *lookupLibrary(const char *libraryName, unsigned expectedInterfaceHash, const IRoxieContextLogger &logctx) const = 0;
-    virtual void getQueryInfo(StringBuffer &result, bool full, IArrayOf<IQueryFactory> *slaveQueries,const IRoxieContextLogger &logctx) const = 0;
+    virtual void getQueryInfo(StringBuffer &result, bool full, IArrayOf<IQueryFactory> *agentQueries,const IRoxieContextLogger &logctx) const = 0;
     virtual bool isDynamic() const = 0;
     virtual void checkSuspended() const = 0;
     virtual void onTermination(TerminationCallbackInfo *info) const= 0;
@@ -212,7 +212,7 @@ typedef MapStringTo<ActivityGraphPtr> MapStringToActivityGraph; // Note not link
 typedef IActivityFactory *IActivityFactoryPtr;
 typedef MapBetween<unsigned, unsigned, IActivityFactoryPtr, IActivityFactoryPtr> MapIdToActivityFactory;
 
-// Common base class for Roxie server and slave activity code - see IActivityFactory
+// Common base class for Roxie server and agent activity code - see IActivityFactory
 
 class CActivityFactory : public CInterface
 {
@@ -255,7 +255,7 @@ public:
 
     virtual void getEdgeProgressInfo(unsigned idx, IPropertyTree &edge) const
     {
-        // No meaningful edge info for remote slave activities...
+        // No meaningful edge info for remote agent activities...
     }
 
     virtual void getNodeProgressInfo(IPropertyTree &node) const
@@ -329,10 +329,10 @@ extern const IQueryDll *createExeQueryDll(const char *exeName);
 extern const IQueryDll *createWuQueryDll(IConstWorkUnit *wu);
 
 extern IQueryFactory *createServerQueryFactory(const char *id, const IQueryDll *dll, const IRoxiePackage &package, const IPropertyTree *stateInfo, bool isDynamic, bool forceRetry);
-extern IQueryFactory *createSlaveQueryFactory(const char *id, const IQueryDll *dll, const IRoxiePackage &package, unsigned _channelNo, const IPropertyTree *stateInfo, bool isDynamic, bool forceRetry);
+extern IQueryFactory *createAgentQueryFactory(const char *id, const IQueryDll *dll, const IRoxiePackage &package, unsigned _channelNo, const IPropertyTree *stateInfo, bool isDynamic, bool forceRetry);
 extern IQueryFactory *getQueryFactory(hash64_t hashvalue, unsigned channel);
 extern IQueryFactory *createServerQueryFactoryFromWu(IConstWorkUnit *wu, const IQueryDll *_dll);
-extern IQueryFactory *createSlaveQueryFactoryFromWu(IConstWorkUnit *wu, unsigned channelNo);
+extern IQueryFactory *createAgentQueryFactoryFromWu(IConstWorkUnit *wu, unsigned channelNo);
 extern unsigned checkWorkunitVersionConsistency(const IConstWorkUnit *wu );
 
 inline unsigned findParentId(IPropertyTree &node)

roxie/ccd/ccdqueue.cpp

@@ -76,8 +76,8 @@ unsigned RoxiePacketHeader::getSubChannelMask(unsigned subChannel)
 
 unsigned RoxiePacketHeader::priorityHash() const
 {
-    // Used to determine which slave to act as primary and which as secondary for a given packet (thus spreading the load)
-    // It's important that we do NOT include channel (since that would result in different values for the different slaves responding to a broadcast)
+    // Used to determine which agent to act as primary and which as secondary for a given packet (thus spreading the load)
+    // It's important that we do NOT include channel (since that would result in different values for the different agents responding to a broadcast)
     // We also don't include continueSequence since we'd prefer continuations to go the same way as original
     unsigned hash = serverId.hash();
     hash = hashc((const unsigned char *) &uid, sizeof(uid), hash);
@@ -165,7 +165,7 @@ StringBuffer &RoxiePacketHeader::toString(StringBuffer &ret) const
 
 bool RoxiePacketHeader::allChannelsFailed()
 {
-    unsigned mask = (1 << (getNumSlaves(channel) * SUBCHANNEL_BITS)) - 1;
+    unsigned mask = (1 << (getNumAgents(channel) * SUBCHANNEL_BITS)) - 1;
     return (retries & mask) == mask;
 }
 
@@ -173,8 +173,8 @@ bool RoxiePacketHeader::retry()
 {
     bool worthRetrying = false;
     unsigned mask = SUBCHANNEL_MASK;
-    unsigned numSlaves = getNumSlaves(channel);
-    for (unsigned subChannel = 0; subChannel < numSlaves; subChannel++)
+    unsigned numAgents = getNumAgents(channel);
+    for (unsigned subChannel = 0; subChannel < numAgents; subChannel++)
     {
         unsigned subRetries = (retries & mask) >> (subChannel * SUBCHANNEL_BITS);
         if (subRetries != SUBCHANNEL_MASK)
@@ -211,7 +211,7 @@ unsigned getReplicationLevel(unsigned channel)
 
 //============================================================================================
 
-// This function maps a slave number to the multicast ip used to talk to it.
+// This function maps a agent number to the multicast ip used to talk to it.
 
 IpAddress multicastBase("239.1.1.1");           // TBD IPv6 (need IPv6 multicast addresses?
 IpAddress multicastLast("239.1.5.254");
@@ -275,7 +275,7 @@ void openMulticastSocket()
         }
         if (traceLevel)
             DBGLOG("Roxie: multicast socket created port=%d sockbuffsize=%d actual %d", ccdMulticastPort, udpMulticastBufferSize, actualSize);
-        if (roxieMulticastEnabled && !localSlave)
+        if (roxieMulticastEnabled && !localAgent)
         {
             Owned<const ITopologyServer> topology = getTopology();
             for (unsigned channel : topology->queryChannels())
@@ -283,7 +283,7 @@ void openMulticastSocket()
                 assertex(channel);
                 joinMulticastChannel(channel);
             }
-            joinMulticastChannel(0); // all slaves also listen on channel 0
+            joinMulticastChannel(0); // all agents also listen on channel 0
 
         }
     }
@@ -304,9 +304,9 @@ size32_t channelWrite(unsigned channel, void const* buf, size32_t size)
     else
     {
         Owned<const ITopologyServer> topo = getTopology();
-        const SocketEndpointArray &eps = topo->querySlaves(channel);
+        const SocketEndpointArray &eps = topo->queryAgents(channel);
         if (!eps.ordinality())
-            throw makeStringExceptionV(0, "No slaves available for channel %d", channel);
+            throw makeStringExceptionV(0, "No agents available for channel %d", channel);
         ForEachItemIn(idx, eps)
         {
             size32_t wrote = multicastSocket->udp_write_to(eps.item(idx), buf, size);
@@ -533,7 +533,7 @@ public:
 
 extern IRoxieQueryPacket *createRoxiePacket(void *_data, unsigned _len)
 {
-    if ((unsigned short)_len != _len && !localSlave)
+    if ((unsigned short)_len != _len && !localAgent)
     {
         StringBuffer s;
         RoxiePacketHeader *header = (RoxiePacketHeader *) _data;
@@ -552,19 +552,19 @@ extern IRoxieQueryPacket *createRoxiePacket(MemoryBuffer &m)
 
 //=================================================================================
 
-SlaveContextLogger::SlaveContextLogger()
+AgentContextLogger::AgentContextLogger()
 {
     GetHostIp(ip);
     set(NULL);
 }
 
-SlaveContextLogger::SlaveContextLogger(IRoxieQueryPacket *packet)
+AgentContextLogger::AgentContextLogger(IRoxieQueryPacket *packet)
 {
     GetHostIp(ip);
     set(packet);
 }
 
-void SlaveContextLogger::set(IRoxieQueryPacket *packet)
+void AgentContextLogger::set(IRoxieQueryPacket *packet)
 {
     anyOutput = false;
     intercept = false;
@@ -622,7 +622,7 @@ void SlaveContextLogger::set(IRoxieQueryPacket *packet)
         ip.getIpText(s);
         s.append(':').append(channel);
         StringContextLogger::set(s.str());
-        if (intercept || mergeSlaveStatistics)
+        if (intercept || mergeAgentStatistics)
         {
             RoxiePacketHeader newHeader(header, ROXIE_TRACEINFO, 0);  // subchannel not relevant
             output.setown(ROQ->createOutputStream(newHeader, true, *this));
@@ -636,9 +636,9 @@ void SlaveContextLogger::set(IRoxieQueryPacket *packet)
 }
 
 
-void SlaveContextLogger::putStatProcessed(unsigned subGraphId, unsigned actId, unsigned idx, unsigned processed, unsigned strands) const
+void AgentContextLogger::putStatProcessed(unsigned subGraphId, unsigned actId, unsigned idx, unsigned processed, unsigned strands) const
 {
-    if (output && mergeSlaveStatistics)
+    if (output && mergeAgentStatistics)
     {
         MemoryBuffer buf;
         buf.append((char) LOG_CHILDCOUNT); // A special log entry for the stats
@@ -650,9 +650,9 @@ void SlaveContextLogger::putStatProcessed(unsigned subGraphId, unsigned actId, u
     }
 }
 
-void SlaveContextLogger::putStats(unsigned subGraphId, unsigned actId, const CRuntimeStatisticCollection &stats) const
+void AgentContextLogger::putStats(unsigned subGraphId, unsigned actId, const CRuntimeStatisticCollection &stats) const
 {
-    if (output && mergeSlaveStatistics)
+    if (output && mergeAgentStatistics)
     {
         MemoryBuffer buf;
         buf.append((char) LOG_CHILDSTATS); // A special log entry for the stats
@@ -669,12 +669,12 @@ void SlaveContextLogger::putStats(unsigned subGraphId, unsigned actId, const CRu
     }
 }
 
-void SlaveContextLogger::flush()
+void AgentContextLogger::flush()
 {
     if (output)
     {
         CriticalBlock b(crit);
-        if (mergeSlaveStatistics)
+        if (mergeAgentStatistics)
         {
             MemoryBuffer buf;
             buf.append((char) LOG_STATVALUES); // A special log entry for the stats
@@ -825,7 +825,7 @@ public:
 
     void start()
     {
-        if (prestartSlaveThreads)
+        if (prestartAgentThreads)
         {
             while (started < numWorkers)
             {
@@ -893,7 +893,7 @@ public:
             if (traceLevel > 0)
             {
                 StringBuffer xx;
-                SlaveContextLogger l(x);
+                AgentContextLogger l(x);
                 l.CTXLOG("Ignored retry on subchannel %u for queued activity %s", subChannel, header.toString(xx).str());
             }
             if (!subChannel)
@@ -908,7 +908,7 @@ public:
             noteQueued();
             if (traceLevel > 10)
             {
-                SlaveContextLogger l(x);
+                AgentContextLogger l(x);
                 StringBuffer xx; 
                 l.CTXLOG("enqueued %s", header.toString(xx).str());
             }
@@ -942,7 +942,7 @@ public:
         {
 #ifdef _DEBUG
             RoxiePacketHeader &header = found->queryHeader();
-            SlaveContextLogger l(found);
+            AgentContextLogger l(found);
             StringBuffer xx;
             l.CTXLOG("discarded %s", header.toString(xx).str());
 #endif
@@ -1009,10 +1009,10 @@ class CRoxieWorker : public CInterface, implements IPooledThread
     bool stopped;
     bool abortJob;
     bool busy;
-    Owned<IRoxieSlaveActivity> activity;
+    Owned<IRoxieAgentActivity> activity;
     Owned<IRoxieQueryPacket> packet;
     Owned<const ITopologyServer> topology;
-    SlaveContextLogger logctx;
+    AgentContextLogger logctx;
 
 public:
     IMPLEMENT_IINTERFACE;
@@ -1039,7 +1039,7 @@ public:
         stopped = true;
         return true; 
     }
-    inline void setActivity(IRoxieSlaveActivity *act)
+    inline void setActivity(IRoxieAgentActivity *act)
     {
         CriticalBlock b(actCrit);
         activity.setown(act);
@@ -1076,9 +1076,9 @@ public:
                 ibytiSem.signal();
             if (activity) 
             {
-                // Try to stop/abort a job after it starts only if IBYTI comes from a higher priority slave 
-                // (more primary in the rank). The slaves with higher rank will hold the lower bits of the retries field in IBYTI packet).
-                if (!checkRank || topology->queryChannelInfo(h.channel).otherSlaveHasPriority(h.priorityHash(), h.getRespondingSubChannel()))
+                // Try to stop/abort a job after it starts only if IBYTI comes from a higher priority agent 
+                // (more primary in the rank). The agents with higher rank will hold the lower bits of the retries field in IBYTI packet).
+                if (!checkRank || topology->queryChannelInfo(h.channel).otherAgentHasPriority(h.priorityHash(), h.getRespondingSubChannel()))
                 {
                     activity->abort();
                     return true;
@@ -1097,7 +1097,7 @@ public:
         return false;
     }
 
-    void throwRemoteException(IException *E, IRoxieSlaveActivity *activity, IRoxieQueryPacket *packet, bool isUser)
+    void throwRemoteException(IException *E, IRoxieAgentActivity *activity, IRoxieQueryPacket *packet, bool isUser)
     {
         try 
         {
@@ -1116,14 +1116,14 @@ public:
             if (!isUser)
             {
                 StringBuffer s;
-                s.append("Exception in slave for packet ");
+                s.append("Exception in agent for packet ");
                 header.toString(s);
                 logctx.logOperatorException(E, NULL, 0, "%s", s.str());
                 header.setException(mySubChannel);
-                if (!header.allChannelsFailed() && !localSlave)
+                if (!header.allChannelsFailed() && !localAgent)
                 {
                     if (logctx.queryTraceLevel() > 1) 
-                        logctx.CTXLOG("resending packet from slave in case others want to try it");
+                        logctx.CTXLOG("resending packet from agent in case others want to try it");
                     ROQ->sendPacket(packet, logctx);
                 }
             }
@@ -1164,20 +1164,20 @@ public:
         hash64_t queryHash = packet->queryHeader().queryHash;
         unsigned activityId = packet->queryHeader().activityId & ~ROXIE_PRIORITY_MASK;
         Owned<IQueryFactory> queryFactory = getQueryFactory(queryHash, channel);
-        unsigned numSlaves = topology->querySlaves(channel).ordinality();
+        unsigned numAgents = topology->queryAgents(channel).ordinality();
         unsigned mySubChannel = topology->queryChannelInfo(channel).subChannel();
         if (!queryFactory && logctx.queryWuid())
         {
             Owned <IRoxieDaliHelper> daliHelper = connectToDali();
             Owned<IConstWorkUnit> wu = daliHelper->attachWorkunit(logctx.queryWuid(), NULL);
-            queryFactory.setown(createSlaveQueryFactoryFromWu(wu, channel));
+            queryFactory.setown(createAgentQueryFactoryFromWu(wu, channel));
             if (queryFactory)
                 cacheOnDemandQuery(queryHash, channel, queryFactory);
         }
         if (!queryFactory)
         {
             StringBuffer hdr;
-            IException *E = MakeStringException(MSGAUD_operator, ROXIE_UNKNOWN_QUERY, "Roxie slave received request for unregistered query: %s", packet->queryHeader().toString(hdr).str());
+            IException *E = MakeStringException(MSGAUD_operator, ROXIE_UNKNOWN_QUERY, "Roxie agent received request for unregistered query: %s", packet->queryHeader().toString(hdr).str());
             EXCLOG(E, "doActivity");
             throwRemoteException(E, activity, packet, false);
             return;
@@ -1187,9 +1187,9 @@ public:
             if (logctx.queryTraceLevel() > 8) 
             {
                 StringBuffer x;
-                logctx.CTXLOG("IBYTI delay controls : doIbytiDelay=%s numslaves=%u subchnl=%u : %s",
+                logctx.CTXLOG("IBYTI delay controls : doIbytiDelay=%s numagents=%u subchnl=%u : %s",
                     doIbytiDelay?"YES":"NO", 
-                    numSlaves, topology->queryChannelInfo(channel).subChannel(),
+                    numAgents, topology->queryChannelInfo(channel).subChannel(),
                     header.toString(x).str());
             }
             bool debugging = logctx.queryDebuggerActive();
@@ -1198,10 +1198,10 @@ public:
                 if (mySubChannel)
                     abortJob = true;  // when debugging, we always run on primary only...
             }
-            else if (doIbytiDelay && (numSlaves > 1))
+            else if (doIbytiDelay && (numAgents > 1))
             {
                 unsigned hdrHashVal = header.priorityHash();
-                unsigned primarySubChannel = (hdrHashVal % numSlaves);
+                unsigned primarySubChannel = (hdrHashVal % numAgents);
                 if (primarySubChannel != mySubChannel)
                 {
                     unsigned delay = topology->queryChannelInfo(channel).getIbytiDelay(primarySubChannel);
@@ -1256,7 +1256,7 @@ public:
             if (!debugging)
                 ROQ->sendIbyti(header, logctx, mySubChannel);
             activitiesStarted++;
-            Owned <ISlaveActivityFactory> factory = queryFactory->getSlaveActivityFactory(activityId);
+            Owned <IAgentActivityFactory> factory = queryFactory->getAgentActivityFactory(activityId);
             assertex(factory);
             setActivity(factory->createActivity(logctx, packet));
             Owned<IMessagePacker> output = activity->process();
@@ -1304,8 +1304,8 @@ public:
                     queue->wait();
                     if (stopped)
                         break;
-                    slavesActive++;
-                    maxSlavesActive.store_max(slavesActive);
+                    agentsActive++;
+                    maxAgentsActive.store_max(agentsActive);
                     abortJob = false;
                     busy = true;
                     if (doIbytiDelay) 
@@ -1368,7 +1368,7 @@ public:
                         topology.clear();
                         logctx.set(NULL);
                     }
-                    slavesActive--;
+                    agentsActive--;
                 }
             }
             catch(IException *E)
@@ -1545,7 +1545,7 @@ public:
 protected:
     void doFileCallback(IRoxieQueryPacket *packet)
     {
-        // This is called on the main slave reader thread so needs to be as fast as possible to avoid lost packets
+        // This is called on the main agent reader thread so needs to be as fast as possible to avoid lost packets
         const char *lfn;
         const char *data;
         unsigned len;
@@ -1869,7 +1869,7 @@ public:
 
     void doIbyti(RoxiePacketHeader &header, RoxieQueue &queue, const ITopologyServer* topology)
     {
-        assertex(!localSlave);
+        assertex(!localAgent);
         bool preActivity = false;
         const ChannelInfo &channelInfo = topology->queryChannelInfo(header.channel);
         unsigned mySubChannel = channelInfo.subChannel();
@@ -1969,7 +1969,7 @@ public:
         else
         {
             Owned<IRoxieQueryPacket> packet = createRoxiePacket(mb);
-            SlaveContextLogger logctx(packet);
+            AgentContextLogger logctx(packet);
             unsigned retries = header.thisChannelRetries(mySubchannel);
             if (retries)
             {
@@ -1979,7 +1979,7 @@ public:
                     return; // someone sent a failure or something - ignore it
 
                 // Send back an out-of-band immediately, to let Roxie server know that channel is still active
-                if (!(testSlaveFailure & 0x800))
+                if (!(testAgentFailure & 0x800))
                 {
                     RoxiePacketHeader newHeader(header, ROXIE_ALIVE, mySubchannel);
                     Owned<IMessagePacker> output = ROQ->createOutputStream(newHeader, true, logctx);
@@ -2260,7 +2260,7 @@ public:
 
     virtual bool isSerialized() const
     {
-        // NOTE: tempting to think that we could avoid serializing in localSlave case, but have to be careful about the lifespan of the rowManager...
+        // NOTE: tempting to think that we could avoid serializing in localAgent case, but have to be careful about the lifespan of the rowManager...
         return true;
     }
 
@@ -2420,7 +2420,7 @@ public:
 
 void LocalMessagePacker::flush()
 {
-    // MORE - I think this means we don't send anything until whole message available in localSlave mode, which
+    // MORE - I think this means we don't send anything until whole message available in localAgent mode, which
     // may not be optimal.
     data.setLength(lastput);
     Owned<ILocalMessageCollator> collator = rm->lookupCollator(id);
@@ -2484,7 +2484,7 @@ public:
                 RoxiePacketHeader newHeader(header, ROXIE_ALIVE, 0);
                 Owned<IMessagePacker> output = createOutputStream(newHeader, true, logctx);
                 output->flush();
-                return; // No point sending the retry in localSlave mode
+                return; // No point sending the retry in localAgent mode
             }
             RoxieQueue *targetQueue;
 #ifdef ROXIE_SLA_LOGIC
@@ -2515,7 +2515,7 @@ public:
 
     virtual void sendIbyti(RoxiePacketHeader &header, const IRoxieContextLogger &logctx, unsigned subChannel) override
     {
-        // Don't do IBYTI's when local slave - no buddy to talk to anyway
+        // Don't do IBYTI's when local agent - no buddy to talk to anyway
     }
 
     virtual void sendAbort(RoxiePacketHeader &header, const IRoxieContextLogger &logctx) override
@@ -2578,7 +2578,7 @@ IRoxieOutputQueueManager *ROQ;
 
 extern IRoxieOutputQueueManager *createOutputQueueManager(unsigned snifferChannel, unsigned numWorkers)
 {
-    if (localSlave)
+    if (localAgent)
         return new RoxieLocalQueueManager(numWorkers);
     else if (useAeron)
         return new RoxieAeronSocketQueueManager(numWorkers);
@@ -2689,7 +2689,7 @@ IPacketDiscarder *createPacketDiscarder()
 
 // There are various possibly interesting ways to reply to a ping:
 // Reply as soon as receive, or put it on the queue like other messages?
-// Reply for every channel, or just once for every slave?
+// Reply for every channel, or just once for every agent?
 // Should I send on channel 0 or round-robin the channels?
 // My gut feeling is that knowing what channels are responding is useful so should reply on every unsuspended channel, 
 // and that the delay caused by queuing system is an interesting part of what we want to measure (though nice to know minimum possible too)

roxie/ccd/ccdserver.hpp

@@ -86,7 +86,7 @@ public:
 interface IRoxieServerActivity;
 interface IRoxieServerChildGraph;
 interface IRoxieServerContext;
-interface IRoxieSlaveContext;
+interface IRoxieAgentContext;
 interface IStrandJunction;
 
 class ClusterWriteHandler;
@@ -107,7 +107,7 @@ interface IFinalRoxieInput : extends IInputBase
     virtual IRoxieServerActivity *queryActivity() = 0;
     virtual IIndexReadActivityInfo *queryIndexReadActivity() = 0;
 
-    virtual IStrandJunction *getOutputStreams(IRoxieSlaveContext *ctx, unsigned idx, PointerArrayOf<IEngineRowStream> &streams, const StrandOptions * consumerOptions, bool consumerOrdered, IOrderedCallbackCollection * orderedCallbacks) = 0;  // Use StrandFlags values for flags
+    virtual IStrandJunction *getOutputStreams(IRoxieAgentContext *ctx, unsigned idx, PointerArrayOf<IEngineRowStream> &streams, const StrandOptions * consumerOptions, bool consumerOrdered, IOrderedCallbackCollection * orderedCallbacks) = 0;  // Use StrandFlags values for flags
 
     inline void stopall()
     {
@@ -116,7 +116,7 @@ interface IFinalRoxieInput : extends IInputBase
     }
 };
 
-extern IEngineRowStream *connectSingleStream(IRoxieSlaveContext *ctx, IFinalRoxieInput *input, unsigned idx, Owned<IStrandJunction> &junction, bool consumerOrdered);
+extern IEngineRowStream *connectSingleStream(IRoxieAgentContext *ctx, IFinalRoxieInput *input, unsigned idx, Owned<IStrandJunction> &junction, bool consumerOrdered);
 
 interface ISteppedConjunctionCollector;
 
@@ -154,7 +154,7 @@ interface IRoxieServerActivity : extends IActivityBase
     virtual void execute(unsigned parentExtractSize, const byte *parentExtract) = 0;
     virtual void onCreate(IHThorArg *colocalArg) = 0;
     virtual void start(unsigned parentExtractSize, const byte *parentExtract, bool paused) = 0;
-    virtual IStrandJunction *getOutputStreams(IRoxieSlaveContext *ctx, unsigned idx, PointerArrayOf<IEngineRowStream> &streams, const StrandOptions * consumerOptions, bool consumerOrdered, IOrderedCallbackCollection * orderedCallbacks) = 0;  // Use StrandFlags values for flags
+    virtual IStrandJunction *getOutputStreams(IRoxieAgentContext *ctx, unsigned idx, PointerArrayOf<IEngineRowStream> &streams, const StrandOptions * consumerOptions, bool consumerOrdered, IOrderedCallbackCollection * orderedCallbacks) = 0;  // Use StrandFlags values for flags
 
     virtual void stop() = 0;
     virtual void abort() = 0;
@@ -184,7 +184,7 @@ interface IRoxieServerActivity : extends IActivityBase
     virtual const IResolvedFile *resolveLFN(const char *fileName, bool isOpt, bool isPrivilegedUser) = 0;
     virtual const IResolvedFile *queryVarFileInfo() const = 0;
 //misc
-    virtual IRoxieSlaveContext *queryContext() = 0;
+    virtual IRoxieAgentContext *queryContext() = 0;
     virtual void serializeSkipInfo(MemoryBuffer &out, unsigned seekLen, const void *rawSeek, unsigned numFields, const void * seek, const SmartStepExtra &stepExtra) const = 0;
     virtual ThorActivityKind getKind() const = 0;
     virtual const IRoxieContextLogger &queryLogCtx() const = 0;
@@ -197,7 +197,7 @@ interface IRoxieServerActivity : extends IActivityBase
 
 interface IRoxieServerActivityFactory : extends IActivityFactory
 {
-    virtual IRoxieServerActivity *createActivity(IRoxieSlaveContext *_ctx, IProbeManager *_probemanager) const = 0;
+    virtual IRoxieServerActivity *createActivity(IRoxieAgentContext *_ctx, IProbeManager *_probemanager) const = 0;
     virtual void setInput(unsigned idx, unsigned source, unsigned sourceidx) = 0;
     virtual bool isSink() const = 0;
     virtual bool isFunction() const = 0;
@@ -214,11 +214,11 @@ interface IRoxieServerActivityFactory : extends IActivityFactory
     virtual IHThorArg &getHelper() const = 0;
     virtual IRoxieServerActivity *createFunction(IHThorArg &helper, IProbeManager *_probeManager) const = 0;
     virtual void noteProcessed(unsigned idx, unsigned processed) const = 0;
-    virtual void onCreateChildQueries(IRoxieSlaveContext *ctx, IHThorArg *colocalArg, IArrayOf<IActivityGraph> &childGraphs, IRoxieServerActivity *parentActivity, IProbeManager *_probeManager, const IRoxieContextLogger &_logctx, unsigned numParallel) const = 0;
+    virtual void onCreateChildQueries(IRoxieAgentContext *ctx, IHThorArg *colocalArg, IArrayOf<IActivityGraph> &childGraphs, IRoxieServerActivity *parentActivity, IProbeManager *_probeManager, const IRoxieContextLogger &_logctx, unsigned numParallel) const = 0;
     virtual void noteStarted() const = 0;
     virtual void noteStarted(unsigned idx) const = 0;
     virtual void noteDependent(unsigned target) = 0;
-    virtual IActivityGraph * createChildGraph(IRoxieSlaveContext * ctx, IHThorArg *colocalArg, unsigned childId, IRoxieServerActivity *parentActivity, IProbeManager * _probeManager, const IRoxieContextLogger &_logctx) const = 0;
+    virtual IActivityGraph * createChildGraph(IRoxieAgentContext * ctx, IHThorArg *colocalArg, unsigned childId, IRoxieServerActivity *parentActivity, IProbeManager * _probeManager, const IRoxieContextLogger &_logctx) const = 0;
     virtual unsigned __int64 queryLocalTimeNs() const = 0;
     virtual bool isGraphInvariant() const = 0;
     virtual IRoxieServerSideCache *queryServerSideCache() const = 0;
@@ -273,7 +273,7 @@ interface IRoxieServerChildGraph : public IInterface
 
 interface IQueryFactory;
 
-extern IActivityGraph *createActivityGraph(IRoxieSlaveContext *ctx, const char *graphName, unsigned id, ActivityArray &x, IRoxieServerActivity *parent, IProbeManager *probeManager, const IRoxieContextLogger &logctx, unsigned numParallel);
+extern IActivityGraph *createActivityGraph(IRoxieAgentContext *ctx, const char *graphName, unsigned id, ActivityArray &x, IRoxieServerActivity *parent, IProbeManager *probeManager, const IRoxieContextLogger &logctx, unsigned numParallel);
 
 extern ruid_t getNextRuid();
 extern void setStartRuid(unsigned restarts);

roxie/ccd/ccdsnmp.cpp

@@ -84,8 +84,8 @@ RelaxedAtomic<unsigned> packetRunCount;
 
 RelaxedAtomic<unsigned> lastQueryDate;
 RelaxedAtomic<unsigned> lastQueryTime;
-RelaxedAtomic<unsigned> slavesActive;
-RelaxedAtomic<unsigned> maxSlavesActive;
+RelaxedAtomic<unsigned> agentsActive;
+RelaxedAtomic<unsigned> maxAgentsActive;
 
 #define addMetric(a, b) doAddMetric(a, #a, b)
 
@@ -366,8 +366,8 @@ CRoxieMetricsManager::CRoxieMetricsManager()
     addMetric(packetsReceived, 1000);
     addMetric(packetsSent, 1000);
     addMetric(resultsReceived, 1000);
-    addMetric(slavesActive, 0);
-    addMetric(maxSlavesActive, 0);
+    addMetric(agentsActive, 0);
+    addMetric(maxAgentsActive, 0);
     addMetric(indexRecordsRead, 1000);
     addMetric(postFiltered, 1000);
     addMetric(abortsSent, 0);
@@ -565,18 +565,18 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
         time_t startTime; // more interesting than end-time
         unsigned elapsedTimeMs;
         unsigned memUsed;
-        unsigned slavesReplyLen;
+        unsigned agentsReplyLen;
         unsigned bytesOut;
         bool failed;
 
     public:
-        QueryStatsRecord(time_t _startTime, bool _failed, unsigned _elapsedTimeMs, unsigned _memused, unsigned _slavesReplyLen, unsigned _bytesOut)
+        QueryStatsRecord(time_t _startTime, bool _failed, unsigned _elapsedTimeMs, unsigned _memused, unsigned _agentsReplyLen, unsigned _bytesOut)
         {
             startTime = _startTime;
             failed = _failed;
             elapsedTimeMs = _elapsedTimeMs;
             memUsed = _memused;
-            slavesReplyLen = _slavesReplyLen;
+            agentsReplyLen = _agentsReplyLen;
             bytesOut = _bytesOut;
         }
 
@@ -609,7 +609,7 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
             unsigned i = 0;
             for (auto r : useStats)
             {
-                aggregator.noteQuery(r.failed, r.elapsedTimeMs, r.memUsed, r.slavesReplyLen, r.bytesOut);
+                aggregator.noteQuery(r.failed, r.elapsedTimeMs, r.memUsed, r.agentsReplyLen, r.bytesOut);
                 times[i++] = r.elapsedTimeMs;
             }
             aggregator.getStats(result, false);
@@ -635,7 +635,7 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
                 queryStatsRecord->setProp("@startTime", dt.getString(s.clear(), true).str());
                 queryStatsRecord->setPropInt("elapsedTimeMs", r.elapsedTimeMs);
                 queryStatsRecord->setPropInt("memUsed", r.memUsed);
-                queryStatsRecord->setPropInt("slavesReplyLen", r.slavesReplyLen);
+                queryStatsRecord->setPropInt("agentsReplyLen", r.agentsReplyLen);
                 queryStatsRecord->setPropInt("bytesOut", r.bytesOut);
                 queryStatsRecord->setPropBool("failed", r.failed);
                 result.addPropTree(queryStatsRecord->queryName(), LINK(queryStatsRecord));
@@ -661,7 +661,7 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
         unsigned __int64 totalTimeMs;
         unsigned __int64 totalTimeMsSquared;
         unsigned __int64 totalMemUsed;
-        unsigned __int64 totalSlavesReplyLen;
+        unsigned __int64 totalAgentsReplyLen;
         unsigned __int64 totalBytesOut;
         unsigned maxTimeMs;
         unsigned minTimeMs;
@@ -679,7 +679,7 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
             totalTimeMs = 0;
             totalTimeMsSquared = 0;
             totalMemUsed = 0;
-            totalSlavesReplyLen = 0;
+            totalAgentsReplyLen = 0;
             totalBytesOut = 0;
             maxTimeMs = 0;
             minTimeMs = 0;
@@ -724,7 +724,7 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
             totalTimeMs += other.totalTimeMs;
             totalTimeMsSquared += other.totalTimeMsSquared;
             totalMemUsed += other.totalMemUsed;
-            totalSlavesReplyLen += other.totalSlavesReplyLen;
+            totalAgentsReplyLen += other.totalAgentsReplyLen;
             totalBytesOut += other.totalBytesOut;
             maxTimeMs = std::max(maxTimeMs, other.maxTimeMs);
             if (other.countTotal)
@@ -739,14 +739,14 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
             
         }
 
-        void noteQuery(bool failed, unsigned elapsedTimeMs, unsigned memUsed, unsigned slavesReplyLen, unsigned bytesOut)
+        void noteQuery(bool failed, unsigned elapsedTimeMs, unsigned memUsed, unsigned agentsReplyLen, unsigned bytesOut)
         {
             totalTimeMs += elapsedTimeMs;
             unsigned __int64 timeSquared = elapsedTimeMs;
             timeSquared *= timeSquared;
             totalTimeMsSquared += timeSquared;
             totalMemUsed += memUsed;
-            totalSlavesReplyLen += slavesReplyLen;
+            totalAgentsReplyLen += agentsReplyLen;
             totalBytesOut += bytesOut;
             if (elapsedTimeMs > maxTimeMs)
                 maxTimeMs = elapsedTimeMs;
@@ -787,7 +787,7 @@ class CQueryStatsAggregator : public CInterface, implements IQueryStatsAggregato
             result.setPropInt64("countFailed", countFailed);
             result.setPropInt64("averageTimeMs", countTotal ? totalTimeMs/countTotal : 0);
             result.setPropInt64("averageMemUsed", countTotal ? totalMemUsed/countTotal : 0);
-            result.setPropInt64("averageSlavesReplyLen", countTotal ? totalSlavesReplyLen/countTotal : 0);
+            result.setPropInt64("averageAgentsReplyLen", countTotal ? totalAgentsReplyLen/countTotal : 0);
             result.setPropInt64("averageBytesOut", countTotal ? totalBytesOut/countTotal : 0);
             // MORE - do something funky and statistical using totalTimeMsSquared
             result.setPropInt("maxTimeMs", maxTimeMs);
@@ -962,13 +962,13 @@ public:
         return result.getClear();
     }
 
-    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsedTimeMs, unsigned memUsed, unsigned slavesReplyLen, unsigned bytesOut)
+    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsedTimeMs, unsigned memUsed, unsigned agentsReplyLen, unsigned bytesOut)
     {
         time_t timeNow;
         time(&timeNow);
         CriticalBlock b(statsLock);
         if (expirySeconds)
-            recent.emplace(recent.end(), startTime, failed, elapsedTimeMs, memUsed, slavesReplyLen, bytesOut);
+            recent.emplace(recent.end(), startTime, failed, elapsedTimeMs, memUsed, agentsReplyLen, bytesOut);
         // Now remove any that have expired
         if (expirySeconds != (unsigned) -1)
         {
@@ -977,7 +977,7 @@ public:
         }
 
         QueryStatsAggregateRecord &aggregator = findAggregate(startTime);
-        aggregator.noteQuery(failed, elapsedTimeMs, memUsed, slavesReplyLen, bytesOut);
+        aggregator.noteQuery(failed, elapsedTimeMs, memUsed, agentsReplyLen, bytesOut);
     }
 
     virtual IPropertyTree *getStats(time_t from, time_t to)

roxie/ccd/ccdsnmp.hpp

@@ -69,7 +69,7 @@ public:
 
 interface IQueryStatsAggregator : public IInterface
 {
-    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsedTimeMs, unsigned memUsed, unsigned slavesReplyLen, unsigned bytesOut) = 0;
+    virtual void noteQuery(time_t startTime, bool failed, unsigned elapsedTimeMs, unsigned memUsed, unsigned agentsReplyLen, unsigned bytesOut) = 0;
     virtual IPropertyTree *getStats(time_t from, time_t to) = 0;
 };
 
@@ -112,8 +112,8 @@ extern RelaxedAtomic<unsigned> diskReadCompleted;
 extern RelaxedAtomic<unsigned> globalSignals;
 extern RelaxedAtomic<unsigned> globalLocks;
 
-extern RelaxedAtomic<unsigned> maxSlavesActive;
-extern RelaxedAtomic<unsigned> slavesActive;
+extern RelaxedAtomic<unsigned> maxAgentsActive;
+extern RelaxedAtomic<unsigned> agentsActive;
 extern RelaxedAtomic<unsigned> rowsOut;
 extern RelaxedAtomic<unsigned> queueLength;
 extern RelaxedAtomic<unsigned> maxQueueLength;

roxie/ccd/ccdstate.cpp

@@ -885,12 +885,12 @@ MODULE_EXIT()
 // IRoxieQuerySetManager
 //  - CRoxieQuerySetManager -
 //    - CRoxieServerQuerySetManager
-//    - CRoxieSlaveQuerySetManager
+//    - CRoxieAgentQuerySetManager
 //
 // Manages a set of instantiated queries and allows us to look them up by queryname or alias
 //
 // IRoxieQuerySetManagerSet
-// - CRoxieSlaveQuerySetManagerSet
+// - CRoxieAgentQuerySetManagerSet
 //
 // Manages the IRoxieQuerySetManager for multiple channels
 //
@@ -898,14 +898,14 @@ MODULE_EXIT()
 // - CRoxieDaliQueryPackageManager
 // - CStandaloneQueryPackageManager
 //
-// Groups a server resource manager and a set of slave resource managers (one per channel) together.
+// Groups a server resource manager and a set of agent resource managers (one per channel) together.
 // There is one per PackageMap
 //
 // CQueryPackageSetManager at outer level
 // There will be exactly one of these. It will reload the CQueryPackageManager's if dali Package info changes
 
 //================================================================================================
-// CRoxieQuerySetManager - shared base class for slave and server query set manager classes
+// CRoxieQuerySetManager - shared base class for agent and server query set manager classes
 // Manages a set of instantiated queries and allows us to look them up by queryname or alias,
 // as well as controlling their lifespan
 //================================================================================================
@@ -1102,16 +1102,16 @@ public:
         }
     }
 
-    virtual void getAllQueryInfo(StringBuffer &reply, bool full, const IRoxieQuerySetManagerSet *slaves, const IRoxieContextLogger &logctx) const
+    virtual void getAllQueryInfo(StringBuffer &reply, bool full, const IRoxieQuerySetManagerSet *agents, const IRoxieContextLogger &logctx) const
     {
         HashIterator elems(queries);
         for (elems.first(); elems.isValid(); elems.next())
         {
             IMapping &cur = elems.query();
             IQueryFactory *query = queries.mapToValue(&cur);
-            IArrayOf<IQueryFactory> slaveQueries;
-            slaves->getQueries(query->queryQueryName(), slaveQueries, logctx);
-            query->getQueryInfo(reply, full, &slaveQueries, logctx);
+            IArrayOf<IQueryFactory> agentQueries;
+            agents->getQueries(query->queryQueryName(), agentQueries, logctx);
+            query->getQueryInfo(reply, full, &agentQueries, logctx);
         }
         HashIterator aliasIterator(aliases);
         for (aliasIterator.first(); aliasIterator.isValid(); aliasIterator.next())
@@ -1162,10 +1162,10 @@ extern IRoxieQuerySetManager *createServerManager(const char *querySet)
 
 //===============================================================================================================
 
-class CRoxieSlaveQuerySetManager : public CRoxieQuerySetManager
+class CRoxieAgentQuerySetManager : public CRoxieQuerySetManager
 {
 public:
-    CRoxieSlaveQuerySetManager(unsigned _channelNo, const char *_querySetName)
+    CRoxieAgentQuerySetManager(unsigned _channelNo, const char *_querySetName)
         : CRoxieQuerySetManager(_channelNo, _querySetName)
     {
         channelNo = _channelNo;
@@ -1173,39 +1173,39 @@ public:
 
     virtual IQueryFactory *loadQueryFromDll(const char *id, const IQueryDll *dll, const IRoxiePackage &package, const IPropertyTree *stateInfo, bool forceRetry)
     {
-        return createSlaveQueryFactory(id, dll, package, channelNo, stateInfo, false, forceRetry);
+        return createAgentQueryFactory(id, dll, package, channelNo, stateInfo, false, forceRetry);
     }
 
 };
 
-class CRoxieSlaveQuerySetManagerSet : public CInterface, implements IRoxieQuerySetManagerSet
+class CRoxieAgentQuerySetManagerSet : public CInterface, implements IRoxieQuerySetManagerSet
 {
 public:
     IMPLEMENT_IINTERFACE;
-    CRoxieSlaveQuerySetManagerSet(unsigned _numChannels, const char *querySetName)
+    CRoxieAgentQuerySetManagerSet(unsigned _numChannels, const char *querySetName)
         : numChannels(_numChannels)
     {
-        managers = new CRoxieSlaveQuerySetManager *[numChannels];
-        memset(managers, 0, sizeof(CRoxieSlaveQuerySetManager *) * numChannels);
+        managers = new CRoxieAgentQuerySetManager *[numChannels];
+        memset(managers, 0, sizeof(CRoxieAgentQuerySetManager *) * numChannels);
         Owned<const ITopologyServer> topology = getTopology();
         for (unsigned channelNo : topology->queryChannels())
         {
             assertex(channelNo>0 && channelNo<=numChannels);
             if (managers[channelNo-1] == NULL)
-                managers[channelNo-1] = new CRoxieSlaveQuerySetManager(channelNo, querySetName);
+                managers[channelNo-1] = new CRoxieAgentQuerySetManager(channelNo, querySetName);
             else
-                throw MakeStringException(ROXIE_INVALID_TOPOLOGY, "Invalid topology file - channel %d repeated for this slave", channelNo);
+                throw MakeStringException(ROXIE_INVALID_TOPOLOGY, "Invalid topology file - channel %d repeated for this agent", channelNo);
         }
     }
 
-    ~CRoxieSlaveQuerySetManagerSet()
+    ~CRoxieAgentQuerySetManagerSet()
     {
         for (unsigned channel = 0; channel < numChannels; channel++)
             ::Release(managers[channel]);
         delete [] managers;
     }
 
-    inline CRoxieSlaveQuerySetManager *item(int idx)
+    inline CRoxieAgentQuerySetManager *item(int idx)
     {
         return managers[idx];
     }
@@ -1230,7 +1230,7 @@ public:
 
 private:
     unsigned numChannels;
-    CRoxieSlaveQuerySetManager **managers;
+    CRoxieAgentQuerySetManager **managers;
 };
 
 //===============================================================================================================
@@ -1347,10 +1347,10 @@ public:
         return serverManager.getLink();
     }
 
-    IRoxieQuerySetManagerSet* getRoxieSlaveManagers()
+    IRoxieQuerySetManagerSet* getRoxieAgentManagers()
     {
         CriticalBlock b2(updateCrit);
-        return slaveManagers.getLink();
+        return agentManagers.getLink();
     }
 
     void getInfo(StringBuffer &reply, const IRoxieContextLogger &logctx) const
@@ -1379,17 +1379,17 @@ public:
             const char *id = query->queryQueryName();
             serverManager->resetQueryTimings(id, logctx);
             for (unsigned channel = 0; channel < numChannels; channel++)
-                if (slaveManagers->item(channel))
+                if (agentManagers->item(channel))
                 {
-                    slaveManagers->item(channel)->resetQueryTimings(id, logctx);
+                    agentManagers->item(channel)->resetQueryTimings(id, logctx);
                 }
         }
         else
         {
             serverManager->resetAllQueryTimings();
             for (unsigned channel = 0; channel < numChannels; channel++)
-                if (slaveManagers->item(channel))
-                    slaveManagers->item(channel)->resetAllQueryTimings();
+                if (agentManagers->item(channel))
+                    agentManagers->item(channel)->resetAllQueryTimings();
         }
         return true;
     }
@@ -1406,10 +1406,10 @@ public:
                 serverManager->getStats(queryId, graphName, freply, logctx);
                 Owned<IPropertyTree> stats = createPTreeFromXMLString(freply.str(), ipt_fast);
                 for (unsigned channel = 0; channel < numChannels; channel++)
-                    if (slaveManagers->item(channel))
+                    if (agentManagers->item(channel))
                     {
                         StringBuffer sreply;
-                        slaveManagers->item(channel)->getStats(queryId, graphName, sreply, logctx);
+                        agentManagers->item(channel)->getStats(queryId, graphName, sreply, logctx);
                         Owned<IPropertyTree> cstats = createPTreeFromXMLString(sreply.str(), ipt_fast);
                         mergeStats(stats, cstats, 1);
                     }
@@ -1425,16 +1425,16 @@ public:
         serverManager->getActivityMetrics(reply);
         for (unsigned channel = 0; channel < numChannels; channel++)
         {
-            if (slaveManagers->item(channel))
+            if (agentManagers->item(channel))
             {
-                slaveManagers->item(channel)->getActivityMetrics(reply);
+                agentManagers->item(channel)->getActivityMetrics(reply);
             }
         }
     }
     void getAllQueryInfo(StringBuffer &reply, bool full, const IRoxieContextLogger &logctx) const
     {
         CriticalBlock b2(updateCrit);
-        serverManager->getAllQueryInfo(reply, full, slaveManagers, logctx);
+        serverManager->getAllQueryInfo(reply, full, agentManagers, logctx);
     }
     const char *queryQuerySetName()
     {
@@ -1442,25 +1442,25 @@ public:
     }
 protected:
 
-    void reloadQueryManagers(CRoxieSlaveQuerySetManagerSet *newSlaveManagers, IRoxieQuerySetManager *newServerManager, hash64_t newHash)
+    void reloadQueryManagers(CRoxieAgentQuerySetManagerSet *newAgentManagers, IRoxieQuerySetManager *newServerManager, hash64_t newHash)
     {
-        Owned<CRoxieSlaveQuerySetManagerSet> oldSlaveManagers;
+        Owned<CRoxieAgentQuerySetManagerSet> oldAgentManagers;
         Owned<IRoxieQuerySetManager> oldServerManager;
         {
             // Atomically, replace the existing query managers with the new ones
             CriticalBlock b2(updateCrit);
-            oldSlaveManagers.setown(slaveManagers.getClear()); // so that the release happens outside the critblock
+            oldAgentManagers.setown(agentManagers.getClear()); // so that the release happens outside the critblock
             oldServerManager.setown(serverManager.getClear()); // so that the release happens outside the critblock
-            slaveManagers.setown(newSlaveManagers);
+            agentManagers.setown(newAgentManagers);
             serverManager.setown(newServerManager);
             queryHash = newHash;
         }
-        if (slaveQueryReleaseDelaySeconds)
-            delayedReleaser->delayedRelease(oldSlaveManagers.getClear(), slaveQueryReleaseDelaySeconds);
+        if (agentQueryReleaseDelaySeconds)
+            delayedReleaser->delayedRelease(oldAgentManagers.getClear(), agentQueryReleaseDelaySeconds);
     }
 
-    mutable CriticalSection updateCrit;  // protects updates of slaveManagers and serverManager
-    Owned<CRoxieSlaveQuerySetManagerSet> slaveManagers;
+    mutable CriticalSection updateCrit;  // protects updates of agentManagers and serverManager
+    Owned<CRoxieAgentQuerySetManagerSet> agentManagers;
     Owned<IRoxieQuerySetManager> serverManager;
 
     Owned<const IRoxiePackageMap> packages;
@@ -1478,7 +1478,7 @@ protected:
  * at a given time (the one associated with the active PackageSet).
  *
  * To deploy new data, typically we will load a new PackageSet, make it active, then release the old one
- * A packageSet is not modified while loaded, to avoid timing issues between slaves and server.
+ * A packageSet is not modified while loaded, to avoid timing issues between agents and server.
  *
  * We need to be able to spot a change (in dali) to the active package indicator (and switch the active CRoxieDaliQueryPackageManager)
  * We need to be able to spot a change (in dali) that adds a new PackageSet
@@ -1527,11 +1527,11 @@ public:
     {
         hash64_t newHash = numChannels;
         Owned<IPropertyTree> newQuerySet = daliHelper->getQuerySet(querySet);
-        Owned<CRoxieSlaveQuerySetManagerSet> newSlaveManagers = new CRoxieSlaveQuerySetManagerSet(numChannels, querySet);
+        Owned<CRoxieAgentQuerySetManagerSet> newAgentManagers = new CRoxieAgentQuerySetManagerSet(numChannels, querySet);
         Owned<IRoxieQuerySetManager> newServerManager = createServerManager(querySet);
         newServerManager->load(newQuerySet, *packages, newHash, forceRetry);
-        newSlaveManagers->load(newQuerySet, *packages, newHash, forceRetry);
-        reloadQueryManagers(newSlaveManagers.getClear(), newServerManager.getClear(), newHash);
+        newAgentManagers->load(newQuerySet, *packages, newHash, forceRetry);
+        reloadQueryManagers(newAgentManagers.getClear(), newServerManager.getClear(), newHash);
         clearKeyStoreCache(false);   // Allows us to fully release files we no longer need because of unloaded queries
     }
 
@@ -1558,11 +1558,11 @@ public:
         Owned<IPropertyTree> newQuerySet = createPTree("QuerySet", ipt_lowmem);
         newQuerySet->setProp("@name", "_standalone");
         newQuerySet->addPropTree("Query", standaloneDll.getLink());
-        Owned<CRoxieSlaveQuerySetManagerSet> newSlaveManagers = new CRoxieSlaveQuerySetManagerSet(numChannels, querySet);
+        Owned<CRoxieAgentQuerySetManagerSet> newAgentManagers = new CRoxieAgentQuerySetManagerSet(numChannels, querySet);
         Owned<IRoxieQuerySetManager> newServerManager = createServerManager(querySet);
         newServerManager->load(newQuerySet, *packages, newHash, forceReload);
-        newSlaveManagers->load(newQuerySet, *packages, newHash, forceReload);
-        reloadQueryManagers(newSlaveManagers.getClear(), newServerManager.getClear(), newHash);
+        newAgentManagers->load(newQuerySet, *packages, newHash, forceReload);
+        reloadQueryManagers(newAgentManagers.getClear(), newServerManager.getClear(), newHash);
     }
 };
 
@@ -1626,7 +1626,7 @@ public:
         throw MakeStringException(ROXIE_LIBRARY_ERROR, "No library available for %s", libraryName);
     }
 
-    IQueryFactory *getQuery(const char *id, StringBuffer *querySet, IArrayOf<IQueryFactory> *slaveQueries, const IRoxieContextLogger &logctx) const
+    IQueryFactory *getQuery(const char *id, StringBuffer *querySet, IArrayOf<IQueryFactory> *agentQueries, const IRoxieContextLogger &logctx) const
     {
         if (querySet && querySet->length() && !allQuerySetNames.contains(querySet->str()))
             throw MakeStringException(ROXIE_INVALID_TARGET, "Target %s not found", querySet->str());
@@ -1638,10 +1638,10 @@ public:
                 IQueryFactory *query = sm->getQuery(id, querySet, logctx);
                 if (query)
                 {
-                    if (slaveQueries)
+                    if (agentQueries)
                     {
-                        Owned<IRoxieQuerySetManagerSet> slaveManagers = allQueryPackages.item(idx).getRoxieSlaveManagers();
-                        slaveManagers->getQueries(id, *slaveQueries, logctx);
+                        Owned<IRoxieQuerySetManagerSet> agentManagers = allQueryPackages.item(idx).getRoxieAgentManagers();
+                        agentManagers->getQueries(id, *agentQueries, logctx);
                     }
                     return query;
                 }
@@ -1675,8 +1675,8 @@ public:
             Owned<IRoxieQuerySetManager> serverManager = allQueryPackages.item(idx).getRoxieServerManager();
             if (serverManager->isActive())
             {
-                Owned<IRoxieQuerySetManagerSet> slaveManagers = allQueryPackages.item(idx).getRoxieSlaveManagers();
-                serverManager->getAllQueryInfo(reply, full, slaveManagers, logctx);
+                Owned<IRoxieQuerySetManagerSet> agentManagers = allQueryPackages.item(idx).getRoxieAgentManagers();
+                serverManager->getAllQueryInfo(reply, full, agentManagers, logctx);
             }
         }
     }
@@ -1915,10 +1915,10 @@ public:
         return allQueryPackages->lookupLibrary(libraryName, expectedInterfaceHash, logctx);
     }
 
-    virtual IQueryFactory *getQuery(const char *id, StringBuffer *querySet, IArrayOf<IQueryFactory> *slaveQueries, const IRoxieContextLogger &logctx) const
+    virtual IQueryFactory *getQuery(const char *id, StringBuffer *querySet, IArrayOf<IQueryFactory> *agentQueries, const IRoxieContextLogger &logctx) const
     {
         ReadLockBlock b(packageCrit);
-        return allQueryPackages->getQuery(id, querySet, slaveQueries, logctx);
+        return allQueryPackages->getQuery(id, querySet, agentQueries, logctx);
     }
 
     virtual int getActivePackageCount() const
@@ -2048,10 +2048,10 @@ private:
                 const char *id = ids->query().queryProp("@id");
                 if (id)
                 {
-                    IArrayOf<IQueryFactory> slaveQueries;
-                    Owned<IQueryFactory> query = getQuery(id, NULL, &slaveQueries, logctx);
+                    IArrayOf<IQueryFactory> agentQueries;
+                    Owned<IQueryFactory> query = getQuery(id, NULL, &agentQueries, logctx);
                     if (query)
-                        query->getQueryInfo(reply, full, &slaveQueries, logctx);
+                        query->getQueryInfo(reply, full, &agentQueries, logctx);
                     else
                         reply.appendf(" <Query id=\"%s\" error=\"Query not found\"/>\n", id);
                 }
@@ -2583,7 +2583,7 @@ private:
             }
             else if (stricmp(queryName, "control:resetcache")==0)
             {
-                releaseSlaveDynamicFileCache();
+                releaseAgentDynamicFileCache();
             }
             else if (stricmp(queryName, "control:resetindexmetrics")==0)
             {
@@ -2702,9 +2702,9 @@ private:
             break;
 
         case 'T':
-            if (stricmp(queryName, "control:testSlaveFailure")==0)
+            if (stricmp(queryName, "control:testAgentFailure")==0)
             {
-                testSlaveFailure = control->getPropInt("@val", 20);
+                testAgentFailure = control->getPropInt("@val", 20);
             }
             else if (stricmp(queryName, "control:timeActivities")==0)
             {

roxie/ccd/ccdstate.hpp

@@ -75,13 +75,13 @@ interface IResolvedFileCache
 
 extern IRoxiePackage *createRoxiePackage(IPropertyTree *p, IRoxiePackageMap *packages);
 
-interface ISlaveDynamicFileCache : extends IInterface
+interface IAgentDynamicFileCache : extends IInterface
 {
     virtual IResolvedFile *lookupDynamicFile(const IRoxieContextLogger &logctx, const char *lfn, CDateTime &cacheDate, unsigned checksum, RoxiePacketHeader *header, bool isOpt, bool isLocal) = 0;
     virtual void releaseAll() = 0;
 };
-extern ISlaveDynamicFileCache *querySlaveDynamicFileCache();
-extern void releaseSlaveDynamicFileCache();
+extern IAgentDynamicFileCache *queryAgentDynamicFileCache();
+extern void releaseAgentDynamicFileCache();
 
 interface IDynamicTransform;
 
@@ -128,7 +128,7 @@ interface IRoxieQuerySetManager : extends IInterface
     virtual void resetQueryTimings(const char *queryName, const IRoxieContextLogger &logctx) = 0;
     virtual void resetAllQueryTimings() = 0;
     virtual void getActivityMetrics(StringBuffer &reply) const = 0;
-    virtual void getAllQueryInfo(StringBuffer &reply, bool full, const IRoxieQuerySetManagerSet *slaves, const IRoxieContextLogger &logctx) const = 0;
+    virtual void getAllQueryInfo(StringBuffer &reply, bool full, const IRoxieQuerySetManagerSet *agents, const IRoxieContextLogger &logctx) const = 0;
 };
 
 interface IRoxieDebugSessionManager : extends IInterface
@@ -143,7 +143,7 @@ interface IRoxieQueryPackageManagerSet : extends IInterface
     virtual void requestReload(bool wait, bool force) = 0;
     virtual void load() = 0;
     virtual void doControlMessage(IPropertyTree *xml, StringBuffer &reply, const IRoxieContextLogger &ctx) = 0;
-    virtual IQueryFactory *getQuery(const char *id, StringBuffer *querySet, IArrayOf<IQueryFactory> *slaves, const IRoxieContextLogger &logctx) const = 0;
+    virtual IQueryFactory *getQuery(const char *id, StringBuffer *querySet, IArrayOf<IQueryFactory> *agents, const IRoxieContextLogger &logctx) const = 0;
     virtual IQueryFactory *lookupLibrary(const char *libraryName, unsigned expectedInterfaceHash, const IRoxieContextLogger &logctx) const = 0;
     virtual int getActivePackageCount() const = 0;
 };
@@ -151,7 +151,7 @@ interface IRoxieQueryPackageManagerSet : extends IInterface
 extern IRoxieDebugSessionManager &queryRoxieDebugSessionManager();
 
 extern IRoxieQuerySetManager *createServerManager(const char *querySet);
-extern IRoxieQuerySetManager *createSlaveManager();
+extern IRoxieQuerySetManager *createAgentManager();
 extern IRoxieQueryPackageManagerSet *createRoxiePackageSetManager(const IQueryDll *standAloneDll);
 extern IRoxieQueryPackageManagerSet *globalPackageSetManager;
 

roxie/udplib/udpaeron.cpp

@@ -227,7 +227,7 @@ public:
                 if (!msgColl)
                 {
                     msgColl.set(collators[RUID_DISCARD]);
-                    // We could consider sending an abort to the slave, but it should have already been done by ccdserver code
+                    // We could consider sending an abort to the agent, but it should have already been done by ccdserver code
                     isDefault = true;
                     unwantedDiscarded++;
                 }

roxie/udplib/udpsha.hpp

@@ -28,7 +28,7 @@ typedef bool (*PKT_CMP_FUN) (const void *pkData, const void *key);
 
 
 // Flag bits in pktSeq field
-#define UDP_PACKET_COMPLETE           0x80000000  // Packet completes a single slave request
+#define UDP_PACKET_COMPLETE           0x80000000  // Packet completes a single agent request
 #define UDP_PACKET_RESERVED           0x40000000  // Not used - could move UDP_SEQUENCE_COMPLETE here?
 #define UDP_PACKET_SEQUENCE_MASK      0x3fffffff
 
@@ -40,7 +40,7 @@ struct UdpPacketHeader
     unsigned       msgSeq;      // sequence number of messages ever sent from given node, used with ruid to tell which packets are from same message
     unsigned       pktSeq;      // sequence number of this packet within the message (top bit signifies final packet)
     // information below is duplicated in the Roxie packet header - we could remove? However, would make aborts harder, and at least ruid is needed at receive end
-    ruid_t         ruid;        // The uid allocated by the server to this slave transaction
+    ruid_t         ruid;        // The uid allocated by the server to this agent transaction
     unsigned       msgId;       // sub-id allocated by the server to this request within the transaction
 };
 

roxie/udplib/udptopo.cpp

@@ -70,13 +70,13 @@ ChannelInfo::ChannelInfo(unsigned _mySubChannel, unsigned _numSubChannels, unsig
         currentDelay.emplace_back(initIbytiDelay);
 }
 
-bool ChannelInfo::otherSlaveHasPriority(unsigned priorityHash, unsigned otherSlaveSubChannel) const
+bool ChannelInfo::otherAgentHasPriority(unsigned priorityHash, unsigned otherAgentSubChannel) const
 {
     unsigned primarySubChannel = (priorityHash % numSubChannels);
     // could be coded smarter! Basically mysub - prim < theirsub - prim using modulo arithmetic, I think
     while (primarySubChannel != mySubChannel)
     {
-        if (primarySubChannel == otherSlaveSubChannel)
+        if (primarySubChannel == otherAgentSubChannel)
             return true;
         primarySubChannel++;
         if (primarySubChannel >= numSubChannels)
@@ -92,13 +92,13 @@ public:
     CTopologyServer();
     CTopologyServer(const char *topologyInfo);
 
-    virtual const SocketEndpointArray &querySlaves(unsigned channel) const override;
+    virtual const SocketEndpointArray &queryAgents(unsigned channel) const override;
     virtual const SocketEndpointArray &queryServers(unsigned port) const override;
     virtual const ChannelInfo &queryChannelInfo(unsigned channel) const override;
     virtual const std::vector<unsigned> &queryChannels() const override;
 
 private:
-    std::map<unsigned, SocketEndpointArray> slaves;  // indexed by channel
+    std::map<unsigned, SocketEndpointArray> agents;  // indexed by channel
     std::map<unsigned, SocketEndpointArray> servers; // indexed by port
     static const SocketEndpointArray nullArray;
     std::map<unsigned, ChannelInfo> channelInfo;
@@ -107,7 +107,7 @@ private:
     std::vector<unsigned> replicationLevels;
 };
 
-SocketEndpoint mySlaveEP;
+SocketEndpoint myAgentEP;
 
 CTopologyServer::CTopologyServer()
 {
@@ -147,16 +147,16 @@ CTopologyServer::CTopologyServer(const char *topologyInfo)
                 DBGLOG("Unable to process endpoint information in topology entry %s", line.c_str());
                 continue;
             }
-            if (streq(role, "slave"))
+            if (streq(role, "agent"))
             {
-                slaves[channel].append(ep);
-                if (ep.equals(mySlaveEP))
+                agents[channel].append(ep);
+                if (ep.equals(myAgentEP))
                 {
-                    mySubChannels[channel] = slaves[channel].ordinality()-1;
+                    mySubChannels[channel] = agents[channel].ordinality()-1;
                     channels.push_back(channel);
                     replicationLevels.push_back(repl);
                 }
-                slaves[0].append(ep);
+                agents[0].append(ep);
             }
             else if (streq(role, "server"))
                 servers[ep.port].append(ep);
@@ -167,14 +167,14 @@ CTopologyServer::CTopologyServer(const char *topologyInfo)
         unsigned channel = channels[i];
         unsigned repl = replicationLevels[i];
         unsigned subChannel = mySubChannels[channel];
-        channelInfo.emplace(std::make_pair(channel, ChannelInfo(subChannel, slaves[channel].ordinality(), repl)));
+        channelInfo.emplace(std::make_pair(channel, ChannelInfo(subChannel, agents[channel].ordinality(), repl)));
     }
 }
 
-const SocketEndpointArray &CTopologyServer::querySlaves(unsigned channel) const
+const SocketEndpointArray &CTopologyServer::queryAgents(unsigned channel) const
 {
-    auto match = slaves.find(channel);
-    if (match == slaves.end())
+    auto match = agents.find(channel);
+    if (match == agents.end())
         return nullArray;
     return match->second;
 }
@@ -321,7 +321,7 @@ void TopologyManager::setRoles(const std::vector<RoxieEndpointInfo> &myRoles)
         switch (role.role)
         {
         case RoxieEndpointInfo::RoxieServer: topoBuf.append("server|"); break;
-        case RoxieEndpointInfo::RoxieSlave: topoBuf.append("slave|"); break;
+        case RoxieEndpointInfo::RoxieAgent: topoBuf.append("agent|"); break;
         default: throwUnexpected();
         }
         topoBuf.append(role.channel).append('|');
@@ -339,10 +339,10 @@ extern UDPLIB_API const ITopologyServer *getTopology()
     return &topologyManager.getCurrent();
 }
 
-extern UDPLIB_API unsigned getNumSlaves(unsigned channel)
+extern UDPLIB_API unsigned getNumAgents(unsigned channel)
 {
     Owned<const ITopologyServer> topology = getTopology();
-    return topology->querySlaves(channel).ordinality();
+    return topology->queryAgents(channel).ordinality();
 }
 
 #ifndef _CONTAINERIZED
@@ -372,11 +372,11 @@ extern UDPLIB_API void initializeTopology(const StringArray &topoValues, const s
                 {
                     DBGLOG("Topology information updated:");
                     Owned<const ITopologyServer> c = getTopology();
-                    const SocketEndpointArray &eps = c->querySlaves(0);
+                    const SocketEndpointArray &eps = c->queryAgents(0);
                     ForEachItemIn(idx, eps)
                     {
                         StringBuffer s;
-                        DBGLOG("Slave %d: %s", idx, eps.item(idx).getIpText(s).str());
+                        DBGLOG("Agent %d: %s", idx, eps.item(idx).getIpText(s).str());
                     }
                 }
                 waitTime = topoUpdateInterval;

roxie/udplib/udptopo.hpp

@@ -24,51 +24,51 @@
 /*
  * IBYTI handling
  *
- * IBYTI (I beat you to it) messages are sent by the slave that is going to process a particular request,
- * to tell the other slaves on the same channel not to bother.
+ * IBYTI (I beat you to it) messages are sent by the agent that is going to process a particular request,
+ * to tell the other agents on the same channel not to bother.
  *
  * In order to reduce wasted work, for each request a "primary" subchannel is selected (based on a hash of the
  * packet's RUID) - this channel will process the request immediately, but others will delay a little while
  * in order to give the expected IBYTI time to arrive.
  *
  * The decision on how long to delay is a little complex - too long, and you end up losing the ability for a
- * backup slave to step in when primary is under load (or dead); too short and you end up duplicating work.
- * It's also important for the delay to be adaptive so that if a slave goes offline, the other slaves on the
+ * backup agent to step in when primary is under load (or dead); too short and you end up duplicating work.
+ * It's also important for the delay to be adaptive so that if a agent goes offline, the other agents on the
  * subchannel don't keep waiting for it to take its turn.
  *
  * The adaptiveness is handled by noting any time that we delay waiting for an IBYTI that does not arrive - this
- * may mean that the slave(s) we expected to get there first are offline, and thus next time we don't wait quite
- * so long for them. Conversely, any time an IBYTI does arrive from another slave on your channel, you know that
+ * may mean that the agent(s) we expected to get there first are offline, and thus next time we don't wait quite
+ * so long for them. Conversely, any time an IBYTI does arrive from another agent on your channel, you know that
  * it is online and so can reset the delay to its original value.
  *
- * A previous version of this code assumed a single missed IBYTI was enough to assume that a slave was dead and drop the
- * delay for that slave to zero - this turned out to behave pretty poorly when under load, with much duplicated work.
+ * A previous version of this code assumed a single missed IBYTI was enough to assume that a agent was dead and drop the
+ * delay for that agent to zero - this turned out to behave pretty poorly when under load, with much duplicated work.
  * Thus we take care to adjust the delay more gradually, while still ending up with a zero delay if the buddy does not respond
  * several times in a row.
  */
 
 /*
  * A "subchannel" is a value from 1 to 7 (with current settings) that indicates which "copy" of the data for this channel
- * is being processed by this slave. A value of 0 would indicate that this slave does not have any data for this channel.
+ * is being processed by this agent. A value of 0 would indicate that this agent does not have any data for this channel.
  * In a typical 100-way roxie with cyclic redundancy, node 1 would be processing channel 1, subchannel 1, and channel 2,
  * subchannel 2, node 2 would be processing channel 2, subchannel 1 and channel 3, subchannel 2, and so on u to node 100,
  * which would process channel 100, subchannel 1 and channel 1, subchannel 2.
  *
  * To determine which subchannel is the "primary" for a given query packet, a hash value of fields from the packet header
- * is used, modulo the number of subchannels on this channel. The slave on this subchannel will respond immediately.
- * Slaves on other subchannels delay according to the subchannel number - so on a 4-way redundant system, if the primary
- * subchannel is decided to be 2, the slave on subchannel 3 will delay by 1 ibytiDelay value, the slave on subchannel 4 by
- * 2 values, and the slave on subchannel 1 by 3 values (this assumes all slaves are responding normally).
+ * is used, modulo the number of subchannels on this channel. The agent on this subchannel will respond immediately.
+ * Agents on other subchannels delay according to the subchannel number - so on a 4-way redundant system, if the primary
+ * subchannel is decided to be 2, the agent on subchannel 3 will delay by 1 ibytiDelay value, the agent on subchannel 4 by
+ * 2 values, and the agent on subchannel 1 by 3 values (this assumes all agents are responding normally).
  *
  * In fact, the calculation is a little more complex, in that the "units" are adjusted per subchannel to take into account
  * the responsiveness or otherwise of a subchannel. Initially, the delay value for each subchannel is the same, but any time
- * a slave waits for an IBYTI that does not arrive on time, the delay value for any slave that is "more primary" than me for
+ * a agent waits for an IBYTI that does not arrive on time, the delay value for any agent that is "more primary" than me for
  * this packet is reduced. Any time an IBYTI _does_ arrive on time, the delay is reset to its initial value.
  */
 
 extern UDPLIB_API unsigned minIbytiDelay;
 extern UDPLIB_API unsigned initIbytiDelay;
-extern UDPLIB_API SocketEndpoint mySlaveEP;
+extern UDPLIB_API SocketEndpoint myAgentEP;
 
 class UDPLIB_API ChannelInfo
 {
@@ -87,29 +87,29 @@ public:
      * As I will also have sent out an IBYTI, I should only abort if the sender of the IBYTI has higher priority
      * for this packet than I do.
      */
-    bool otherSlaveHasPriority(unsigned priorityHash, unsigned otherSlaveSubChannel) const;
+    bool otherAgentHasPriority(unsigned priorityHash, unsigned otherAgentSubChannel) const;
 
 private:
     unsigned mySubChannel = 0;     // Which subChannel does this node implement for this channel - zero-based
     unsigned myReplicationLevel = 0; // Which data location is this channel pulling its data from - zero-based
-    unsigned numSubChannels = 0;   // How many subchannels are there for this channel, across all slaves. Equivalently, the number of slaves that implement this channel
+    unsigned numSubChannels = 0;   // How many subchannels are there for this channel, across all agents. Equivalently, the number of agents that implement this channel
     mutable std::vector<unsigned> currentDelay;  // NOTE - technically should be atomic, but in the event of a race we don't really care who wins
 };
 
 interface ITopologyServer : public IInterface
 {
-    virtual const SocketEndpointArray &querySlaves(unsigned channel) const = 0;
+    virtual const SocketEndpointArray &queryAgents(unsigned channel) const = 0;
     virtual const SocketEndpointArray &queryServers(unsigned port) const = 0;
     virtual const ChannelInfo &queryChannelInfo(unsigned channel) const = 0;
     virtual const std::vector<unsigned> &queryChannels() const = 0;
 };
 
-extern UDPLIB_API unsigned getNumSlaves(unsigned channel);
+extern UDPLIB_API unsigned getNumAgents(unsigned channel);
 extern UDPLIB_API const ITopologyServer *getTopology();
 
 struct RoxieEndpointInfo
 {
-    enum Role { RoxieServer, RoxieSlave } role;
+    enum Role { RoxieServer, RoxieAgent } role;
     unsigned channel;
     SocketEndpoint ep;
     unsigned replicationLevel;

roxie/udplib/udptrr.cpp

@@ -77,7 +77,7 @@ class CReceiveManager : implements IReceiveManager, public CInterface
     /*
      * Handling lost packets
      *
-     * We try to make lost packets unlikely by telling slaves when to send (and making sure they don't send unless
+     * We try to make lost packets unlikely by telling agents when to send (and making sure they don't send unless
      * there's a good chance that socket buffer will have room). But we can't legislate for network issues.
      *
      * What packets can be lost?
@@ -368,7 +368,7 @@ class CReceiveManager : implements IReceiveManager, public CInterface
 
         unsigned timedOut(UdpSenderEntry *requester)
         {
-            // MORE - this will retry indefinitely if slave in question is dead
+            // MORE - this will retry indefinitely if agent in question is dead
             currentRequester = nullptr;
             if (requester->retryOnTimeout())
                 enqueueRequest(requester);
@@ -534,7 +534,7 @@ class CReceiveManager : implements IReceiveManager, public CInterface
                     if (e->errorCode() == JSOCKERR_timeout_expired)
                     {
                         // A timeout implies that there is an active permission to send, but nothing has happened.
-                        // Could be a really busy (or crashed) slave, could be a lost packet
+                        // Could be a really busy (or crashed) agent, could be a lost packet
                         if (currentRequester)
                             timeoutExpires = msTick() + timedOut(currentRequester);
                     }
@@ -847,27 +847,27 @@ IReceiveManager *createReceiveManager(int server_flow_port, int data_port, int c
 /*
 Thoughts on flow control / streaming:
 1. The "continuation packet" mechanism does have some advantages
-    - easy recovery from slave failures
-    - slave recovers easily from Roxie server failures
+    - easy recovery from agent failures
+    - agent recovers easily from Roxie server failures
     - flow control is simple (but is it effective?)
 
 2. Abandoning continuation packet in favour of streaming would give us the following issues:
     - would need some flow control to stop getting ahead of a Roxie server that consumed slowly
-        - flow control is non trivial if you want to avoid tying up a slave thread and want slave to be able to recover from Roxie server failure
+        - flow control is non trivial if you want to avoid tying up a agent thread and want agent to be able to recover from Roxie server failure
     - Need to work out how to do GSS - the nextGE info needs to be passed back in the flow control?
-    - can't easily recover from slave failures if you already started processing
-        - unless you assume that the results from slave are always deterministic and can retry and skip N
-    - potentially ties up a slave thread for a while 
+    - can't easily recover from agent failures if you already started processing
+        - unless you assume that the results from agent are always deterministic and can retry and skip N
+    - potentially ties up a agent thread for a while 
         - do we need to have a larger thread pool but limit how many actually active?
 
 3. Order of work
     - Just adding streaming while ignoring flow control and continuation stuff (i.e. we still stop for permission to continue periodically)
         - Shouldn't make anything any _worse_ ...
-            - except that won't be able to recover from a slave dying mid-stream (at least not without some considerable effort)
+            - except that won't be able to recover from a agent dying mid-stream (at least not without some considerable effort)
                 - what will happen then?
             - May also break server-side caching (that no-one has used AFAIK). Maybe restrict to nohits as we change....
     - Add some flow control
-        - would prevent slave getting too far ahead in cases that are inadequately flow-controlled today
+        - would prevent agent getting too far ahead in cases that are inadequately flow-controlled today
         - shouldn't make anything any worse...
     - Think about removing continuation mechanism from some cases
 
@@ -889,7 +889,7 @@ More questions:
 
 Problems found while testing implemetnation:
     - the unpacker cursor read code is crap
-    - there is a potential to deadlock when need to make a callback slave->server during a streamed result (indexread5 illustrates)
+    - there is a potential to deadlock when need to make a callback agent->server during a streamed result (indexread5 illustrates)
         - resolution callback code doesn't really need to be query specific - could go to the default handler
         - but other callbacks - ALIVE, EXCEPTION, and debugger are not so clear
     - It's not at all clear where to move the code for processing metadata
@@ -924,7 +924,7 @@ Problems found while testing implemetnation:
 
     If continuation info was restricted to a "yes/no" (i.e. had to be continued on same node as started on) could have simple "Is there any continuation" bit. Others are sent in their 
     own packets so are a little different. Does that make it harder to recover? Not sure that it does really (just means that the window at which a failure causes a problem starts earlier).
-    However it may be an issue tying up slave thread for a while (and do we know when to untie it if the Roxie server abandons/restarts?)
+    However it may be an issue tying up agent thread for a while (and do we know when to untie it if the Roxie server abandons/restarts?)
 
     Perhaps it makes sense to pause at this point (with streaming disabled and with retry mechanism optional)
 

roxie/udplib/udptrs.cpp

@@ -45,7 +45,7 @@ using roxiemem::DataBuffer;
 
 /*
  *
- * There are 3 threads running to manage the data transfer from slave back to server:
+ * There are 3 threads running to manage the data transfer from agent back to server:
  * send_resend_flow
  *   - checks periodically that nothing is waiting for a "request to send" that timed out
  * send_receive_flow
@@ -59,12 +59,12 @@ using roxiemem::DataBuffer;
  *   - broadcasts "no longer "
  *   - sends "completed" or "completed but I want to send more" flow message to server
  *
- * Queueing up data packets is done by the slave worker threads.
+ * Queueing up data packets is done by the agent worker threads.
  * *
 
  *
  * Data races to watch for
- * 1. Two slave threads add data at same time - only one should sent rts (use atomic_inc for the count)
+ * 1. Two agent threads add data at same time - only one should sent rts (use atomic_inc for the count)
  * 2. We check for timeout and resend rts or fail just as permission comes in
  *    - resend rts is harmless ?
  *    - fail is acceptable

testing/regress/ecl-test

@@ -228,6 +228,8 @@ class RegressMain:
                                 nargs=1,  default = ['none'],   metavar="filespec[,filespec,...]")
         executionParser.add_argument('--generateStackTrace', help="Generate stack trace of Thor components before kill a timeouted test case. Trace files are stored into Regression Engine Log directory (see 'LogDir' in ecl-test.json file)",
                                 action = 'store_true')
+        executionParser.add_argument('--createEclRunArg', help="Generate ECL tool command line.",
+                                action='store_true')
 
 
         parser = argparse.ArgumentParser(prog=prog, description=description,  parents=[helperParser, commonParser,  executionParser])
@@ -244,8 +246,6 @@ class RegressMain:
                                  action='store_true')
         parser_list.add_argument('--target', '-t', help="Provide target cluster(s) to list test cases. If target = 'all' then list test cases on all clusters. If not defined then default value(s) come from config (ecl-test.json by default).",
                                 nargs='?', type=str,  default='', metavar="target_cluster_list | all")
-        parser_list.add_argument('--createEclRunArg', help="Generate ECL tool command line.",
-                                action='store_true')
 
 
         parser_setup = subparsers.add_parser('setup', help='Setup help',  parents=[helperParser, commonParser, executionParser])

testing/regress/hpcc/regression/regress.py

@@ -31,7 +31,7 @@ from ..regression.suite import Suite
 from ..util.ecl.cc import ECLCC
 from ..util.ecl.command import ECLcmd
 from ..util.expandcheck import ExpandCheck
-from ..util.util import getConfig, queryWuid,  abortWorkunit, getVersionNumbers, createZAP
+from ..util.util import getConfig, queryWuid,  abortWorkunit, getVersionNumbers, createZAP, getEclRunArgs
 
 
 class Regression:
@@ -503,6 +503,8 @@ class Regression:
 
         logging.debug("runQuery(engine: '%s', cluster: '%s', query: '%s', cnt: %d, publish: %s, thread id: %d" % ( engine, cluster, query.ecl, cnt, publish,  th))
         logging.warn("%3d. Test: %s" % (cnt, query.getBaseEclRealName()),  extra={'taskId':cnt})
+        if 'createEclRunArg' in self.args and self.args.createEclRunArg:
+            logging.warn("%3d. Cmd: %s %s/%s" % (cnt, getEclRunArgs(query, engine, cluster), query.dir_ec, query.getBaseEcl())),
 
         self.loggermutex.release()
         res = 0

thorlcr/msort/tsorts.cpp

@@ -1152,7 +1152,8 @@ public:
         else
         {
             unsigned _snum = (rowidx_t)snum; // only support 2^32 rows in memory
-            assertex(snum==_snum);
+            if (snum != _snum)
+                throw MakeActivityException(activity, 0, "Local sort limit exceeeded (max = 2^32 rows), trying to sort %" RCPF "u rows", snum);
             return rowArray.createRowStream((rowidx_t)sstart, _snum, false); // must be false as rows may overlap (between join)
         }
     }

tools/wutool/wutool.cpp

@@ -258,7 +258,7 @@ static void process(IConstWorkUnit &w, IProperties *globals, const StringArray &
         ScopeDumper dumper;
         WuScopeFilter filter;
         filter.addFilter(args.item(0));
-        if (filter.properties == PTnone)
+        if (!filter.outputDefined())
             filter.addOutputProperties(PTall);
         filter.finishedFilter();