ROOT » PROOF » PROOF » TProof

class TProof: public TNamed, public TQObject


TProof

This class controls a Parallel ROOT Facility, PROOF, cluster.
It fires the worker servers, it keeps track of how many workers are
running, it keeps track of the workers running status, it broadcasts
messages to all workers, it collects results, etc.


Function Members (Methods)

public:
virtual~TProof()
voidTObject::AbstractMethod(const char* method) const
Int_tActivateWorker(const char* ord, Bool_t save = kTRUE)
voidAddChain(TChain* chain)
Int_tAddDynamicPath(const char* libpath, Bool_t onClient = kFALSE, TList* wrks = 0, Bool_t doCollect = kTRUE)
static voidAddEnvVar(const char* name, const char* value)
voidAddFeedback(const char* name)
Int_tAddIncludePath(const char* incpath, Bool_t onClient = kFALSE, TList* wrks = 0, Bool_t doCollect = kTRUE)
voidAddInput(TObject* obj)
voidAddInputData(TObject* obj, Bool_t push = kFALSE)
virtual voidTObject::AppendPad(Option_t* option = "")
Int_tArchive(Int_t query, const char* url)
Int_tArchive(const char* queryref, const char* url = 0)
static Bool_tTQObject::AreAllSignalsBlocked()
Bool_tTQObject::AreSignalsBlocked() const
static Bool_tTQObject::BlockAllSignals(Bool_t b)
Bool_tTQObject::BlockSignals(Bool_t b)
virtual voidBrowse(TBrowser* b)
virtual Bool_tCancelStagingDataSet(const char* dataset)
voidcd(Int_t id = -1)
virtual voidTQObject::ChangedBy(const char* method)SIGNAL
static TClass*Class()
virtual const char*TObject::ClassName() const
Int_tCleanupSession(const char* sessiontag)
virtual voidTNamed::Clear(Option_t* option = "")
virtual voidClearCache(const char* file = 0)
voidClearData(UInt_t what = kUnregistered, const char* dsname = 0)
virtual voidClearDataSetCache(const char* dataset = 0)
voidClearFeedback()
voidClearInput()
voidClearInputData(TObject* obj = 0)
voidClearInputData(const char* name)
Int_tClearPackage(const char* package)
Int_tClearPackages()
virtual TObject*TNamed::Clone(const char* newname = "") const
voidClose(Option_t* option = "")
voidCloseProgressDialog()SIGNAL
voidTQObject::CollectClassSignalLists(TList& list, TClass* cls)
virtual Int_tTNamed::Compare(const TObject* obj) const
Bool_tTQObject::Connect(const char* signal, const char* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::Connect(TQObject* sender, const char* signal, const char* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::Connect(const char* sender_class, const char* signal, const char* receiver_class, void* receiver, const char* slot)
virtual voidTQObject::Connected(const char*)
virtual voidTNamed::Copy(TObject& named) const
TDrawFeedback*CreateDrawFeedback()
voidDataSetStatus(const char* msg, Bool_t status, Int_t done, Int_t total)SIGNAL
Int_tDeactivateWorker(const char* ord, Bool_t save = kTRUE)
static voidDelEnvVar(const char* name)
virtual voidTObject::Delete(Option_t* option = "")MENU
voidDeleteDrawFeedback(TDrawFeedback* f)
voidDeleteParameters(const char* wildcard)
virtual voidTQObject::Destroyed()SIGNAL
voidDetach(Option_t* opt = "")
voidDisableGoAsyn()
Bool_tTQObject::Disconnect(const char* signal = 0, void* receiver = 0, const char* slot = 0)
static Bool_tTQObject::Disconnect(TQObject* sender, const char* signal = 0, void* receiver = 0, const char* slot = 0)
static Bool_tTQObject::Disconnect(const char* class_name, const char* signal, void* receiver = 0, const char* slot = 0)
virtual voidTQObject::Disconnected(const char*)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
Int_tDownloadPackage(const char* par, const char* dstdir = 0)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual Long64_tDrawSelect(TDSet* dset, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
Long64_tDrawSelect(const char* dsetname, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0, TObject* enl = 0)
virtual voidTObject::Dump() constMENU
virtual Int_tEcho(const TObject* obj)
virtual Int_tEcho(const char* str)
voidTQObject::Emit(const char* signal)
voidTQObject::Emit(const char* signal, Long_t* paramArr)
voidTQObject::Emit(const char* signal, const char* params)
voidTQObject::Emit(const char* signal, Double_t param)
voidTQObject::Emit(const char* signal, Long_t param)
voidTQObject::Emit(const char* signal, Long64_t param)
voidTQObject::Emit(const char* signal, Bool_t param)
voidTQObject::Emit(const char* signal, Char_t param)
voidTQObject::Emit(const char* signal, UChar_t param)
voidTQObject::Emit(const char* signal, Short_t param)
voidTQObject::Emit(const char* signal, UShort_t param)
voidTQObject::Emit(const char* signal, Int_t param)
voidTQObject::Emit(const char* signal, UInt_t param)
voidTQObject::Emit(const char* signal, ULong_t param)
voidTQObject::Emit(const char* signal, ULong64_t param)
voidTQObject::Emit(const char* signal, Float_t param)
voidTQObject::EmitVA(const char* signal, Int_t nargs, va_list va)
voidTQObject::EmitVA<>(const char* signal_name, Int_t)
Int_tEnablePackage(const char* package, Bool_t notOnClient = kFALSE, TList* workers = 0)
Int_tEnablePackage(const char* package, const char* loadopts, Bool_t notOnClient = kFALSE, TList* workers = 0)
Int_tEnablePackage(const char* package, TList* loadopts, Bool_t notOnClient = kFALSE, TList* workers = 0)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
Int_tExec(const char* cmd, Bool_t plusMaster = kFALSE)
Int_tExec(const char* cmd, const char* ord, Bool_t logtomacro = kFALSE)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual Bool_tExistsDataSet(const char* dataset)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
voidFeedback(TList* objs)SIGNAL
virtual voidTNamed::FillBuffer(char*& buffer)
Long64_tFinalize(Int_t query = -1, Bool_t force = kFALSE)
Long64_tFinalize(const char* queryref, Bool_t force = kFALSE)
TList*FindDataSets(const char* searchString, const char* optStr = "")
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Long64_tGetBytesRead() const
Int_tGetClientProtocol() const
const char*GetConfDir() const
const char*GetConfFile() const
Float_tGetCpuTime() const
const char*GetDataPoolUrl() const
virtual TFileCollection*GetDataSet(const char* dataset, const char* optStr = "")
TMap*GetDataSetQuota(const char* optStr = "")
virtual TMap*GetDataSets(const char* uri = "", const char* optStr = "")
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
TStringGetenv(const char* env, const char* ord = "0")
static const TList*GetEnvVars()
TList*GetFeedbackList() const
const char*GetGroup() const
virtual const char*TObject::GetIconName() const
const char*GetImage() const
TList*GetInputList()
TMacro*GetLastLog()
TList*TQObject::GetListOfClassSignals() const
TList*TQObject::GetListOfConnections() const
TList*GetListOfEnabledPackages()
TList*GetListOfPackages()
virtual TList*GetListOfQueries(Option_t* opt = "")
TList*TQObject::GetListOfSignals() const
TList*GetListOfSlaveInfos()
TList*GetLoadedMacros() const
voidGetLog(Int_t start = -1, Int_t end = -1)
Int_tGetLogLevel() const
TMacro*GetMacroLog()
TProofMgr*GetManager()
const char*GetMaster() const
voidGetMaxQueries()
TFileCollection*GetMissingFiles(TQueryResult* qr = 0)
virtual const char*TNamed::GetName() const
Int_tGetNumberOfDrawQueries()
Int_tGetNumberOfQueries()
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TObject*GetOutput(const char* name)
static TObject*GetOutput(const char* name, TList* out)
TList*GetOutputList()
TList*GetOutputNames()
Int_tGetParallel() const
TObject*GetParameter(const char* par) const
static Int_tGetParameter(TCollection* c, const char* par, TString& value)
static Int_tGetParameter(TCollection* c, const char* par, Int_t& value)
static Int_tGetParameter(TCollection* c, const char* par, Long_t& value)
static Int_tGetParameter(TCollection* c, const char* par, Long64_t& value)
static Int_tGetParameter(TCollection* c, const char* par, Double_t& value)
Int_tGetPort() const
TProof::EQueryModeGetQueryMode(Option_t* mode = 0) const
TQueryResult*GetQueryResult(const char* ref = 0)
TList*GetQueryResults()
Int_tGetRC(const char* RCenv, Int_t& env, const char* ord = "0")
Int_tGetRC(const char* RCenv, Double_t& env, const char* ord = "0")
Int_tGetRC(const char* RCenv, TString& env, const char* ord = "0")
Float_tGetRealTime() const
Int_tGetRemoteProtocol() const
TProof::ERunStatusGetRunStatus() const
Int_tGetSeqNum() const
Int_tGetSessionID() const
const char*GetSessionTag() const
virtual TFileCollection*GetStagingStatusDataSet(const char* dataset)
voidGetStatistics(Bool_t verbose = kFALSE)
Int_tGetStatus() const
virtual const char*TNamed::GetTitle() const
virtual TTree*GetTreeHeader(TDSet* tdset)
virtual UInt_tTObject::GetUniqueID() const
const char*GetUrl()
const char*GetUser() const
const char*GetWorkDir() const
voidGoAsynchronous()
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Bool_tTQObject::HasConnection(const char* signal_name) const
virtual ULong_tTNamed::Hash() const
virtual voidTQObject::HighPriority(const char* signal_name, const char* slot_name = 0)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tIsDataReady(Long64_t& totalbytes, Long64_t& bytesready)
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tIsFolder() const
Bool_tIsIdle() const
Bool_tIsLite() const
Bool_tIsMaster() const
Bool_tTObject::IsOnHeap() const
Bool_tIsParallel() const
Bool_tIsProofd() const
virtual Bool_tTNamed::IsSortable() const
Bool_tIsTty() const
Bool_tIsValid() const
Bool_tIsWaiting() const
Bool_tTObject::IsZombie() const
virtual Int_tLoad(const char* macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE, TList* wrks = 0)
voidLogMessage(const char* msg, Bool_t all)SIGNAL
static voidLogViewer(const char* url = 0, Int_t sessionidx = 0)
virtual voidTQObject::LowPriority(const char* signal_name, const char* slot_name = 0)
virtual voidTNamed::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual voidTQObject::Message(const char* msg)SIGNAL
static TProofMgr*Mgr(const char* url)
virtual Bool_tTObject::Notify()
virtual Int_tTQObject::NumberOfConnections() const
virtual Int_tTQObject::NumberOfSignals() const
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static TProof*Open(const char* url = 0, const char* conffile = 0, const char* confdir = 0, Int_t loglevel = 0)
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTObject::Paint(Option_t* option = "")
Int_tPing()
virtual voidTObject::Pop()
virtual voidPrint(Option_t* option = "") const
virtual Long64_tProcess(const char* selector, Long64_t nentries, Option_t* option = "")
virtual Long64_tProcess(TSelector* selector, Long64_t nentries, Option_t* option = "")
virtual Long64_tProcess(TDSet* dset, const char* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
virtual Long64_tProcess(TFileCollection* fc, const char* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
virtual Long64_tProcess(TDSet* dset, TSelector* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
virtual Long64_tProcess(TFileCollection* fc, TSelector* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
virtual Long64_tProcess(const char* dsetname, const char* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0, TObject* enl = 0)
virtual Long64_tProcess(const char* dsetname, TSelector* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0, TObject* enl = 0)
voidProgress(Long64_t total, Long64_t processed)SIGNAL
voidProgress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti)SIGNAL
voidProgress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti, Int_t actw, Int_t tses, Float_t eses)SIGNAL
voidPutLog(TQueryResult* qr)
voidQueryResultReady(const char* ref)SIGNAL
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual Bool_tRegisterDataSet(const char* name, TFileCollection* dataset, const char* optStr = "")
Int_tRemove(Int_t query, Bool_t all = kFALSE)
Int_tRemove(const char* queryref, Bool_t all = kFALSE)
voidRemoveChain(TChain* chain)
virtual Int_tRemoveDataSet(const char* dataset, const char* optStr = "")
Int_tRemoveDynamicPath(const char* libpath, Bool_t onClient = kFALSE)
voidRemoveFeedback(const char* name)
Int_tRemoveIncludePath(const char* incpath, Bool_t onClient = kFALSE)
virtual Bool_tRequestStagingDataSet(const char* dataset)
static voidReset(const char* url, Bool_t hard = kFALSE)
voidTObject::ResetBit(UInt_t f)
static voidResetEnvVars()
voidResetProgressDialog(const char* sel, Int_t sz, Long64_t fst, Long64_t ent)SIGNAL
voidResetProgressDialogStatus()
Int_tRetrieve(Int_t query, const char* path = 0)
Int_tRetrieve(const char* queryref, const char* path = 0)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
Int_tSavePerfTree(const char* pf = 0, const char* qref = 0)
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidSendDataSetStatus(const char* msg, UInt_t n, UInt_t tot, Bool_t st)
Bool_tSendingLogToWindow() const
voidSendLogToWindow(Bool_t mode)
voidSetActive(Bool_t = kTRUE)
virtual voidSetAlias(const char* alias = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetDataPoolUrl(const char* url)
virtual Int_tSetDataSetTreeName(const char* dataset, const char* treename)
voidSetDrawFeedbackOption(TDrawFeedback* f, Option_t* opt)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetInputDataFile(const char* datafile)
voidSetLogLevel(Int_t level, UInt_t mask = TProofDebug::kAll)
voidSetManager(TProofMgr* mgr)
voidSetMaxDrawQueries(Int_t max)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
Int_tSetParallel(Int_t nodes = -1, Bool_t random = kFALSE)
voidSetParameter(const char* par, const char* value)
voidSetParameter(const char* par, Int_t value)
voidSetParameter(const char* par, Long_t value)
voidSetParameter(const char* par, Long64_t value)
voidSetParameter(const char* par, Double_t value)
voidSetPerfTree(const char* pf = "perftree.root", Bool_t withWrks = kFALSE)
voidSetPrintProgress(PrintProgress_t pp)
voidSetProgressDialog(Bool_t on = kTRUE)
voidSetQueryMode(TProof::EQueryMode mode)
voidSetRealTimeLog(Bool_t on = kTRUE)
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowCache(Bool_t all = kFALSE)
virtual voidShowData()
voidShowDataSet(const char* dataset = "", const char* opt = "filter:SsCc")
virtual voidShowDataSetCache(const char* dataset = 0)
voidShowDataSetQuota(Option_t* opt = 0)
virtual voidShowDataSets(const char* uri = "", const char* optStr = "")
voidShowEnabledPackages(Bool_t all = kFALSE)
voidShowFeedback() const
voidShowLog(Int_t qry = -1)
voidShowLog(const char* queryref)
virtual voidShowMembers(TMemberInspector& insp) const
voidShowMissingFiles(TQueryResult* qr = 0)
voidShowPackages(Bool_t all = kFALSE, Bool_t redirlog = kFALSE)
voidShowParameters(const char* wildcard = "PROOF_*") const
voidShowQueries(Option_t* opt = "")
virtual voidShowStagingStatusDataSet(const char* dataset, const char* optStr = "filter:SsCc")
virtual Int_tTNamed::Sizeof() const
voidStartupMessage(const char* msg, Bool_t status, Int_t done, Int_t total)SIGNAL
voidStopProcess(Bool_t abort, Int_t timeout = -1)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTouch()
TProof(const char* masterurl, const char* conffile = kPROOF_ConfFile, const char* confdir = kPROOF_ConfDir, Int_t loglevel = 0, const char* alias = 0, TProofMgr* mgr = 0)
Int_tUploadDataSet(const char*, TList*, const char* = 0, Int_t = 0, TList* = 0)
Int_tUploadDataSet(const char*, const char*, const char* = 0, Int_t = 0, TList* = 0)
Int_tUploadDataSetFromFile(const char*, const char*, const char* = 0, Int_t = 0, TList* = 0)
Int_tUploadPackage(const char* par, TProof::EUploadPackageOpt opt = kUntar, TList* workers = 0)
virtual voidTObject::UseCurrentStyle()
Bool_tUseDynamicStartup() const
virtual Int_tVerifyDataSet(const char* dataset, const char* optStr = "")
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
Int_tAddWorkers(TList* wrks)
static Int_tAssertDataSet(TDSet* dset, TList* input, TDataSetManager* mgr, TString& emsg)
Int_tAssertPath(const char* path, Bool_t writable)
static Int_tTQObject::CheckConnectArgs(TQObject* sender, TClass* sender_class, const char* signal, TClass* receiver_class, const char* slot)
Int_tCollect(TProof::ESlaves list = kActive, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
Int_tCollect(TList* slaves, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
static TStringTQObject::CompressName(const char* method_name)
static Bool_tTQObject::ConnectToClass(TQObject* sender, const char* signal, TClass* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::ConnectToClass(const char* sender_class, const char* signal, TClass* receiver_class, void* receiver, const char* slot)
TSlave*CreateSlave(const char* url, const char* ord, Int_t perf, const char* image, const char* workdir)
TSlave*CreateSubmaster(const char* url, const char* ord, const char* image, const char* msd, Int_t nwk = 1)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
TList*GetEnabledPackages() const
static Bool_tGetFileInCmd(const char* cmd, TString& fn)
static Int_tGetInputData(TList* input, const char* cachedir, TString& emsg)
TList*GetListOfActiveSlaves() const
TVirtualProofPlayer*GetPlayer() const
TPluginHandler*GetProgressDialog() const
Int_tGetSandbox(TString& sb, Bool_t assert = kFALSE, const char* rc = 0)
virtual void*TQObject::GetSender()
virtual const char*TQObject::GetSenderClassName() const
voidHandleLibIncPath(const char* what, Bool_t add, const char* dirs)
Int_tHandleOutputOptions(TString& opt, TString& target, Int_t action)
Int_tInit(const char* masterurl, const char* conffile, const char* confdir, Int_t loglevel, const char* alias = 0)
voidInitMembers()
virtual TVirtualProofPlayer*MakePlayer(const char* player = 0, TSocket* s = 0)
voidTObject::MakeZombie()
virtual Int_tPollForNewWorkers()
voidPrepareInputDataFile(TString& dataFile)
Int_tRemoveWorkers(TList* wrks)
static Int_tSaveInputData(TQueryResult* qr, const char* cachedir, TString& emsg)
virtual voidSaveWorkerInfo()
Int_tSendFile(const char* file, Int_t opt = (kBinary | kForward | kCp | kCpBin), const char* rfile = 0, TSlave* sl = 0)
static Int_tSendInputData(TQueryResult* qr, TProof* p, TString& emsg)
virtual voidSendInputDataFile()
voidSetDSet(TDSet* dset)
voidSetFeedback(TString& opt, TString& optfb, Int_t action)
voidSetPlayer(TVirtualProofPlayer* player)
voidSetupWorkersEnv(TList* wrks, Bool_t increasingpool = kFALSE)
static void*SlaveStartupThread(void* arg)
virtual Bool_tStartSlaves(Bool_t attach = kFALSE)
static voidSystemCmd(const char* cmd, Int_t fdout)
TProof()
voidUpdateDialog()
virtual voidValidateDSet(TDSet* dset)
Int_tVerifyDataSetParallel(const char* uri, const char* optStr)
private:
voidActivate(TList* slaves = 0)
voidActivateAsyncInput()
voidAskForOutput(TSlave* sl)
voidAskParallel()
voidAskStatistics()
Int_tBroadcast(const TMessage& mess, TList* slaves)
Int_tBroadcast(const TMessage& mess, TProof::ESlaves list = kActive)
Int_tBroadcast(Int_t kind, TList* slaves)
Int_tBroadcast(Int_t kind, TProof::ESlaves list = kActive)
Int_tBroadcast(const char* mess, Int_t kind, TList* slaves)
Int_tBroadcast(const char* mess, Int_t kind = kMESS_STRING, TProof::ESlaves list = kActive)
Int_tBroadcastFile(const char* file, Int_t opt, const char* rfile, TList* wrks)
Int_tBroadcastFile(const char* file, Int_t opt, const char* rfile = 0, TProof::ESlaves list = kAllUnique)
Int_tBroadcastGroupPriority(const char* grp, Int_t priority, TProof::ESlaves list = kAllUnique)
Int_tBroadcastGroupPriority(const char* grp, Int_t priority, TList* workers)
Int_tBroadcastObject(const TObject* obj, Int_t kind, TList* slaves)
Int_tBroadcastObject(const TObject* obj, Int_t kind = kMESS_OBJECT, TProof::ESlaves list = kActive)
Int_tBroadcastRaw(const void* buffer, Int_t length, TList* slaves)
Int_tBroadcastRaw(const void* buffer, Int_t length, TProof::ESlaves list = kActive)
Int_tBuildPackage(const char* package, TProof::EBuildPackageOpt opt = kBuildAll, Int_t chkveropt = kCheckROOT, TList* workers = 0)
Int_tBuildPackageOnClient(const char* package, Int_t opt = 0, TString* path = 0, Int_t chkveropt = kCheckROOT)
Bool_tCheckFile(const char* file, TSlave* sl, Long_t modtime, Int_t cpopt = (kCp | kCpBin))
voidCleanGDirectory(TList* ol)
voidClearDataProgress(Int_t r, Int_t t)
Int_tCollect(const TSlave* sl, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
Int_tCollect(TMonitor* mon, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
Int_tCollectInputFrom(TSocket* s, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
Bool_tCreateMerger(TSlave* sl, Int_t port)
voidDeActivateAsyncInput()
Int_tDisablePackage(const char* package)
Int_tDisablePackageOnClient(const char* package)
Int_tDisablePackages()
Int_tExec(const char* cmd, TProof::ESlaves list, Bool_t plusMaster)
voidFinalizationDone()
Int_tFindNextFreeMerger()
TSlave*FindSlave(TSocket* s) const
virtual voidFindUniqueSlaves()
Int_tGetActiveMergersCount()
static TList*GetDataSetSrvMaps(const TString& srvmaps)
TList*GetListOfBadSlaves() const
TList*GetListOfInactiveSlaves() const
TList*GetListOfSlaves() const
TList*GetListOfUniqueSlaves() const
Int_tGetNumberOfActiveSlaves() const
Int_tGetNumberOfBadSlaves() const
Int_tGetNumberOfInactiveSlaves() const
Int_tGetNumberOfSlaves() const
Int_tGetNumberOfUniqueSlaves() const
Int_tGetQueryReference(Int_t qry, TString& ref)
Int_tGoMoreParallel(Int_t nWorkersToAdd)
Int_tGoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE)
Int_tHandleInputMessage(TSlave* wrk, TMessage* m, Bool_t deactonfail = kFALSE)
voidHandleSubmerger(TMessage* mess, TSlave* sl)
voidInterrupt(TProof::EUrgent type, TProof::ESlaves list = kActive)
voidInterruptCurrentMonitor()
Bool_tIsEndMaster() const
Bool_tIsSync() const
Int_tLoadPackage(const char* package, Bool_t notOnClient = kFALSE, TList* loadopts = 0, TList* workers = 0)
Int_tLoadPackageOnClient(const char* package, TList* loadopts = 0)
voidMarkBad(TSlave* wrk, const char* reason = 0)
voidMarkBad(TSocket* s, const char* reason = 0)
Int_tModifyWorkerLists(const char* ord, Bool_t add, Bool_t save)
voidNotifyLogMsg(const char* msg, const char* sfx = "\n")
voidoperator=(const TProof&)
voidParseConfigField(const char* config)
Int_tPing(TProof::ESlaves list)
voidPrintProgress(Long64_t total, Long64_t processed, Float_t procTime = -1., Long64_t bytesread = -1)
Bool_tPrompt(const char* p)
voidRecvLogFile(TSocket* s, Int_t size)
voidRedirectWorker(TSocket* s, TSlave* sl, Int_t output_size)
voidReleaseMonitor(TMonitor* mon)
voidResetMergePrg()
voidResetMergers()
Int_tRestoreActiveList()
voidSaveActiveList()
Int_tSendCommand(const char* cmd, TProof::ESlaves list = kActive)
Int_tSendCurrentState(TProof::ESlaves list = kActive)
Int_tSendCurrentState(TList* list)
Int_tSendGroupView()
Int_tSendInitialState()
Int_tSendObject(const TObject* obj, TProof::ESlaves list = kActive)
Int_tSendPrint(Option_t* option = "")
voidSetMonitor(TMonitor* mon = 0, Bool_t on = kTRUE)
Int_tSetParallelSilent(Int_t nodes, Bool_t random = kFALSE)
voidSetRunStatus(TProof::ERunStatus rst)
voidTerminateWorker(TSlave* wrk)
voidTerminateWorker(const char* ord)
TProof(const TProof&)
Int_tUnloadPackage(const char* package)
Int_tUnloadPackageOnClient(const char* package)
Int_tUnloadPackages()
Int_tUploadPackageOnClient(const char* package, TProof::EUploadPackageOpt opt, TMD5* md5)

Data Members

public:
static TProof::ERunStatuskAborted
static TProof::EUploadOptkAppend
static TProof::EUploadOptkAskUser
static TProof::EQueryModekAsync
static TProof::ESubMergerkBeMerger
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TProof::EProofClearDatakDataset
static TProof::ERegisterOptkFailIfExists
static TProof::EProofClearDatakForceClear
static TObject::EStatusBitsTObject::kHasUUID
static TObject::EStatusBitsTObject::kInvalidObject
static TProof::EStatusBitskIsClient
static TProof::EStatusBitskIsMaster
static TObject::(anonymous)TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TProof::EStatusBitskIsTopMaster
static TProof::ERegisterOptkMergeIfExists
static TProof::ESubMergerkMergerDown
static TObject::EStatusBitsTObject::kMustCleanup
static TProof::EStatusBitskNewInputData
static TObject::EStatusBitsTObject::kNoContextMenu
static TProof::EUploadOptkNoOverwriteDataSet
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TProof::ESubMergerkOutputSent
static TProof::ESubMergerkOutputSize
static TObject::(anonymous)TObject::kOverwrite
static TProof::EUploadOptkOverwriteAllFiles
static TProof::EUploadOptkOverwriteDataSet
static TProof::ERegisterOptkOverwriteIfExists
static TProof::EUploadOptkOverwriteNoFiles
static TProof::EProofClearDatakPurge
static TProof::EUploadPackageOptkRemoveOld
static TProof::ERunStatuskRunning
static TProof::ESubMergerkSendOutput
static TObject::(anonymous)TObject::kSingleKey
static TProof::ESubMergerkStopMerging
static TProof::ERunStatuskStopped
static TProof::EQueryModekSync
static TProof::EProofClearDatakUnregistered
static TProof::EUploadPackageOptkUntar
static TProof::EStatusBitskUseProgressDialog
static TProof::EStatusBitskUsingSessionGui
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
protected:
TMonitor*fAllMonitormonitor activity on all valid slave sockets
TList*fAvailablePackageslist of available packages
TList*fBadSlavesdead slaves (subset of all slaves)
Long64_tfBytesReadynumber of bytes staged
Int_tfCollectTimeoutTimeout for (some) collect actions
TStringfConfDirdirectory containing cluster config information
TStringfConfFilefile containing config information
TStringfDataPoolUrldefault data pool entry point URL
Bool_tfDataReadytrue if data is ready to be analyzed
Bool_tfDynamicStartupare the workers started dynamically?
TList*fEnabledPackageslist of enabled packages
TStringfImagemaster's image name
TList*TQObject::fListOfConnections! list of connections to this object
TList*TQObject::fListOfSignals! list of signals from this object
TProofMgr*fManagermanager to which this session belongs (if any)
Bool_tfMasterServtrue if we are a master server
TStringTNamed::fNameobject identifier
Float_tfPrepTimePreparation time
Int_tfProtocolremote PROOF server protocol version number
TProof::EQueryModefQueryModedefault query mode
TStopwatchfQuerySTWStopwatch to measure query times
TList*fRunningDSetsTemporary datasets used for async running
TSelector*fSelectorSelector to be processed, if any
TProofMgr::EServTypefServTypetype of server: proofd, XrdProofd
Bool_tTQObject::fSignalsBlocked! flag used for suppression of signals
TList*fSlaveslist of all slave servers as in config file
TList*fTerminatedSlaveInfoslist of unique infos of terminated slaves
TStringTNamed::fTitleobject title
Long64_tfTotalBytesnumber of bytes to be analyzed
TUrlfUrlUrl of the master
static Bool_tTQObject::fgAllSignalsBlockedflag used for suppression of all signals
static TSemaphore*fgSemaphoresemaphore to control no of parallel startup threads
static TProof::ESlaveskActive
static TProof::ESlaveskAll
static TProof::ESlaveskAllUnique
static TProof::ESlaveskUnique
private:
TMonitor*fActiveMonitormonitor activity on all active slave sockets
TList*fActiveSlaveslist of active slaves (subset of all slaves)
TStringfActiveSlavesSavedcomma-separated list of active slaves (before last call to
TMonitor*fAllUniqueMonitormonitor activity on all unique slave sockets, including all submasters
TList*fAllUniqueSlaveslist of all active slaves with unique file systems, including all submasters
Long64_tfBytesReadbytes read by all slaves during the session
TList*fChainschains with this proof set
Int_tfCheckFileStatusremote return status after kPROOF_CHECKFILE
TVirtualMutex*fCloseMutexAvoid crashes in MarkBad or alike while closing
Float_tfCpuTimeCPU time spent by all slaves during the session
TMonitor*fCurrentMonitorcurrently active monitor
TDSet*fDSetcurrent TDSet being validated
Int_tfDrawQueriesnumber of draw queries during this sessions
TList*fEnabledPackagesOnClientlist of packages enabled on client
TList*fEnabledPackagesOnClusterlist of enabled packages
Bool_tfEndMastertrue for a master in direct contact only with workers
TList*fFeedbacklist of names to be returned as feedback
TProof::FileMap_tfFileMapmap keeping track of a file's md5 and mod time
Bool_tfFinalizationRunning
THashList*fGlobalPackageDirListlist of directories containing global packages libs
TStringfGroupPROOF group of this user
TList*fInactiveSlaveslist of inactive slaves (good but not used for processing)
TList*fInputDataInput data objects sent over via file
TStringfInputDataFileFile with input data objects
TSignalHandler*fIntHandlerinterrupt signal handler (ctrl-c)
Bool_tfIsPollingWorkerswill be set to kFALSE to prevent recursive dyn workers check in dyn mode
Bool_tfIsWaitingtrue if queries have been enqueued
Int_tfLastAssignedMerger
Long64_tfLastPollWorkers_stimestamp (in seconds) of last poll for workers, -1 if never checked
TList*fLoadedMacrosList of loaded macros (just file names)
TStringfLogFileNamename of the temp file for redirected logs
FILE*fLogFileRtemp file to read redirected logs
FILE*fLogFileWtemp file to redirect logs
Int_tfLogLevelserver debug logging level
Bool_tfLogToWindowOnlysend log to window only
TMacrofMacroLogMacro with the saved (last) log
TStringfMastermaster server ("" if a master); used in the browser
Int_tfMaxDrawQueriesmax number of draw queries kept
TProofMergePrgfMergePrgMerging progress
TList*fMergers
Bool_tfMergersByHostMergers assigned by host name
Int_tfMergersCount
Bool_tfMergersSetIndicates, if the following variables have been initialized properly
TList*fNonUniqueMasterslist of all active masters with a nonunique file system
Int_tfNotIdleNumber of non-idle sub-nodes
Int_tfOtherQueriesnumber of queries in list from previous sessions
TProofOutputListfOutputListTList implementation filtering ls(...) and Print(...)
TStringfPackageDirpackage directory (used on client)
TProofLockPath*fPackageLockpackage lock
TStringfPerfTreeIf non-null triggers saving of the performance info into fPerfTree
TVirtualProofPlayer*fPlayercurrent player
PrintProgress_tfPrintProgressFunction function to display progress info in batch mode
TPluginHandler*fProgressDialogprogress dialog plugin
Bool_tfProgressDialogStartedindicates if the progress dialog is up
TList*fQuerieslist of TProofQuery objects
Float_tfRealTimerealtime spent by all slaves during the session
TList*fRecvMessagesMessages received during collect not yet processed
Bool_tfRedirLogredirect received log info
Int_tfRedirectNext
TProof::ERunStatusfRunStatusrun status
Bool_tfSaveLogToMacroWhether to save received logs to TMacro fMacroLog (use with care)
Bool_tfSendGroupViewif true send new group view
Int_tfSeqNumRemote sequential # of the last query submitted
Int_tfSessionIDremote ID of the session
TList*fSlaveInfo!list returned by kPROOF_GETSLAVEINFO
Int_tfStatusremote return status (part of kPROOF_LOGDONE)
Bool_tfSynctrue if type of currently processed query is sync
Bool_tfTtyTRUE if connected to a terminal
TMonitor*fUniqueMonitormonitor activity on all unique slave sockets
TList*fUniqueSlaveslist of all active slaves with unique file systems
Bool_tfValidis this a valid proof object
TList*fWaitingSlavesstores a TPair of the slaves's TSocket and TMessage
TStringfWorkDircurrent work directory on remote servers
Int_tfWorkersToMergeCurrent total number of workers, which have not been yet assigned to any merger
TList*fWrksOutputReadyList of workers ready to send output (in control output sending mode)
static TPluginHandler*fgLogViewerLog dialog box plugin
static TList*fgProofEnvListList of TNameds defining environment
static TProof::EProofWrkListActionkActivateWorker
static TProof::ESendFileOptkAscii
static TProof::ESendFileOptkBinary
static TProof::EBuildPackageOptkBuildAll
static TProof::EBuildPackageOptkBuildOnSlavesNoWait
static TProof::EProofCacheCommandskBuildPackage
static TProof::EProofCacheCommandskBuildSubPackage
static TProof::EProofDataSetCommandskCache
static TProof::EProofDataSetCommandskCancelStaging
static TProof::EProofDataSetCommandskCheckDataSetName
static TProof::EParCheckVersionOptkCheckROOT
static TProof::EParCheckVersionOptkCheckSVN
static TProof::EProofCacheCommandskClearCache
static TProof::EProofCacheCommandskClearPackage
static TProof::EProofCacheCommandskClearPackages
static TProof::EProofCacheCommandskClearSubCache
static TProof::EBuildPackageOptkCollectBuildResults
static TProof::ESendFileOptkCp
static TProof::ESendFileOptkCpBin
static TProof::EProofWrkListActionkDeactivateWorker
static TProof::EProofCacheCommandskDisablePackage
static TProof::EProofCacheCommandskDisablePackages
static TProof::EProofCacheCommandskDisableSubPackage
static TProof::EProofCacheCommandskDisableSubPackages
static TProof::EBuildPackageOptkDontBuildOnClient
static TProof::EParCheckVersionOptkDontCheck
static TProof::ESendFileOptkForce
static TProof::ESendFileOptkForward
static TProof::EProofDataSetCommandskGetDataSet
static TProof::EProofDataSetCommandskGetDataSets
static TProof::EProofDataSetCommandskGetQuota
static TProof::EUrgentkHardInterrupt
static TProof::EProofCacheCommandskListEnabledPackages
static TProof::EProofCacheCommandskListPackages
static TProof::EProofCacheCommandskLoadMacro
static TProof::EProofCacheCommandskLoadPackage
static TProof::EUrgentkLocalInterrupt
static TProof::EProofDataSetCommandskMergeDataSet
static TProof::EProofShowQuotaOptkPerGroup
static TProof::EProofShowQuotaOptkPerUser
static TProof::EUrgentkPing
static TProof::EProofDataSetCommandskRegisterDataSet
static TProof::EProofDataSetCommandskRemoveDataSet
static TProof::EProofDataSetCommandskRequestStaging
static TProof::EProofDataSetCommandskSetDefaultTreeName
static TProof::EProofCacheCommandskShowCache
static TProof::EProofDataSetCommandskShowDataSets
static TProof::EProofCacheCommandskShowEnabledPackages
static TProof::EProofCacheCommandskShowPackages
static TProof::EProofDataSetCommandskShowQuota
static TProof::EProofCacheCommandskShowSubCache
static TProof::EProofCacheCommandskShowSubPackages
static TProof::EUrgentkShutdownInterrupt
static TProof::EUrgentkSoftInterrupt
static TProof::EProofDataSetCommandskStagingStatus
static TProof::EProofCacheCommandskUnloadPackage
static TProof::EProofCacheCommandskUnloadPackages
static TProof::EProofDataSetCommandskUploadDataSet
static TProof::EProofDataSetCommandskVerifyDataSet

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TProof(const char* masterurl, const char* conffile = kPROOF_ConfFile, const char* confdir = kPROOF_ConfDir, Int_t loglevel = 0, const char* alias = 0, TProofMgr* mgr = 0)
 Create a PROOF environment. Starting PROOF involves either connecting
 to a master server, which in turn will start a set of slave servers, or
 directly starting as master server (if master = ""). Masterurl is of
 the form: [proof[s]://]host[:port]. Conffile is the name of the config
 file describing the remote PROOF cluster (this argument alows you to
 describe different cluster configurations).
 The default is proof.conf. Confdir is the directory where the config
 file and other PROOF related files are (like motd and noproof files).
 Loglevel is the log level (default = 1). User specified custom config
 files will be first looked for in $HOME/.conffile.
TProof()
 Protected constructor to be used by classes deriving from TProof
 (they have to call Init themselves and override StartSlaves
 appropriately).

 This constructor simply closes any previous gProof and sets gProof
 to this instance.
void InitMembers()
 Default initializations
~TProof()
 Clean up PROOF environment.
Int_t Init(const char* masterurl, const char* conffile, const char* confdir, Int_t loglevel, const char* alias = 0)
 Start the PROOF environment. Starting PROOF involves either connecting
 to a master server, which in turn will start a set of slave servers, or
 directly starting as master server (if master = ""). For a description
 of the arguments see the TProof ctor. Returns the number of started
 master or slave servers, returns 0 in case of error, in which case
 fValid remains false.
Int_t GetSandbox(TString& sb, Bool_t assert = kFALSE, const char* rc = 0)
 Set the sandbox path from ' Proof.Sandbox' or the alternative var 'rc'.
 Use the existing setting or the default if nothing is found.
 If 'assert' is kTRUE, make also sure that the path exists.
 Return 0 on success, -1 on failure
void ParseConfigField(const char* config)
 The config file field may contain special instructions which need to be
 parsed at the beginning, e.g. for debug runs with valgrind.
 Several options can be given separated by a ','
Int_t AssertPath(const char* path, Bool_t writable)
 Make sure that 'path' exists; if 'writable' is kTRUE, make also sure
 that the path is writable
void SetManager(TProofMgr* mgr)
 Set manager and schedule its destruction after this for clean
 operations.
Int_t AddWorkers(TList* wrks)
 Works on the master node only.
 It starts workers on the machines in workerList and sets the paths,
 packages and macros as on the master.
 It is a subbstitute for StartSlaves(...)
 The code is mostly the master part of StartSlaves,
 with the parallel startup removed.
void SetupWorkersEnv(TList* wrks, Bool_t increasingpool = kFALSE)
 Set up packages, loaded macros, include and lib paths ...
Int_t RemoveWorkers(TList* wrks)
 Used for shuting down the workres after a query is finished.
 Sends each of the workers from the workerList, a kPROOF_STOP message.
 If the workerList == 0, shutdown all the workers.
Bool_t StartSlaves(Bool_t attach = kFALSE)
 Start up PROOF slaves.
void Close(Option_t* option = "")
 Close all open slave servers.
 Client can decide to shutdown the remote session by passing option is 'S'
 or 's'. Default for clients is detach, if supported. Masters always
 shutdown the remote counterpart.
TSlave * CreateSlave(const char* url, const char* ord, Int_t perf, const char* image, const char* workdir)
 Create a new TSlave of type TSlave::kSlave.
 Note: creation of TSlave is private with TProof as a friend.
 Derived classes must use this function to create slaves.
TSlave * CreateSubmaster(const char* url, const char* ord, const char* image, const char* msd, Int_t nwk = 1)
 Create a new TSlave of type TSlave::kMaster.
 Note: creation of TSlave is private with TProof as a friend.
 Derived classes must use this function to create slaves.
TSlave * FindSlave(TSocket* s) const
 Find slave that has TSocket s. Returns 0 in case slave is not found.
void FindUniqueSlaves()
 Add to the fUniqueSlave list the active slaves that have a unique
 (user) file system image. This information is used to transfer files
 only once to nodes that share a file system (an image). Submasters
 which are not in fUniqueSlaves are put in the fNonUniqueMasters
 list. That list is used to trigger the transferring of files to
 the submaster's unique slaves without the need to transfer the file
 to the submaster.
Int_t GetNumberOfSlaves() const
 Return number of slaves as described in the config file.
Int_t GetNumberOfActiveSlaves() const
 Return number of active slaves, i.e. slaves that are valid and in
 the current computing group.
Int_t GetNumberOfInactiveSlaves() const
 Return number of inactive slaves, i.e. slaves that are valid but not in
 the current computing group.
Int_t GetNumberOfUniqueSlaves() const
 Return number of unique slaves, i.e. active slaves that have each a
 unique different user files system.
Int_t GetNumberOfBadSlaves() const
 Return number of bad slaves. This are slaves that we in the config
 file, but refused to startup or that died during the PROOF session.
void AskStatistics()
 Ask the for the statistics of the slaves.
void GetStatistics(Bool_t verbose = kFALSE)
 Get statistics about CPU time, real time and bytes read.
 If verbose, print the resuls (always available via GetCpuTime(), GetRealTime()
 and GetBytesRead()
void AskParallel()
 Ask the for the number of parallel slaves.
TList * GetListOfQueries(Option_t* opt = "")
 Ask the master for the list of queries.
Int_t GetNumberOfQueries()
 Number of queries processed by this session
void SetMaxDrawQueries(Int_t max)
 Set max number of draw queries whose results are saved
void GetMaxQueries()
 Get max number of queries whose full results are kept in the
 remote sandbox
TList * GetQueryResults()
 Return pointer to the list of query results in the player
TQueryResult * GetQueryResult(const char* ref = 0)
 Return pointer to the full TQueryResult instance owned by the player
 and referenced by 'ref'. If ref = 0 or "", return the last query result.
void ShowQueries(Option_t* opt = "")
 Ask the master for the list of queries.
 Options:
           "A"     show information about all the queries known to the
                   server, i.e. even those processed by other sessions
           "L"     show only information about queries locally available
                   i.e. already retrieved. If "L" is specified, "A" is
                   ignored.
           "F"     show all details available about queries
           "H"     print help menu
 Default ""
Bool_t IsDataReady(Long64_t& totalbytes, Long64_t& bytesready)
 See if the data is ready to be analyzed.
void Interrupt(TProof::EUrgent type, TProof::ESlaves list = kActive)
 Send interrupt to master or slave servers.
Int_t GetParallel() const
 Returns number of slaves active in parallel mode. Returns 0 in case
 there are no active slaves. Returns -1 in case of error.
TList * GetListOfSlaveInfos()
 Returns list of TSlaveInfo's. In case of error return 0.
void Activate(TList* slaves = 0)
 Activate slave server list.
void SetMonitor(TMonitor* mon = 0, Bool_t on = kTRUE)
 Activate (on == TRUE) or deactivate (on == FALSE) all sockets
 monitored by 'mon'.
Int_t BroadcastGroupPriority(const char* grp, Int_t priority, TList* workers)
 Broadcast the group priority to all workers in the specified list. Returns
 the number of workers the message was successfully sent to.
 Returns -1 in case of error.
Int_t BroadcastGroupPriority(const char* grp, Int_t priority, TProof::ESlaves list = kAllUnique)
 Broadcast the group priority to all workers in the specified list. Returns
 the number of workers the message was successfully sent to.
 Returns -1 in case of error.
void ResetMergePrg()
 Reset the merge progress notificator
Int_t Broadcast(const TMessage& mess, TList* slaves)
 Broadcast a message to all slaves in the specified list. Returns
 the number of slaves the message was successfully sent to.
 Returns -1 in case of error.
Int_t Broadcast(const TMessage& mess, TProof::ESlaves list = kActive)
 Broadcast a message to all slaves in the specified list (either
 all slaves or only the active slaves). Returns the number of slaves
 the message was successfully sent to. Returns -1 in case of error.
Int_t Broadcast(const char* mess, Int_t kind, TList* slaves)
 Broadcast a character string buffer to all slaves in the specified
 list. Use kind to set the TMessage what field. Returns the number of
 slaves the message was sent to. Returns -1 in case of error.
Int_t Broadcast(const char* mess, Int_t kind = kMESS_STRING, TProof::ESlaves list = kActive)
 Broadcast a character string buffer to all slaves in the specified
 list (either all slaves or only the active slaves). Use kind to
 set the TMessage what field. Returns the number of slaves the message
 was sent to. Returns -1 in case of error.
Int_t BroadcastObject(const TObject* obj, Int_t kind, TList* slaves)
 Broadcast an object to all slaves in the specified list. Use kind to
 set the TMEssage what field. Returns the number of slaves the message
 was sent to. Returns -1 in case of error.
Int_t BroadcastObject(const TObject* obj, Int_t kind = kMESS_OBJECT, TProof::ESlaves list = kActive)
 Broadcast an object to all slaves in the specified list. Use kind to
 set the TMEssage what field. Returns the number of slaves the message
 was sent to. Returns -1 in case of error.
Int_t BroadcastRaw(const void* buffer, Int_t length, TList* slaves)
 Broadcast a raw buffer of specified length to all slaves in the
 specified list. Returns the number of slaves the buffer was sent to.
 Returns -1 in case of error.
Int_t BroadcastRaw(const void* buffer, Int_t length, TProof::ESlaves list = kActive)
 Broadcast a raw buffer of specified length to all slaves in the
 specified list. Returns the number of slaves the buffer was sent to.
 Returns -1 in case of error.
Int_t BroadcastFile(const char* file, Int_t opt, const char* rfile, TList* wrks)
 Broadcast file to all workers in the specified list. Returns the number of workers
 the buffer was sent to.
 Returns -1 in case of error.
Int_t BroadcastFile(const char* file, Int_t opt, const char* rfile = 0, TProof::ESlaves list = kAllUnique)
 Broadcast file to all workers in the specified list. Returns the number of workers
 the buffer was sent to.
 Returns -1 in case of error.
void ReleaseMonitor(TMonitor* mon)
 Release the used monitor to be used, making sure to delete newly created
 monitors.
Int_t Collect(const TSlave* sl, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
 Collect responses from slave sl. Returns the number of slaves that
 responded (=1).
 If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
 which means wait forever).
 If defined (>= 0) endtype is the message that stops this collection.
Int_t Collect(TList* slaves, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
 Collect responses from the slave servers. Returns the number of slaves
 that responded.
 If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
 which means wait forever).
 If defined (>= 0) endtype is the message that stops this collection.
Int_t Collect(ESlaves list, Long_t timeout, Int_t endtype, Bool_t deactonfail)
 Collect responses from the slave servers. Returns the number of slaves
 that responded.
 If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
 which means wait forever).
 If defined (>= 0) endtype is the message that stops this collection.
Int_t Collect(TMonitor* mon, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
 Collect responses from the slave servers. Returns the number of messages
 received. Can be 0 if there are no active slaves.
 If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
 which means wait forever).
 If defined (>= 0) endtype is the message that stops this collection.
 Collect also stops its execution from time to time to check for new
 workers in Dynamic Startup mode.
Int_t PollForNewWorkers()
 Asks the PROOF Serv for new workers in Dynamic Startup mode and activates
 them. Returns the number of new workers found, or <0 on errors.
void CleanGDirectory(TList* ol)
 Remove links to objects in list 'ol' from gDirectory
Int_t CollectInputFrom(TSocket* s, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
 Collect and analyze available input from socket s.
 Returns 0 on success, -1 if any failure occurs.
Int_t HandleInputMessage(TSlave* wrk, TMessage* m, Bool_t deactonfail = kFALSE)
 Analyze the received message.
 Returns 0 on success (1 if this the last message from this socket), -1 if
 any failure occurs.
void HandleSubmerger(TMessage* mess, TSlave* sl)
 Process a message of type kPROOF_SUBMERGER
void RedirectWorker(TSocket* s, TSlave* sl, Int_t output_size)
 Redirect output of worker sl to some merger
Int_t FindNextFreeMerger()
 Return a merger, which is both active and still accepts some workers to be
 assigned to it. It works on the 'round-robin' basis.
void AskForOutput(TSlave* sl)
 Master asks for output from worker sl
void UpdateDialog()
 Final update of the progress dialog
void ActivateAsyncInput()
 Activate the a-sync input handler.
void DeActivateAsyncInput()
 De-activate a-sync input handler.
Int_t GetActiveMergersCount()
 Get the active mergers count
Bool_t CreateMerger(TSlave* sl, Int_t port)
 Create a new merger
void MarkBad(TSlave* wrk, const char* reason = 0)
 Add a bad slave server to the bad slave list and remove it from
 the active list and from the two monitor objects. Assume that the work
 done by this worker was lost and ask packerizer to reassign it.
void MarkBad(TSocket* s, const char* reason = 0)
 Add slave with socket s to the bad slave list and remove if from
 the active list and from the two monitor objects.
void TerminateWorker(TSlave* wrk)
 Ask an active worker 'wrk' to terminate, i.e. to shutdown
void TerminateWorker(const char* ord)
 Ask an active worker 'ord' to terminate, i.e. to shutdown
Int_t Ping()
 Ping PROOF. Returns 1 if master server responded.
Int_t Ping(TProof::ESlaves list)
 Ping PROOF slaves. Returns the number of slaves that responded.
void Touch()
 Ping PROOF slaves. Returns the number of slaves that responded.
void Print(Option_t* option = "") const
 Print status of PROOF cluster.
Int_t HandleOutputOptions(TString& opt, TString& target, Int_t action)
 Extract from opt information about output handling settings.
 The understood keywords are:
     of=<file>, outfile=<file>         output file location
     ds=<dsname>, dataset=<dsname>     dataset name ('of' and 'ds' are
                                       mutually exclusive,execution stops
                                       if both are found)
     sft[=<opt>], savetofile[=<opt>]   control saving to file

 For 'mvf', the <opt> integer has the following meaning:
     <opt> = <how>*10 + <force>
             <force> = 0      save to file if memory threshold is reached
                              (the memory threshold is set by the cluster
                              admin); in case an output file is defined, the
                              files are merged at the end;
                       1      save results to file.
             <how> =   0      save at the end of the query
                       1      save results after each packet (to reduce the
                              loss in case of crash).

 Setting 'ds' automatically sets 'mvf=1'; it is still possible to set 'mvf=11'
 to save results after each packet.

 The separator from the next option is either a ' ' or a ';'

 All recognized settings are removed from the input string opt.
 If action == 0, set up the output file accordingly, if action == 1 clean related
 output file settings.
 If the final target file is local then 'target' is set to the final local path
 when action == 0 and used to retrieve the file with TFile::Cp when action == 1.

 Output file settings are in the form

       <previous_option>of=name <next_option>
       <previous_option>outfile=name,...;<next_option>

 The separator from the next option is either a ' ' or a ';'
 Called interanally by TProof::Process.

 Returns 0 on success, -1 on error.
void SetFeedback(TString& opt, TString& optfb, Int_t action)
 Extract from opt in optfb information about wanted feedback settings.
 Feedback are removed from the input string opt.
 If action == 0, set up feedback accordingly, if action == 1 clean related
 feedback settings (using info in optfb, if available, or reparsing opt).

 Feedback requirements are in the form

       <previous_option>fb=name1,name2,name3,... <next_option>
       <previous_option>feedback=name1,name2,name3,...;<next_option>

 The special name 'stats' triggers feedback about events and packets.
 The separator from the next option is either a ' ' or a ';'.
 Called interanally by TProof::Process.
Long64_t Process(TDSet* dset, const char* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
 Process a data set (TDSet) using the specified selector (.C) file or
 Tselector object
 Entry- or event-lists should be set in the data set object using
 TDSet::SetEntryList.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Long64_t Process(TFileCollection* fc, const char* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
 Process a data set (TFileCollection) using the specified selector (.C) file
 or TSelector object.
 The default tree is analyzed (i.e. the first one found). To specify another
 tree, the default tree can be changed using TFileCollection::SetDefaultMetaData .
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Long64_t Process(const char* dsetname, const char* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0, TObject* enl = 0)
 Process a dataset which is stored on the master with name 'dsetname'.
 The syntax for dsetname is name[#[dir/]objname], e.g.
   "mydset"       analysis of the first tree in the top dir of the dataset
                  named "mydset"
   "mydset#T"     analysis tree "T" in the top dir of the dataset
                  named "mydset"
   "mydset#adir/T" analysis tree "T" in the dir "adir" of the dataset
                  named "mydset"
   "mydset#adir/" analysis of the first tree in the dir "adir" of the
                  dataset named "mydset"
 The component 'name' in its more general form contains also the group and
 user name following "/<group>/<user>/<dsname>". Each of these components
 can contain one or more wildcards '*', in which case all the datasets matching
 the expression are added together as a global dataset (wildcard support has
 been added in version 5.27/02).
 The last argument 'elist' specifies an entry- or event-list to be used as
 event selection.
 It is also possible (starting w/ version 5.27/02) to run on multiple datasets
 at once in a more flexible way that the one provided by wildcarding. There
 are three possibilities:
    1) specifying the dataset names separated by the OR operator '|', e.g.
          dsetname = "<dset1>|<dset2>|<dset3>|..."
       in this case the datasets are a seen as a global unique dataset
    2) specifying the dataset names separated by a ',' or a ' ', e.g.
          dsetname = "<dset1>,<dset2> <dset3>,..."
       in this case the datasets are processed one after the other and the
       selector is notified when switching dataset via a bit in the current
       processed element.
    3) giving the path of a textfile where the dataset names are specified
       on one or multiple lines; the lines found are joined as in 1), unless
       the filepath is followed by a ',' (i.e. p->Process("datasets.txt,",...)
       with the dataset names listed in 'datasets.txt') in which case they are
       treated as in 2); the file is open in raw mode with TFile::Open and
       therefore it cane be remote, e.g. on a Web server.
 Each <dsetj> has the format specified above for the single dataset processing,
 included wildcarding (the name of the tree and subdirectory must be same for
 all the datasets).
 In the case of multiple datasets, 'elist' is treated a global entry list.
 It is possible to specify per-dataset entry lists using the syntax
   "mydset[#adir/[T]]?enl=entrylist"
 or
   "mydset[#adir/[T]]<<entrylist"
 Here 'entrylist' is a tag identifying, in the order :
   i. a named entry-list in the input list or in the input data list
  ii. a named entry-list in memory (in gDirectory)
 iii. the path of a file containing the entry-list to be used
 In the case ii) and iii) the entry-list object(s) is(are) added to the input
 data list.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Long64_t Process(const char* selector, Long64_t nentries, Option_t* option = "")
 Generic (non-data based) selector processing: the Process() method of the
 specified selector (.C) or TSelector object is called 'n' times.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Long64_t Process(TDSet* dset, TSelector* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
 Process a data set (TDSet) using the specified selector object.
 Entry- or event-lists should be set in the data set object using
 TDSet::SetEntryList.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Long64_t Process(TFileCollection* fc, TSelector* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
 Process a data set (TFileCollection) using the specified selector object
 The default tree is analyzed (i.e. the first one found). To specify another
 tree, the default tree can be changed using TFileCollection::SetDefaultMetaData .
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Long64_t Process(const char* dsetname, TSelector* selector, Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0, TObject* enl = 0)
 Process with name of dataset and TSelector object
Long64_t Process(TSelector* selector, Long64_t nentries, Option_t* option = "")
 Generic (non-data based) selector processing: the Process() method of the
 specified selector is called 'n' times.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Int_t GetQueryReference(Int_t qry, TString& ref)
 Get reference for the qry-th query in fQueries (as
 displayed by ShowQueries).
Long64_t Finalize(Int_t query = -1, Bool_t force = kFALSE)
 Finalize the qry-th query in fQueries.
 If force, force retrieval if the query is found in the local list
 but has already been finalized (default kFALSE).
 If query < 0, finalize current query.
 Return 0 on success, -1 on error
Long64_t Finalize(const char* queryref, Bool_t force = kFALSE)
 Finalize query with reference ref.
 If force, force retrieval if the query is found in the local list
 but has already been finalized (default kFALSE).
 If ref = 0, finalize current query.
 Return 0 on success, -1 on error
Int_t Retrieve(Int_t query, const char* path = 0)
 Send retrieve request for the qry-th query in fQueries.
 If path is defined save it to path.
Int_t Retrieve(const char* queryref, const char* path = 0)
 Send retrieve request for the query specified by ref.
 If path is defined save it to path.
 Generic method working for all queries known by the server.
Int_t Remove(Int_t query, Bool_t all = kFALSE)
 Send remove request for the qry-th query in fQueries.
Int_t Remove(const char* queryref, Bool_t all = kFALSE)
 Send remove request for the query specified by ref.
 If all = TRUE remove also local copies of the query, if any.
 Generic method working for all queries known by the server.
 This method can be also used to reset the list of queries
 waiting to be processed: for that purpose use ref == "cleanupqueue".
Int_t Archive(Int_t query, const char* url)
 Send archive request for the qry-th query in fQueries.
Int_t Archive(const char* queryref, const char* url = 0)
 Send archive request for the query specified by ref.
 Generic method working for all queries known by the server.
 If ref == "Default", path is understood as a default path for
 archiving.
Int_t CleanupSession(const char* sessiontag)
 Send cleanup request for the session specified by tag.
void SetQueryMode(TProof::EQueryMode mode)
 Change query running mode to the one specified by 'mode'.
Long64_t DrawSelect(TDSet* dset, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
 Execute the specified drawing action on a data set (TDSet).
 Event- or Entry-lists should be set in the data set object using
 TDSet::SetEntryList.
 Returns -1 in case of error or number of selected events otherwise.
Long64_t DrawSelect(const char* dsetname, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0, TObject* enl = 0)
 Execute the specified drawing action on a data set which is stored on the
 master with name 'dsetname'.
 The syntax for dsetname is name[#[dir/]objname], e.g.
   "mydset"       analysis of the first tree in the top dir of the dataset
                  named "mydset"
   "mydset#T"     analysis tree "T" in the top dir of the dataset
                  named "mydset"
   "mydset#adir/T" analysis tree "T" in the dir "adir" of the dataset
                  named "mydset"
   "mydset#adir/" analysis of the first tree in the dir "adir" of the
                  dataset named "mydset"
 The last argument 'enl' specifies an entry- or event-list to be used as
 event selection.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
void StopProcess(Bool_t abort, Int_t timeout = -1)
 Send STOPPROCESS message to master and workers.
void DisableGoAsyn()
 Signal to disable related switches
void GoAsynchronous()
 Send GOASYNC message to the master.
void RecvLogFile(TSocket* s, Int_t size)
 Receive the log file of the slave with socket s.
void NotifyLogMsg(const char* msg, const char* sfx = "\n")
 Notify locally 'msg' to the appropriate units (file, stdout, window)
 If defined, 'sfx' is added after 'msg' (typically a line-feed);
void LogMessage(const char* msg, Bool_t all)
 Log a message into the appropriate window by emitting a signal.
Int_t SendGroupView()
 Send to all active slaves servers the current slave group size
 and their unique id. Returns number of active slaves.
 Returns -1 in case of error.
Bool_t GetFileInCmd(const char* cmd, TString& fn)
 Static method to extract the filename (if any) form a CINT command.
 Returns kTRUE and the filename in 'fn'; returns kFALSE if not found or not
 appliable.
Int_t Exec(const char* cmd, Bool_t plusMaster = kFALSE)
 Send command to be executed on the PROOF master and/or slaves.
 If plusMaster is kTRUE then exeucte on slaves and master too.
 Command can be any legal command line command. Commands like
 ".x file.C" or ".L file.C" will cause the file file.C to be send
 to the PROOF cluster. Returns -1 in case of error, >=0 in case of
 succes.
Int_t Exec(const char *cmd, ESlaves list, Bool_t plusMaster)
 Send command to be executed on the PROOF master and/or slaves.
 Command can be any legal command line command. Commands like
 ".x file.C" or ".L file.C" will cause the file file.C to be send
 to the PROOF cluster. Returns -1 in case of error, >=0 in case of
 succes.
Int_t Exec(const char* cmd, const char* ord, Bool_t logtomacro = kFALSE)
 Send command to be executed on node of ordinal 'ord' (use "0" for master).
 Command can be any legal command line command. Commands like
 ".x file.C" or ".L file.C" will cause the file file.C to be send
 to the PROOF cluster.
 If logtomacro is TRUE the text result of the action is saved in the fMacroLog
 TMacro, accessible via TMacro::GetMacroLog();
 Returns -1 in case of error, >=0 in case of succes.
Int_t SendCommand(const char* cmd, TProof::ESlaves list = kActive)
 Send command to be executed on the PROOF master and/or slaves.
 Command can be any legal command line command, however commands
 like ".x file.C" or ".L file.C" will not cause the file.C to be
 transfered to the PROOF cluster. In that case use TProof::Exec().
 Returns the status send by the remote server as part of the
 kPROOF_LOGDONE message. Typically this is the return code of the
 command on the remote side. Returns -1 in case of error.
TString Getenv(const char* env, const char* ord = "0")
 Get value of environment variable 'env' on node 'ord'
Int_t GetRC(const char* RCenv, Int_t& env, const char* ord = "0")
 Get into 'env' the value of integer RC env variable 'rcenv' on node 'ord'
Int_t GetRC(const char* RCenv, Double_t& env, const char* ord = "0")
 Get into 'env' the value of double RC env variable 'rcenv' on node 'ord'
Int_t GetRC(const char* RCenv, TString& env, const char* ord = "0")
 Get into 'env' the value of string RC env variable 'rcenv' on node 'ord'
Int_t SendCurrentState(TList* list)
 Transfer the current state of the master to the active slave servers.
 The current state includes: the current working directory, etc.
 Returns the number of active slaves. Returns -1 in case of error.
Int_t SendCurrentState(TProof::ESlaves list = kActive)
 Transfer the current state of the master to the active slave servers.
 The current state includes: the current working directory, etc.
 Returns the number of active slaves. Returns -1 in case of error.
Int_t SendInitialState()
 Transfer the initial (i.e. current) state of the master to all
 slave servers. Currently the initial state includes: log level.
 Returns the number of active slaves. Returns -1 in case of error.
Bool_t CheckFile(const char* file, TSlave* sl, Long_t modtime, Int_t cpopt = (kCp | kCpBin))
 Check if a file needs to be send to the slave. Use the following
 algorithm:
   - check if file appears in file map
     - if yes, get file's modtime and check against time in map,
       if modtime not same get md5 and compare against md5 in map,
       if not same return kTRUE.
     - if no, get file's md5 and modtime and store in file map, ask
       slave if file exists with specific md5, if yes return kFALSE,
       if no return kTRUE.
 The options 'cpopt' define if to copy things from cache to sandbox and what.
 To retrieve from the cache the binaries associated with the file TProof::kCpBin
 must be set in cpopt; the default is copy everything.
 Returns kTRUE in case file needs to be send, returns kFALSE in case
 file is already on remote node.
Int_t SendFile(const char* file, Int_t opt = (kBinary | kForward | kCp | kCpBin), const char* rfile = 0, TSlave* sl = 0)
 Send a file to master or slave servers. Returns number of slaves
 the file was sent to, maybe 0 in case master and slaves have the same
 file system image, -1 in case of error.
 If defined, send to worker 'wrk' only.
 If defined, the full path of the remote path will be rfile.
 If rfile = "cache" the file is copied to the remote cache instead of the sandbox
 (to copy to the cache on a different name use rfile = "cache:newname").
 The mask 'opt' is an or of ESendFileOpt:

       kAscii  (0x0)      if set true ascii file transfer is used
       kBinary (0x1)      if set true binary file transfer is used
       kForce  (0x2)      if not set an attempt is done to find out
                          whether the file really needs to be downloaded
                          (a valid copy may already exist in the cache
                          from a previous run); the bit is set by
                          UploadPackage, since the check is done elsewhere.
       kForward (0x4)     if set, ask server to forward the file to slave
                          or submaster (meaningless for slave servers).
       kCpBin   (0x8)     Retrieve from the cache the binaries associated
                          with the file
       kCp      (0x10)    Retrieve the files from the cache

Int_t Echo(const TObject* obj)
 Sends an object to master and workers and expect them to send back a
 message with the output of its TObject::Print(). Returns -1 on error, the
 number of workers that received the objects on success.
Int_t Echo(const char* str)
 Sends a string to master and workers and expect them to echo it back to
 the client via a message. It is a special case of the generic Echo()
 that works with TObjects. Returns -1 on error, the number of workers that
 received the message on success.
Int_t SendObject(const TObject* obj, TProof::ESlaves list = kActive)
 Send object to master or slave servers. Returns number of slaves object
 was sent to, -1 in case of error.
Int_t SendPrint(Option_t* option = "")
 Send print command to master server. Returns number of slaves message
 was sent to. Returns -1 in case of error.
void SetLogLevel(Int_t level, UInt_t mask = TProofDebug::kAll)
 Set server logging level.
void SetRealTimeLog(Bool_t on = kTRUE)
 Switch ON/OFF the real-time logging facility. When this option is
 ON, log messages from processing are sent back as they come, instead of
 being sent back at the end in one go. This may help debugging or monitoring
 in some cases, but, depending on the amount of log, it may have significant
 consequencies on the load over the network, so it must be used with care.
Int_t SetParallelSilent(Int_t nodes, Bool_t random = kFALSE)
 Tell PROOF how many slaves to use in parallel. If random is TRUE a random
 selection is done (if nodes is less than the available nodes).
 Returns the number of parallel slaves. Returns -1 in case of error.
Int_t SetParallel(Int_t nodes = -1, Bool_t random = kFALSE)
 Tell PROOF how many slaves to use in parallel. Returns the number of
 parallel slaves. Returns -1 in case of error.
Int_t GoMoreParallel(Int_t nWorkersToAdd)
 Add nWorkersToAdd workers to current list of workers. This function is
 works on the master only, and only when an analysis is ongoing. A message
 is sent back to the client when we go "more" parallel.
 Returns -1 on error, number of total (not added!) workers on success.
Int_t GoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE)
 Go in parallel mode with at most "nodes" slaves. Since the fSlaves
 list is sorted by slave performace the active list will contain first
 the most performant nodes. Returns the number of active slaves.
 If random is TRUE, and nodes is less than the number of available workers,
 a random selection is done.
 Returns -1 in case of error.
void ShowData()
 List contents of the data directory in the sandbox.
 This is the place where files produced by the client queries are kept
void ClearData(UInt_t what = kUnregistered, const char* dsname = 0)
 Remove files for the data directory.
 The option 'what' can take the values:
     kPurge                 remove all files and directories under '~/data'
     kUnregistered          remove only files not in registered datasets (default)
     kDataset               remove files belonging to dataset 'dsname'
 User is prompt for confirmation, unless kForceClear is ORed with the option
Bool_t Prompt(const char* p)
 Prompt the question 'p' requiring an answer y,Y,n,N
 Return kTRUE is the answer was y or Y, kFALSE in all other cases.
void ClearDataProgress(Int_t r, Int_t t)
 Progress bar for clear data
void ShowCache(Bool_t all = kFALSE)
 List contents of file cache. If all is true show all caches also on
 slaves. If everything is ok all caches are to be the same.
void ClearCache(const char* file = 0)
 Remove file from all file caches. If file is 0 or "" or "*", remove all
 the files
void SystemCmd(const char* cmd, Int_t fdout)
 Exec system command 'cmd'. If fdout > -1, append the output to fdout.
void ShowPackages(Bool_t all = kFALSE, Bool_t redirlog = kFALSE)
 List contents of package directory. If all is true show all package
 directories also on slaves. If everything is ok all package directories
 should be the same. If redir is kTRUE the result is redirected to the log
 file (option available for internal actions).
void ShowEnabledPackages(Bool_t all = kFALSE)
 List which packages are enabled. If all is true show enabled packages
 for all active slaves. If everything is ok all active slaves should
 have the same packages enabled.
Int_t ClearPackages()
 Remove all packages.
 Returns 0 in case of success and -1 in case of error.
Int_t ClearPackage(const char* package)
 Remove a specific package.
 Returns 0 in case of success and -1 in case of error.
Int_t DisablePackage(const char* package)
 Remove a specific package.
 Returns 0 in case of success and -1 in case of error.
Int_t DisablePackageOnClient(const char* package)
 Remove a specific package 'pack' from the client.
 Returns 0 in case of success and -1 in case of error.
Int_t DisablePackages()
 Remove all packages.
 Returns 0 in case of success and -1 in case of error.
Int_t BuildPackage(const char* package, TProof::EBuildPackageOpt opt = kBuildAll, Int_t chkveropt = kCheckROOT, TList* workers = 0)
 Build specified package. Executes the PROOF-INF/BUILD.sh
 script if it exists on all unique nodes. If opt is kBuildOnSlavesNoWait
 then submit build command to slaves, but don't wait
 for results. If opt is kCollectBuildResults then collect result
 from slaves. To be used on the master.
 If opt = kBuildAll (default) then submit and wait for results
 (to be used on the client).
 Returns 0 in case of success and -1 in case of error.
Int_t BuildPackageOnClient(const char* package, Int_t opt = 0, TString* path = 0, Int_t chkveropt = kCheckROOT)
 Build specified package on the client. Executes the PROOF-INF/BUILD.sh
 script if it exists on the client.
 If opt == 0, both the preparation and building phases are run.
 If opt == 1, only the preparation phase (asserting and, eventually, downloading
              of the package) is done; '*path' contains the full path to the
              package to be passed in the next call
 If opt == 2, only the building phase is run using *path .
 Returns 0 in case of success and -1 in case of error.
 The code is equivalent to the one in TProofServ.cxx (TProof::kBuildPackage
 case). Keep in sync in case of changes.
Int_t LoadPackage(const char* package, Bool_t notOnClient = kFALSE, TList* loadopts = 0, TList* workers = 0)
 Load specified package. Executes the PROOF-INF/SETUP.C script
 on all active nodes. If notOnClient = true, don't load package
 on the client. The default is to load the package also on the client.
 The argument 'loadopts' specify a list of objects to be passed to the SETUP.
 The objects in the list must be streamable; the SETUP macro will be executed
 like this: SETUP.C(loadopts).
 Returns 0 in case of success and -1 in case of error.
Int_t LoadPackageOnClient(const char* package, TList* loadopts = 0)
 Load specified package in the client. Executes the PROOF-INF/SETUP.C
 script on the client. Returns 0 in case of success and -1 in case of error.
 The code is equivalent to the one in TProofServ.cxx (TProof::kLoadPackage
 case). Keep in sync in case of changes.
 The argument 'loadopts' specify a list of objects to be passed to the SETUP.
 The objects in the list must be streamable; the SETUP macro will be executed
 like this: SETUP.C(loadopts).
 Returns 0 in case of success and -1 in case of error.
Int_t UnloadPackage(const char* package)
 Unload specified package.
 Returns 0 in case of success and -1 in case of error.
Int_t UnloadPackageOnClient(const char* package)
 Unload a specific package on the client.
 Returns 0 in case of success and -1 in case of error.
 The code is equivalent to the one in TProofServ.cxx (TProof::UnloadPackage
 case). Keep in sync in case of changes.
Int_t UnloadPackages()
 Unload all packages.
 Returns 0 in case of success and -1 in case of error.
Int_t EnablePackage(const char* package, Bool_t notOnClient = kFALSE, TList* workers = 0)
 Enable specified package. Executes the PROOF-INF/BUILD.sh
 script if it exists followed by the PROOF-INF/SETUP.C script.
 In case notOnClient = true, don't enable the package on the client.
 The default is to enable packages also on the client.
 If specified, enables packages only on the specified workers.
 Returns 0 in case of success and -1 in case of error.
 Provided for backward compatibility.
Int_t EnablePackage(const char* package, const char* loadopts, Bool_t notOnClient = kFALSE, TList* workers = 0)
 Enable specified package. Executes the PROOF-INF/BUILD.sh
 script if it exists followed by the PROOF-INF/SETUP.C script.
 In case notOnClient = true, don't enable the package on the client.
 The default is to enable packages also on the client.
 It is is possible to specify options for the loading step via 'loadopts';
 the string will be passed passed as argument to SETUP.
 Special option 'chkv=<o>' (or 'checkversion=<o>') can be used to control
 plugin version checking during building: possible choices are:
     off         no check; failure may occur at loading
     on          check ROOT version [default]
     svn         check ROOT version and Git commit SHA1.
 (Use ';', ' ' or '|' to separate 'chkv=<o>' from the rest.)
 If specified, enables packages only on the specified workers.
 Returns 0 in case of success and -1 in case of error.
Int_t EnablePackage(const char* package, TList* loadopts, Bool_t notOnClient = kFALSE, TList* workers = 0)
 Enable specified package. Executes the PROOF-INF/BUILD.sh
 script if it exists followed by the PROOF-INF/SETUP.C script.
 In case notOnClient = true, don't enable the package on the client.
 The default is to enable packages also on the client.
 It is is possible to specify a list of objects to be passed to the SETUP
 functions via 'loadopts'; the objects must be streamable.
 Returns 0 in case of success and -1 in case of error.
Int_t DownloadPackage(const char* par, const char* dstdir = 0)
 Download a PROOF archive (PAR file) from the master package repository.
 The PAR file is downloaded in the current directory or in the directory
 specified by 'dstdir'. If a package with the same name already exists
 at destination, a check on the MD5 sum is done and the user warned or
 prompted for action, depending is the file is equal or different.
 Returns 0 in case of success and -1 in case of error.
Int_t UploadPackage(const char* par, TProof::EUploadPackageOpt opt = kUntar, TList* workers = 0)
 Upload a PROOF archive (PAR file). A PAR file is a compressed
 tar file with one special additional directory, PROOF-INF
 (blatantly copied from Java's jar format). It must have the extension
 .par. A PAR file can be directly a binary or a source with a build
 procedure. In the PROOF-INF directory there can be a build script:
 BUILD.sh to be called to build the package, in case of a binary PAR
 file don't specify a build script or make it a no-op. Then there is
 SETUP.C which sets the right environment variables to use the package,
 like LD_LIBRARY_PATH, etc.
 The 'opt' allows to specify whether the .PAR should be just unpacked
 in the existing dir (opt = kUntar, default) or a remove of the existing
 directory should be executed (opt = kRemoveOld), so triggering a full
 re-build. The option if effective only for PROOF protocol > 8 .
 The lab 'dirlab' (e.g. 'G0') indicates that the package is to uploaded to
 an alternative global directory for global usage. This may require special
 privileges.
 If download is kTRUE and the package is not found locally, then it is downloaded
 from the master repository.
 Returns 0 in case of success and -1 in case of error.
Int_t UploadPackageOnClient(const char* package, TProof::EUploadPackageOpt opt, TMD5* md5)
 Upload a package on the client in ~/.proof/packages.
 The 'opt' allows to specify whether the .PAR should be just unpacked
 in the existing dir (opt = kUntar, default) or a remove of the existing
 directory should be executed (opt = kRemoveOld), thereby triggering a full
 re-build. This option if effective only for PROOF protocol > 8.
 Returns 0 in case of success and -1 in case of error.
Int_t Load(const char* macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE, TList* wrks = 0)
 Load the specified macro on master, workers and, if notOnClient is
 kFALSE, on the client. The macro file is uploaded if new or updated.
 Additional files to be uploaded (or updated, if needed) can be specified
 after a comma, e.g. "mymacro.C+,thisheader.h,thatheader.h".
 If existing in the same directory, a header basename(macro).h or .hh, is also
 uploaded.
 The default is to load the macro also on the client; notOnClient can be used
 to avoid loading on the client.
 On masters, if uniqueWorkers is kTRUE, the macro is loaded on unique workers
 only, and collection is not done; if uniqueWorkers is kFALSE, collection
 from the previous request is done, and broadcasting + collection from the
 other workers is done.
 The wrks arg can be used on the master to limit the set of workers.
 Returns 0 in case of success and -1 in case of error.
Int_t AddDynamicPath(const char* libpath, Bool_t onClient = kFALSE, TList* wrks = 0, Bool_t doCollect = kTRUE)
 Add 'libpath' to the lib path search.
 Multiple paths can be specified at once separating them with a comma or
 a blank.
 Return 0 on success, -1 otherwise
Int_t AddIncludePath(const char* incpath, Bool_t onClient = kFALSE, TList* wrks = 0, Bool_t doCollect = kTRUE)
 Add 'incpath' to the inc path search.
 Multiple paths can be specified at once separating them with a comma or
 a blank.
 Return 0 on success, -1 otherwise
Int_t RemoveDynamicPath(const char* libpath, Bool_t onClient = kFALSE)
 Remove 'libpath' from the lib path search.
 Multiple paths can be specified at once separating them with a comma or
 a blank.
 Return 0 on success, -1 otherwise
Int_t RemoveIncludePath(const char* incpath, Bool_t onClient = kFALSE)
 Remove 'incpath' from the inc path search.
 Multiple paths can be specified at once separating them with a comma or
 a blank.
 Return 0 on success, -1 otherwise
void HandleLibIncPath(const char* what, Bool_t add, const char* dirs)
 Handle lib, inc search paths modification request
TList * GetListOfPackages()
 Get from the master the list of names of the packages available.
TList * GetListOfEnabledPackages()
 Get from the master the list of names of the packages enabled.
void PrintProgress(Long64_t total, Long64_t processed, Float_t procTime = -1., Long64_t bytesread = -1)
 Print a progress bar on stderr. Used in batch mode.
void Progress(Long64_t total, Long64_t processed)
 Get query progress information. Connect a slot to this signal
 to track progress.
void Progress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti)
 Get query progress information. Connect a slot to this signal
 to track progress.
void Progress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti, Int_t actw, Int_t tses, Float_t eses)
 Get query progress information. Connect a slot to this signal
 to track progress.
void Feedback(TList* objs)
 Get list of feedback objects. Connect a slot to this signal
 to monitor the feedback object.
void CloseProgressDialog()
 Close progress dialog.
void ResetProgressDialog(const char* sel, Int_t sz, Long64_t fst, Long64_t ent)
 Reset progress dialog.
void StartupMessage(const char* msg, Bool_t status, Int_t done, Int_t total)
 Send startup message.
void DataSetStatus(const char* msg, Bool_t status, Int_t done, Int_t total)
 Send dataset preparation status.
void SendDataSetStatus(const char* msg, UInt_t n, UInt_t tot, Bool_t st)
 Send or notify data set status
void QueryResultReady(const char* ref)
 Notify availability of a query result.
void ValidateDSet(TDSet* dset)
 Validate a TDSet.
void AddInputData(TObject* obj, Bool_t push = kFALSE)
 Add data objects that might be needed during the processing of
 the selector (see Process()). This object can be very large, so they
 are distributed in an optimized way using a dedicated file.
 If push is TRUE the input data are sent over even if no apparent change
 occured to the list.
void ClearInputData(TObject* obj = 0)
 Remove obj form the input data list; if obj is null (default), clear the
 input data info.
void ClearInputData(const char* name)
 Remove obj 'name' form the input data list;
void SetInputDataFile(const char* datafile)
 Set the file to be used to optimally distribute the input data objects.
 If the file exists the object in the file are added to those in the
 fInputData list. If the file path is null, a default file will be created
 at the moment of sending the processing request with the content of
 the fInputData list. See also SendInputDataFile.
void SendInputDataFile()
 Send the input data objects to the master; the objects are taken from the
 dedicated list and / or the specified file.
 If the fInputData is empty the specified file is sent over.
 If there is no specified file, a file named "inputdata.root" is created locally
 with the content of fInputData and sent over to the master.
 If both fInputData and the specified file are not empty, a copy of the file
 is made locally and augmented with the content of fInputData.
void PrepareInputDataFile(TString& dataFile)
 Prepare the file with the input data objects to be sent the master; the
 objects are taken from the dedicated list and / or the specified file.
 If the fInputData is empty the specified file is sent over.
 If there is no specified file, a file named "inputdata.root" is created locally
 with the content of fInputData and sent over to the master.
 If both fInputData and the specified file are not empty, a copy of the file
 is made locally and augmented with the content of fInputData.
void AddInput(TObject* obj)
 Add objects that might be needed during the processing of
 the selector (see Process()).
void ClearInput()
 Clear input object list.
TList * GetInputList()
 Get input list.
TObject * GetOutput(const char* name)
 Get specified object that has been produced during the processing
 (see Process()).
TObject * GetOutput(const char* name, TList* out)
 Find object 'name' in list 'out' or in the files specified in there
TList * GetOutputList()
 Get list with all object created during processing (see Process()).
void SetParameter(const char* par, const char* value)
 Set input list parameter. If the parameter is already
 set it will be set to the new value.
void SetParameter(const char* par, Int_t value)
 Set an input list parameter.
void SetParameter(const char* par, Long_t value)
 Set an input list parameter.
void SetParameter(const char* par, Long64_t value)
 Set an input list parameter.
void SetParameter(const char* par, Double_t value)
 Set an input list parameter.
TObject * GetParameter(const char* par) const
 Get specified parameter. A parameter set via SetParameter() is either
 a TParameter or a TNamed or 0 in case par is not defined.
void DeleteParameters(const char* wildcard)
 Delete the input list parameters specified by a wildcard (e.g. PROOF_*)
 or exact name (e.g. PROOF_MaxSlavesPerNode).
void ShowParameters(const char* wildcard = "PROOF_*") const
 Show the input list parameters specified by the wildcard.
 Default is the special PROOF control parameters (PROOF_*).
void AddFeedback(const char* name)
 Add object to feedback list.
void RemoveFeedback(const char* name)
 Remove object from feedback list.
void ClearFeedback()
 Clear feedback list.
void ShowFeedback() const
 Show items in feedback list.
TList * GetFeedbackList() const
 Return feedback list.
TTree * GetTreeHeader(TDSet* tdset)
 Creates a tree header (a tree with nonexisting files) object for
 the DataSet.
TDrawFeedback * CreateDrawFeedback()
 Draw feedback creation proxy. When accessed via TProof avoids
 link dependency on libProofPlayer.
void SetDrawFeedbackOption(TDrawFeedback* f, Option_t* opt)
 Set draw feedback option.
void DeleteDrawFeedback(TDrawFeedback* f)
 Delete draw feedback object.
TList * GetOutputNames()
   FIXME: to be written
void Browse(TBrowser* b)
 Build the PROOF's structure in the browser.
void SetPlayer(TVirtualProofPlayer* player)
 Set a new PROOF player.
TVirtualProofPlayer * MakePlayer(const char* player = 0, TSocket* s = 0)
 Construct a TProofPlayer object. The player string specifies which
 player should be created: remote, slave, sm (supermaster) or base.
 Default is remote. Socket is needed in case a slave player is created.
void AddChain(TChain* chain)
 Add chain to data set
void RemoveChain(TChain* chain)
 Remove chain from data set
void GetLog(Int_t start = -1, Int_t end = -1)
 Ask for remote logs in the range [start, end]. If start == -1 all the
 messages not yet received are sent back.
TMacro * GetLastLog()
 Fill a TMacro with the log lines since the last reading (fLogFileR)
 Return (TMacro *)0 if no line was logged.
 The returned TMacro must be deleted by the caller.
void PutLog(TQueryResult* qr)
 Display log of query pq into the log window frame
void ShowLog(const char* queryref)
 Display on screen the content of the temporary log file for query
 in reference
void ShowLog(Int_t qry = -1)
 Display on screen the content of the temporary log file.
 If qry == -2 show messages from the last (current) query.
 If qry == -1 all the messages not yet displayed are shown (default).
 If qry == 0, all the messages in the file are shown.
 If qry  > 0, only the messages related to query 'qry' are shown.
 For qry != -1 the original file offset is restored at the end
void cd(Int_t id = -1)
 Set session with 'id' the default one. If 'id' is not found in the list,
 the current session is set as default
void Detach(Option_t* opt = "")
 Detach this instance to its proofserv.
 If opt is 'S' or 's' the remote server is shutdown
void SetAlias(const char* alias = "")
 Set an alias for this session. If reconnection is supported, the alias
 will be communicated to the remote coordinator so that it can be recovered
 when reconnecting
Int_t UploadDataSet(const char* , TList* , const char* = 0, Int_t = 0, TList* = 0)
 *** This function is deprecated and will disappear in future versions ***
 *** It is just a wrapper around TFile::Cp.
 *** Please use TProofMgr::UploadFiles.

 Upload a set of files and save the list of files by name dataSetName.
 The 'files' argument is a list of TFileInfo objects describing the files
 as first url.
 The mask 'opt' is a combination of EUploadOpt:
   kAppend             (0x1)   if set true files will be appended to
                               the dataset existing by given name
   kOverwriteDataSet   (0x2)   if dataset with given name exited it
                               would be overwritten
   kNoOverwriteDataSet (0x4)   do not overwirte if the dataset exists
   kOverwriteAllFiles  (0x8)   overwrite all files that may exist
   kOverwriteNoFiles   (0x10)  overwrite none
   kAskUser            (0x0)   ask user before overwriteng dataset/files
 The default value is kAskUser.
 The user will be asked to confirm overwriting dataset or files unless
 specified opt provides the answer!
 If kOverwriteNoFiles is set, then a pointer to TList must be passed as
 skippedFiles argument. The function will add to this list TFileInfo
 objects describing all files that existed on the cluster and were
 not uploaded.

 Communication Summary
 Client                             Master
    |------------>DataSetName----------->|
    |<-------kMESS_OK/kMESS_NOTOK<-------| (Name OK/file exist)
 (*)|-------> call RegisterDataSet ------->|
 (*) - optional
Int_t UploadDataSet(const char* , const char* , const char* = 0, Int_t = 0, TList* = 0)
 *** This function is deprecated and will disappear in future versions ***
 *** It is just a wrapper around TFile::Cp.
 *** Please use TProofMgr::UploadFiles.

 Upload a set of files and save the list of files by name dataSetName.
 The mask 'opt' is a combination of EUploadOpt:
   kAppend             (0x1)   if set true files will be appended to
                               the dataset existing by given name
   kOverwriteDataSet   (0x2)   if dataset with given name exited it
                               would be overwritten
   kNoOverwriteDataSet (0x4)   do not overwirte if the dataset exists
   kOverwriteAllFiles  (0x8)   overwrite all files that may exist
   kOverwriteNoFiles   (0x10)  overwrite none
   kAskUser            (0x0)   ask user before overwriteng dataset/files
 The default value is kAskUser.
 The user will be asked to confirm overwriting dataset or files unless
 specified opt provides the answer!
 If kOverwriteNoFiles is set, then a pointer to TList must be passed as
 skippedFiles argument. The function will add to this list TFileInfo
 objects describing all files that existed on the cluster and were
 not uploaded.

Int_t UploadDataSetFromFile(const char* , const char* , const char* = 0, Int_t = 0, TList* = 0)
 *** This function is deprecated and will disappear in future versions ***
 *** It is just a wrapper around TFile::Cp.
 *** Please use TProofMgr::UploadFiles.

 Upload files listed in "file" to PROOF cluster.
 Where file = name of file containing list of files and
 dataset = dataset name and opt is a combination of EUploadOpt bits.
 Each file description (line) can include wildcards.
 Check TFileInfo compatibility
Bool_t RegisterDataSet(const char* name, TFileCollection* dataset, const char* optStr = "")
 Register the 'dataSet' on the cluster under the current
 user, group and the given 'dataSetName'.
 If a dataset with the same name already exists the action fails unless 'opts'
 contains 'O', in which case the old dataset is overwritten, or contains 'U',
 in which case 'newDataSet' is added to the existing dataset (duplications are
 ignored, if any).
 If 'opts' contains 'V' the dataset files are also verified (if the dataset manager
 is configured to allow so). By default the dataset is not verified.
 If 'opts' contains 'T' the in the dataset object (status bits, meta,...)
 is trusted, i.e. not reset (if the dataset manager is configured to allow so).
 If 'opts' contains 'S' validation would be run serially (meaningful only if
 validation is required).
 Returns kTRUE on success.
Int_t SetDataSetTreeName(const char* dataset, const char* treename)
 Set/Change the name of the default tree. The tree name may contain
 subdir specification in the form "subdir/name".
 Returns 0 on success, -1 otherwise.
TMap * GetDataSets(const char* uri = "", const char* optStr = "")
 Lists all datasets that match given uri.
 The 'optStr' can contain a comma-separated list of servers for which the
 information is wanted. If ':lite:' (case insensitive) is specified in 'optStr'
 only the global information in the TFileCollection is retrieved; useful to only
 get the list of available datasets.
void ShowDataSets(const char* uri = "", const char* optStr = "")
 Shows datasets in locations that match the uri.
 By default shows the user's datasets and global ones
Bool_t ExistsDataSet(const char* dataset)
 Returns kTRUE if 'dataset' exists, kFALSE otherwise
void ClearDataSetCache(const char* dataset = 0)
 Clear the content of the dataset cache, if any (matching 'dataset', if defined).
void ShowDataSetCache(const char* dataset = 0)
 Display the content of the dataset cache, if any (matching 'dataset', if defined).
TFileCollection * GetDataSet(const char* dataset, const char* optStr = "")
 Get a list of TFileInfo objects describing the files of the specified
 dataset.
 To get the short version (containing only the global meta information)
 specify optStr = "S:" or optStr = "short:".
 To get the sub-dataset of files located on a given server(s) specify
 the list of servers (comma-separated) in the 'optStr' field.
void ShowDataSet(const char* dataset = "", const char* opt = "filter:SsCc")
 display meta-info for given dataset usi
Int_t RemoveDataSet(const char* dataset, const char* optStr = "")
 Remove the specified dataset from the PROOF cluster.
 Files are not deleted.
TList* FindDataSets(const char* searchString, const char* optStr = "")
 Find datasets, returns in a TList all found datasets.
Bool_t RequestStagingDataSet(const char* dataset)
 Allows users to request staging of a particular dataset. Requests are
 saved in a special dataset repository and must be honored by the endpoint.
Bool_t CancelStagingDataSet(const char* dataset)
 Cancels a dataset staging request. Returns kTRUE on success, kFALSE on
 failure. Dataset not found equals to a failure.
TFileCollection * GetStagingStatusDataSet(const char* dataset)
 Obtains a TFileCollection showing the staging status of the specified
 dataset. A valid dataset manager and dataset staging requests repository
 must be present on the endpoint.
void ShowStagingStatusDataSet(const char* dataset, const char* optStr = "filter:SsCc")
 Like GetStagingStatusDataSet, but displays results immediately.
Int_t VerifyDataSet(const char* dataset, const char* optStr = "")
 Verify if all files in the specified dataset are available.
 Print a list and return the number of missing files.
 Returns -1 in case of error.
Int_t VerifyDataSetParallel(const char* uri, const char* optStr)
 Internal function for parallel dataset verification used TProof::VerifyDataSet and
 TProofLite::VerifyDataSet
TMap * GetDataSetQuota(const char* optStr = "")
 returns a map of the quotas of all groups
void ShowDataSetQuota(Option_t* opt = 0)
 shows the quota and usage of all groups
 if opt contains "U" shows also distribution of usage on user-level
void InterruptCurrentMonitor()
 If in active in a monitor set ready state
Int_t ActivateWorker(const char* ord, Bool_t save = kTRUE)
 Make sure that the worker identified by the ordinal number 'ord' is
 in the active list. The request will be forwarded to the master
 in direct contact with the worker. If needed, this master will move
 the worker from the inactive to the active list and rebuild the list
 of unique workers.
 Use ord = "*" to activate all inactive workers.
 The string 'ord' can also be a comma-separated list of ordinal numbers the
 status of which will be modified at once.
 Return <0 if something went wrong (-2 if at least one worker was not found)
 or the number of workers with status change (on master; 0 on client).
Int_t DeactivateWorker(const char* ord, Bool_t save = kTRUE)
 Remove the worker identified by the ordinal number 'ord' from the
 the active list. The request will be forwarded to the master
 in direct contact with the worker. If needed, this master will move
 the worker from the active to the inactive list and rebuild the list
 of unique workers.
 Use ord = "*" to deactivate all active workers.
 The string 'ord' can also be a comma-separated list of ordinal numbers the
 status of which will be modified at once.
 Return <0 if something went wrong (-2 if at least one worker was not found)
 or the number of workers with status change (on master; 0 on client).
Int_t ModifyWorkerLists(const char* ord, Bool_t add, Bool_t save)
 Modify the worker active/inactive list by making the worker identified by
 the ordinal number 'ord' active (add == TRUE) or inactive (add == FALSE).
 The string 'ord' can also be a comma-separated list of ordinal numbers the
 status of which will be modified at once.
 If needed, the request will be forwarded to the master in direct contact
 with the worker. The end-master will move the worker from one list to the
 other active and rebuild the list of unique active workers.
 Use ord = "*" to deactivate all active workers.
 If save is TRUE the current active list is saved before any modification is
 done; re-running with ord = "restore" restores the saved list
 Return <0 if something went wrong (-2 if at least one worker was not found)
 or the number of workers with status change (on master; 0 on client).
void SaveActiveList()
 Save current list of active workers
Int_t RestoreActiveList()
 Restore saved list of active workers
TProof * Open(const char* url = 0, const char* conffile = 0, const char* confdir = 0, Int_t loglevel = 0)
 Start a PROOF session on a specific cluster. If cluster is 0 (the
 default) then the PROOF Session Viewer GUI pops up and 0 is returned.
 If cluster is "lite://" we start a PROOF-lite session.
 If cluster is "" (empty string) then we connect to the cluster specified
 by 'Proof.LocalDefault', defaulting to "lite://".
 If cluster is "pod://" (case insensitive), then we connect to a PROOF cluster
 managed by PROOF on Demand (PoD, http://pod.gsi.de ).
 Via conffile a specific PROOF config file in the confir directory can be specified.
 Use loglevel to set the default loging level for debugging.
 The appropriate instance of TProofMgr is created, if not
 yet existing. The instantiated TProof object is returned.
 Use TProof::cd() to switch between PROOF sessions.
 For more info on PROOF see the TProof ctor.
TProofMgr * Mgr(const char* url)
 Get instance of the effective manager for 'url'
 Return 0 on failure.
void Reset(const char* url, Bool_t hard = kFALSE)
 Wrapper around TProofMgr::Reset(...).
const TList * GetEnvVars()
 Get environemnt variables.
void AddEnvVar(const char* name, const char* value)
 Add an variable to the list of environment variables passed to proofserv
 on the master and slaves
void DelEnvVar(const char* name)
 Remove an variable from the list of environment variables passed to proofserv
 on the master and slaves
void ResetEnvVars()
 Clear the list of environment variables passed to proofserv
 on the master and slaves
void SaveWorkerInfo()
 Save information about the worker set in the file .workers in the working
 dir. Called each time there is a change in the worker setup, e.g. by
 TProof::MarkBad().
Int_t GetParameter(TCollection* c, const char* par, TString& value)
 Get the value from the specified parameter from the specified collection.
 Returns -1 in case of error (i.e. list is 0, parameter does not exist
 or value type does not match), 0 otherwise.
Int_t GetParameter(TCollection* c, const char* par, Int_t& value)
 Get the value from the specified parameter from the specified collection.
 Returns -1 in case of error (i.e. list is 0, parameter does not exist
 or value type does not match), 0 otherwise.
Int_t GetParameter(TCollection* c, const char* par, Long_t& value)
 Get the value from the specified parameter from the specified collection.
 Returns -1 in case of error (i.e. list is 0, parameter does not exist
 or value type does not match), 0 otherwise.
Int_t GetParameter(TCollection* c, const char* par, Long64_t& value)
 Get the value from the specified parameter from the specified collection.
 Returns -1 in case of error (i.e. list is 0, parameter does not exist
 or value type does not match), 0 otherwise.
Int_t GetParameter(TCollection* c, const char* par, Double_t& value)
 Get the value from the specified parameter from the specified collection.
 Returns -1 in case of error (i.e. list is 0, parameter does not exist
 or value type does not match), 0 otherwise.
Int_t AssertDataSet(TDSet* dset, TList* input, TDataSetManager* mgr, TString& emsg)
 Make sure that dataset is in the form to be processed. This may mean
 retrieving the relevant info from the dataset manager or from the
 attached input list.
 Returns 0 on success, -1 on error
Int_t SaveInputData(TQueryResult* qr, const char* cachedir, TString& emsg)
 Save input data file from 'cachedir' into the sandbox or create a the file
 with input data objects
Int_t SendInputData(TQueryResult* qr, TProof* p, TString& emsg)
 Send the input data file to the workers
Int_t GetInputData(TList* input, const char* cachedir, TString& emsg)
 Get the input data from the file defined in the input list
void LogViewer(const char* url = 0, Int_t sessionidx = 0)
 Start the log viewer window usign the plugin manager
void SetProgressDialog(Bool_t on = kTRUE)
 Enable/Disable the graphic progress dialog.
 By default the dialog is enabled
void ShowMissingFiles(TQueryResult* qr = 0)
 Show information about missing files during query described by 'qr' or the
 last query if qr is null (default).
 A short summary is printed in the end.
TFileCollection * GetMissingFiles(TQueryResult* qr = 0)
 Get a TFileCollection with the files missing in the query described by 'qr'
 or the last query if qr is null (default).
 Return a null pointer if none were found, for whatever reason.
 The caller is responsible for the returned object.
void SetPerfTree(const char* pf = "perftree.root", Bool_t withWrks = kFALSE)
 Enable/Disable saving of the performance tree
Int_t SavePerfTree(const char* pf = 0, const char* qref = 0)
 Save performance information from TPerfStats to file 'pf'.
 If 'ref' is defined, do it for query 'ref'.
 Return 0 on sucecss, -1 in case of any error
TProofInterruptHandler& operator=(const TProof& )
Int_t GetPort()
{ return fPort; }
TProof(const TProof& )
Int_t Broadcast(const TMessage& mess, TList* slaves)
Int_t Broadcast(const TMessage &mess, ESlaves list = kActive)
TList * GetListOfSlaves() const
{ return fSlaves; }
TList * GetListOfInactiveSlaves() const
{ return fInactiveSlaves; }
TList * GetListOfUniqueSlaves() const
{ return fUniqueSlaves; }
TList * GetListOfBadSlaves() const
{ return fBadSlaves; }
Bool_t IsEndMaster() const
{ return fEndMaster; }
Bool_t IsSync() const
{ return fSync; }
void SetRunStatus(TProof::ERunStatus rst)
{ fRunStatus = rst; }
void ResetMergers()
void FinalizationDone()
TList * GetDataSetSrvMaps(const TString& srvmaps)
TVirtualProofPlayer * GetPlayer() const
{ return fPlayer; }
TList * GetListOfActiveSlaves() const
{ return fActiveSlaves; }
TList * GetEnabledPackages() const
void SetDSet(TDSet* dset)
{ fDSet = dset; }
TPluginHandler * GetProgressDialog() const
{ return fProgressDialog; }
void * SlaveStartupThread(void* arg)
const char * GetMaster() const
{ return fMaster; }
const char * GetConfDir() const
{ return fConfDir; }
const char * GetConfFile() const
{ return fConfFile; }
const char * GetUser() const
{ return fUrl.GetUser(); }
const char * GetGroup() const
{ return fGroup; }
const char * GetWorkDir() const
{ return fWorkDir; }
const char * GetSessionTag() const
{ return GetName(); }
const char * GetImage() const
{ return fImage; }
const char * GetUrl()
{ return fUrl.GetUrl(); }
Int_t GetRemoteProtocol() const
{ return fProtocol; }
Int_t GetClientProtocol() const
{ return kPROOF_Protocol; }
Int_t GetStatus() const
{ return fStatus; }
Int_t GetLogLevel() const
{ return fLogLevel; }
Int_t GetSeqNum() const
{ return fSeqNum; }
Int_t GetSessionID() const
{ return fSessionID; }
Bool_t UseDynamicStartup() const
{ return fDynamicStartup; }
EQueryMode GetQueryMode(Option_t* mode = 0) const
Long64_t GetBytesRead() const
{ return fBytesRead; }
Float_t GetRealTime() const
{ return fRealTime; }
Float_t GetCpuTime() const
{ return fCpuTime; }
Bool_t IsLite() const
{ return (fServType == TProofMgr::kProofLite) ? kTRUE : kFALSE; }
Bool_t IsProofd() const
{ return (fServType == TProofMgr::kProofd) ? kTRUE : kFALSE; }
Bool_t IsFolder() const
{ return kTRUE; }
Bool_t IsMaster() const
{ return fMasterServ; }
Bool_t IsValid() const
{ return fValid; }
Bool_t IsTty() const
{ return fTty; }
Bool_t IsParallel() const
{ return GetParallel() > 0 ? kTRUE : kFALSE; }
Bool_t IsIdle() const
{ return (fNotIdle <= 0) ? kTRUE : kFALSE; }
Bool_t IsWaiting() const
{ return fIsWaiting; }
ERunStatus GetRunStatus() const
{ return fRunStatus; }
TList * GetLoadedMacros() const
{ return fLoadedMacros; }
Int_t GetNumberOfDrawQueries()
{ return fDrawQueries; }
void SetActive(Bool_t = kTRUE)
{ }
Bool_t SendingLogToWindow() const
{ return fLogToWindowOnly; }
void SendLogToWindow(Bool_t mode)
{ fLogToWindowOnly = mode; }
TMacro * GetMacroLog()
{ return &fMacroLog; }
void ResetProgressDialogStatus()
TProofMgr * GetManager()
{ return fManager; }
const char * GetDataPoolUrl() const
{ return fManager ? fManager->GetMssUrl() : 0; }
void SetDataPoolUrl(const char* url)
{ if (fManager) fManager->SetMssUrl(url); }
void SetPrintProgress(PrintProgress_t pp)
{ fPrintProgress = pp; }