ROOT logo
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:
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)
virtual~TProof()
voidTObject::AbstractMethod(const char* method) const
voidActivateWorker(const char* ord)
voidAddChain(TChain* chain)
Int_tAddDynamicPath(const char* libpath, Bool_t onClient = kFALSE, TList* wrks = 0)
static voidAddEnvVar(const char* name, const char* value)
voidAddFeedback(const char* name)
Int_tAddIncludePath(const char* incpath, Bool_t onClient = kFALSE, TList* wrks = 0)
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)
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)
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
voidDeactivateWorker(const char* ord)
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)
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
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)
voidTQObject::EmitVA(const char* signal, Int_t nargs, va_list va)
Int_tEnablePackage(const char* package, Bool_t notOnClient = kFALSE)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
Int_tExec(const char* cmd, Bool_t plusMaster = 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()
static const TList*GetEnvVars()
TList*GetFeedbackList() const
const char*GetGroup() const
virtual const char*TObject::GetIconName() const
const char*GetImage() const
TList*GetInputList()
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
TProofMgr*GetManager()
const char*GetMaster() const
voidGetMaxQueries()
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)
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()
Float_tGetRealTime() const
Int_tGetRemoteProtocol() const
TProof::ERunStatusGetRunStatus() const
Int_tGetSeqNum() const
Int_tGetSessionID() const
const char*GetSessionTag() const
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_tIsValid() const
Bool_tIsWaiting() const
Bool_tTObject::IsZombie() const
Int_tLoad(const char* macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE, TList* wrks = 0)
static voidTQObject::LoadRQ_OBJECT()
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
static TProof*Open(const char* url = 0, const char* conffile = 0, const char* confdir = 0, Int_t loglevel = 0)
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static 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(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(const char* dsetname, const char* 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)
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
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& 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 = 9999, 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)
voidSetPrintProgress(PrintProgress_t pp)
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)
voidShowData()
voidShowDataSet(const char* dataset = "", const char* opt = "M")
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, char* parent)
voidShowPackages(Bool_t all = kFALSE)
voidShowParameters(const char* wildcard = "PROOF_*") const
voidShowQueries(Option_t* opt = "")
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& b)
voidStreamerNVirtual(TBuffer& 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()
Int_tUploadDataSet(const char* dataset, TList* files, const char* dest = 0, Int_t opt = kAskUser, TList* skippedFiles = 0)
Int_tUploadDataSet(const char* dataset, const char* files, const char* dest = 0, Int_t opt = kAskUser, TList* skippedFiles = 0)
Int_tUploadDataSetFromFile(const char* dataset, const char* file, const char* dest = 0, Int_t opt = kAskUser, TList* skippedFiles = 0)
Int_tUploadPackage(const char* par, TProof::EUploadPackageOpt opt = kUntar)
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:
TProof()
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)
Int_tCollect(TList* slaves, Long_t timeout = -1, Int_t endtype = -1)
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)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) 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
virtual void*TQObject::GetSender()
virtual const char*TQObject::GetSenderClassName() const
voidHandleLibIncPath(const char* what, Bool_t add, const char* dirs)
Int_tInit(const char* masterurl, const char* conffile, const char* confdir, Int_t loglevel, const char* alias = 0)
virtual TVirtualProofPlayer*MakePlayer(const char* player = 0, TSocket* s = 0)
voidTObject::MakeZombie()
voidPrepareInputDataFile(TString& dataFile)
Int_tRemoveWorkers(TList* wrks)
static Int_tSaveInputData(TQueryResult* qr, const char* cachedir, TString& emsg)
virtual voidSaveWorkerInfo()
static Int_tSendInputData(TQueryResult* qr, TProof* p, TString& emsg)
virtual voidSendInputDataFile()
voidSetDSet(TDSet* dset)
voidSetPlayer(TVirtualProofPlayer* player)
static void*SlaveStartupThread(void* arg)
virtual Bool_tStartSlaves(Bool_t attach = kFALSE)
voidUpdateDialog()
virtual voidValidateDSet(TDSet* dset)
private:
TProof(const TProof&)
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_tBuildPackageOnClient(const TString& package)
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)
Int_tCollect(TMonitor* mon, Long_t timeout = -1, Int_t endtype = -1)
Int_tCollectInputFrom(TSocket* s, Int_t endtype = -1)
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
voidFindUniqueSlaves()
Int_tGetActiveMergersCount()
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_tGoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE)
Int_tHandleInputMessage(TSlave* wrk, TMessage* m)
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)
Int_tLoadPackageOnClient(const TString& package)
voidMarkBad(TSlave* wrk, const char* reason = 0)
voidMarkBad(TSocket* s, const char* reason = 0)
voidModifyWorkerLists(const char* ord, Bool_t add)
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.)
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_tSendCommand(const char* cmd, TProof::ESlaves list = kActive)
Int_tSendCurrentState(TProof::ESlaves list = kActive)
Int_tSendFile(const char* file, Int_t opt = (kBinary|kForward|kCp|kCpBin), const char* rfile = 0, TSlave* sl = 0)
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)
Int_tUnloadPackage(const char* package)
Int_tUnloadPackageOnClient(const char* package)
Int_tUnloadPackages()
Int_tUploadPackageOnClient(const TString& package, TProof::EUploadPackageOpt opt, TMD5* md5)

Data Members

public:
enum EStatusBits { kUsingSessionGui
kNewInputData
kIsClient
kIsMaster
kIsTopMaster
};
enum EQueryMode { kSync
kAsync
};
enum EUploadOpt { kAppend
kOverwriteDataSet
kNoOverwriteDataSet
kOverwriteAllFiles
kOverwriteNoFiles
kAskUser
};
enum ERegisterOpt { kFailIfExists
kOverwriteIfExists
kMergeIfExists
};
enum EUploadDataSetAnswer { kError
kDataSetExists
kFail
};
enum EUploadPackageOpt { kUntar
kRemoveOld
};
enum ERunStatus { kRunning
kStopped
kAborted
};
enum ESubMerger { kOutputSize
kSendOutput
kBeMerger
kMergerDown
kStopMerging
kOutputSent
};
enum EUrgent { kLocalInterrupt
kPing
kHardInterrupt
kSoftInterrupt
kShutdownInterrupt
};
enum EProofCacheCommands { kShowCache
kClearCache
kShowPackages
kClearPackages
kClearPackage
kBuildPackage
kLoadPackage
kShowEnabledPackages
kShowSubCache
kClearSubCache
kShowSubPackages
kDisableSubPackages
kDisableSubPackage
kBuildSubPackage
kUnloadPackage
kDisablePackage
kUnloadPackages
kDisablePackages
kListPackages
kListEnabledPackages
kLoadMacro
};
enum EProofDataSetCommands { kUploadDataSet
kCheckDataSetName
kGetDataSets
kRegisterDataSet
kGetDataSet
kVerifyDataSet
kRemoveDataSet
kMergeDataSet
kShowDataSets
kGetQuota
kShowQuota
kSetDefaultTreeName
};
enum ESendFileOpt { kAscii
kBinary
kForce
kForward
kCpBin
kCp
};
enum EProofWrkListAction { kActivateWorker
kDeactivateWorker
};
enum EBuildPackageOpt { kDontBuildOnClient
kBuildOnSlavesNoWait
kBuildAll
kCollectBuildResults
};
enum EProofShowQuotaOpt { kPerGroup
kPerUser
};
enum EProofClearData { kPurge
kUnregistered
kDataset
kForceClear
};
enum ESlaves { kAll
kActive
kUnique
kAllUnique
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
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
Int_tfProtocolremote PROOF server protocol version number
TProof::EQueryModefQueryModedefault query mode
TList*fRunningDSetsTemporary datasets used for async running
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
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
private:
TMonitor*fActiveMonitormonitor activity on all active slave sockets
TList*fActiveSlaveslist of active slaves (subset of all slaves)
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
Bool_tfEndMastertrue for a master in direct contact only with workers
TList*fFeedbacklist of names to be returned as feedback
map<TString,TProof::MD5Mod_t,less<TString>,allocator<pair<const TString,TProof::MD5Mod_t> > >fFileMapmap 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_tfIsWaitingtrue if queries have been enqueued
Int_tfLastAssignedMerger
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
TStringfMastermaster server ("" if a master); used in the browser
Int_tfMaxDrawQueriesmax number of draw queries kept
TProofMergePrgfMergePrgMerging progress
TList*fMergers
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
TStringfPackageDirpackage directory (used on client)
TProofLockPath*fPackageLockpackage lock
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_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
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
static TPluginHandler*fgLogViewerLog dialog box plugin
static TList*fgProofEnvListList of TNameds defining environment

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.
~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.
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.
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.
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)
 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 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, ESlaves list)
 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, ESlaves list)
 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 *str, 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 *str, Int_t kind, ESlaves list)
 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, ESlaves list)
 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, ESlaves list)
 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, ESlaves list)
 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, Int_t endtype)
 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, Int_t endtype)
 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)
 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, Int_t endtype)
 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.
void CleanGDirectory(TList* ol)
 Remove links to objects in list 'ol' from gDirectory
Int_t CollectInputFrom(TSocket* s, Int_t endtype = -1)
 Collect and analyze available input from socket s.
 Returns 0 on success, -1 if any failure occurs.
Int_t HandleInputMessage(TSlave* wrk, TMessage* m)
 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)
 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)
 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.
Long64_t Process(TDSet *dset, const char *selector, Option_t *option, Long64_t nentries, Long64_t first)
 Process a data set (TDSet) using the specified selector (.C) file.
 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, Long64_t first)
 Process a data set (TFileCollection) using the specified selector (.C) file.
 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 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.
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) 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 qry, Bool_t force)
 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 *ref, Bool_t force)
 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 qry, const char *path)
 Send retrieve request for the qry-th query in fQueries.
 If path is defined save it to path.
Int_t Retrieve(const char *ref, const char *path)
 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 qry, Bool_t all)
 Send remove request for the qry-th query in fQueries.
Int_t Remove(const char *ref, Bool_t all)
 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 qry, const char *path)
 Send archive request for the qry-th query in fQueries.
Int_t Archive(const char *ref, const char *path)
 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, TProof::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 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.
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 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 = 9999, 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 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 ShowPackages(Bool_t all = kFALSE)
 List contents of package directory. If all is true show all package
 directries also on slaves. If everything is ok all package directories
 should be the same.
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 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)
 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 TString& package)
 Build specified package on the client. Executes the PROOF-INF/BUILD.sh
 script if it exists 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::kBuildPackage
 case). Keep in sync in case of changes.
Int_t LoadPackage(const char* package, Bool_t notOnClient = kFALSE)
 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.
 Returns 0 in case of success and -1 in case of error.
Int_t LoadPackageOnClient(const TString& package)
 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.
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)
 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.
 Returns 0 in case of success and -1 in case of error.
Int_t UploadPackage(const char* par, TProof::EUploadPackageOpt opt = kUntar)
 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 .
 Returns 0 in case of success and -1 in case of error.
Int_t UploadPackageOnClient(const TString& 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. The 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.
 If existing, the corresponding header basename(macro).h or .hh, is also
 uploaded. The default is to load the macro also 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)
 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)
 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.)
 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)
 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()).
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.
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)
 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 *dataSetName, TList *files, const char *desiredDest, Int_t opt, TList *skippedFiles)
 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 *dataSetName, const char *files, const char *desiredDest, Int_t opt, TList *skippedFiles)
 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* dataset, const char* file, const char* dest = 0, Int_t opt = kAskUser, TList* skippedFiles = 0)
 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'.
 Fails if a dataset named 'dataSetName' already exists, unless 'optStr'
 contains 'O', in which case the old dataset is overwritten.
 If 'optStr' contains 'V' the dataset files are verified (default no
 verification).
 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.
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
TFileCollection * GetDataSet(const char* dataset, const char* optStr = "")
 Get a list of TFileInfo objects describing the files of the specified
 dataset.
void ShowDataSet(const char* dataset = "", const char* opt = "M")
 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.
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.
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
void ActivateWorker(const char* ord)
 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.
void DeactivateWorker(const char* ord)
 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.
void ModifyWorkerLists(const char* ord, Bool_t add)
 Modify the worker active/inactive list by making the worker identified by
 the ordinal number 'ord' active (add == TRUE) or inactive (add == FALSE).
 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.
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 "" (empty string) then we connect to a PROOF session
 on the localhost ("proof://localhost"). 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 informations 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
TProofInterruptHandler& operator=(const TProof& )
Int_t GetPort() const
{ 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()
TVirtualProofPlayer * GetPlayer() const
{ return fPlayer; }
TList * GetListOfActiveSlaves() const
{ return fActiveSlaves; }
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); }
Bool_t IsProofd() const
{ return (fServType == TProofMgr::kProofd); }
Bool_t IsFolder() const
{ return kTRUE; }
Bool_t IsMaster() const
{ return fMasterServ; }
Bool_t IsValid() const
{ return fValid; }
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; }
void ResetProgressDialogStatus()
TProofMgr * GetManager()
{ return fManager; }
const char * GetDataPoolUrl() const
{ return fDataPoolUrl; }
void SetDataPoolUrl(const char* url)
{ fDataPoolUrl = url; }
void SetPrintProgress(PrintProgress_t pp)
{ fPrintProgress = pp; }