TProof

class TProof : public TObject

    private:

      TProof TProof()
      TProof TProof(TProof&)
       Int_t Collect(TMonitor* mon)
        void ConnectFiles()
        void GetStatus()
        void GetUserInfo()
       Int_t Init(char* cluster, char* service, char* master, char* vers, Int_t loglevel, char* confdir)
        void Limits(TSocket* s, TMessage& mess)
        void MarkBad(TSlave* sl)
        void MarkBad(TSocket* s)
        void operator=(TProof&)
       Int_t SendGroupView()
       Int_t SendInitialState()

    public:

               TProof TProof(char* cluster, char* master = pcna49a.cern.ch, char* vers = kPROOF_Version, char* service = proofslave, Int_t loglevel = 1, char* confdir = /usr/proof)
         virtual void ~TProof()
               Bool_t Active()
                Int_t Broadcast(TMessage& mess, TProof::ESlaves list = kActive)
                Int_t Broadcast(char* mess, Int_t kind = kMESS_STRING, TProof::ESlaves list = kActive)
                Int_t Broadcast(Int_t kind, TProof::ESlaves list = kActive)
              TClass* Class()
         virtual void Close(Option_t* option)
                Int_t Collect(TProof::ESlaves list = kActive)
                Int_t Collect(TSlave* sl)
                Int_t ConnectFile(TFile* file)
                Int_t DisConnectFile(TFile* file)
              TSlave* FindSlave(TSocket* s)
             Double_t GetBytesRead()
          const char* GetClusterName()
          const char* GetConfDir()
          const char* GetConfFile()
              Float_t GetCpuTime()
               TList* GetListOfActiveSlaves()
               TList* GetListOfBadSlaves()
               TList* GetListOfSlaves()
                Int_t GetLogLevel()
          const char* GetMaster()
                Int_t GetNumberOfActiveSlaves()
                Int_t GetNumberOfBadSlaves()
                Int_t GetNumberOfSlaves()
                Int_t GetProtocol()
              Float_t GetRealTime()
          const char* GetService()
          const char* GetUser()
          const char* GetVersion()
                 void Interrupt(TProof::EUrgent type, TProof::ESlaves list = kActive)
      virtual TClass* IsA()
               Bool_t IsMaster()
               Bool_t IsValid()
                 void Loop(TTree* tree)
                Int_t Ping(TProof::ESlaves list = kActive)
         virtual void Print(Option_t* option)
                 void RecvLogFile(TSocket* s)
                Int_t SendCommand(char* cmd, TProof::ESlaves list = kActive)
                Int_t SendCurrentState(TProof::ESlaves list = kActive)
                Int_t SendObject(TObject* obj, TProof::ESlaves list = kActive)
                 void SetLogLevel(Int_t level)
                Int_t SetParallel(Int_t nodes = 9999)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)

  Data Members
    private:

        TString fCluster        name of cluster, name will be used to find config file
        TString fService        service we are connected to, either "proofserv" or "proofslave"
        TString fMaster         name of master server (in case of "proofserv")
        TString fVersion        proof server major version
        TString fConfDir        directory containing cluster config information
        TString fConfFile       file containing config information
        TString fUser           user under which to run
        TString fPasswd         user password
          Int_t fProtocol       protocol level
          Int_t fLogLevel       server debug logging level
         Bool_t fMasterServ     true if we are a master server
         TList* fSlaves         list of all slave servers as in config file
         TList* fActiveSlaves   list of active slaves (subset of all slaves)
         TList* fBadSlaves      dead slaves (subset of all slaves)
      TMonitor* fAllMonitor     monitor activity on all valid slave sockets
      TMonitor* fActiveMonitor  monitor activity on all active slave sockets
       Double_t fBytesRead      bytes read by all slaves during the session
        Float_t fRealTime       realtime spent by all slaves during the session
        Float_t fCpuTime        CPU time spent by all slaves during the session
         TTree* fTree           Object being PROOFed
          Int_t fLimits         Used by Limits()

    public:

      static const TProof::ESlaves kAll                
      static const TProof::ESlaves kActive             
      static const TProof::EUrgent kHardInterrupt      
      static const TProof::EUrgent kSoftInterrupt      
      static const TProof::EUrgent kShutdownInterrupt  

Class Description

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

 Create a PROOF environment. Starting PROOF involves reading a config
 file describing the cluster and firing slave servers on all of the
 available nodes.

 Clean up PROOF environment.

 Start the PROOF environment. Starting PROOF involves reading a config
 file describing the cluster and firing slave servers on all of the
 available nodes.

 Send message to all slaves to connect "file". This method is
 called by the TFile ctor (no user method).

 Tell all servers to open all files currently opened by the client.

 Close all open slave servers.

 Send message to all slaves to disconnect "file". This method is
 called by the TFile::Close() (no user method).

 Find slave that has TSocket s. Returns 0 in case slave is not found.

 Get user info: user name and password. This info is needed to validate
 the user on the PROOF cluster.

 Return number of slaves as described in the config file.

 Return number of active slaves, i.e. slaves that are valid and in
 the current computing group.

 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.

 Get the status of the slaves.

 Send interrupt OOB byte to master or slave servers.

 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 send to.

 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 send to.

 Collect responses from slave sl. Returns the number of slaves that
 responded (=1).

 Collect responses from the slave servers. Returns the number of slaves
 that responded.

 Collect responses from the slave servers. Returns the number of slaves
 that responded.

 Calculate histogram limits after TTree::fEstimate entries have
 been processed.
 This function is called via Collect() in response to a kPROOF_LIMITS
 message send from a PROOF slave in TTree::TakeEstimate().

 Handle message comming from the remote TTree method currently being
 executed.

 Add a bad slave server to the bad slave list and remove it from
 the active list and from the two monitor objects.

 Add slave with socket s to the bad slave list and remove if from
 the active list and from the two monitor objects.

 Ping PROOF slaves. Returns the number of slaves that responded.

 Print status of PROOF cluster.

 Receive the log file of the slave with socket s.

 Send to all active slaves servers the current slave group size
 and their unique id. Returns number of active slaves.

 Send command to be executed on the PROOF master and/or slaves.
 Command can be any legal command line command.

 Transfer the current state of the master to the active slave servers
 just before starting the TTree loop. The current state includes: the
 current working directory, TChain defintion, MaxVirtualSize, Selector,
 etc.

 Transfer the initial (i.e. current) state of the master to all
 slave servers. The initial state includes: log level, currently open
 files.

 Send object to master or slave servers. Returns number slaves message
 was sent too, 0 in case of error.

 Set server logging level.

 Set the number of nodes that should work in parallel. Since the fSlaves
 list is sorted by slave performace the active list will contain first
 the most performant nodes.

 Static function that returns kTRUE in case a PROOF connection exists
 with more than 1 active slave. When only one active slave we run in
 sequential mode.

Inline Functions

             TProof TProof(TProof&)
               void operator=(TProof&)
             TProof TProof(char* cluster, char* master = pcna49a.cern.ch, char* vers = kPROOF_Version, char* service = proofslave, Int_t loglevel = 1, char* confdir = /usr/proof)
        const char* GetClusterName()
        const char* GetService()
        const char* GetMaster()
        const char* GetConfDir()
        const char* GetConfFile()
        const char* GetUser()
        const char* GetVersion()
              Int_t GetProtocol()
              Int_t GetLogLevel()
             TList* GetListOfActiveSlaves()
             TList* GetListOfSlaves()
             TList* GetListOfBadSlaves()
           Double_t GetBytesRead()
            Float_t GetRealTime()
            Float_t GetCpuTime()
             Bool_t IsMaster()
             Bool_t IsValid()
              Int_t Broadcast(Int_t kind, TProof::ESlaves list = kActive)
            TClass* Class()
            TClass* IsA()
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)