// @(#)root/proof:$Id$
// Author: G. Ganis, Nov 2005

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofMgr                                                            //
//                                                                      //
// The PROOF manager interacts with the PROOF server coordinator to     //
// create or destroy a PROOF session, attach to or detach from          //
// existing one, and to monitor any client activity on the cluster.     //
// At most one manager instance per server is allowed.                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "Bytes.h"
#include "TError.h"
#include "TEnv.h"
#include "TFile.h"
#include "TFileCollection.h"
#include "TFileInfo.h"
#include "TList.h"
#include "TParameter.h"
#include "TProof.h"
#include "TProofMgr.h"
#include "TProofMgrLite.h"
#include "TSocket.h"
#include "TROOT.h"
#include "TMath.h"

ClassImp(TProofMgr)

// Sub-list of TROOT::fProofs with managers
TList TProofMgr::fgListOfManagers;
TProofMgr_t TProofMgr::fgTXProofMgrHook = 0;

// Auxilliary structures for pinging
// The client request
typedef struct {
   int first;
   int second;
   int third;
   int fourth;
   int fifth;
} clnt_HS_t;
// The body received after the first handshake's header
typedef struct {
   int msglen;
   int protover;
   int msgval;
} srv_HS_t;

//______________________________________________________________________________
TProofMgr::TProofMgr(const char *url, Int_t, const char *alias)
          : TNamed("",""), fRemoteProtocol(-1), fServType(kXProofd),
            fSessions(0), fIntHandler(0)
{
   // Create a PROOF manager for the standard (old) environment.

   fServType = kProofd;

   // AVoid problems with empty URLs
   fUrl = (!url || strlen(url) <= 0) ? TUrl("proof://localhost") : TUrl(url);

   // Correct URL protocol
   if (!strcmp(fUrl.GetProtocol(), TUrl("a").GetProtocol()))
      fUrl.SetProtocol("proof");

   // Check port
   if (fUrl.GetPort() == TUrl("a").GetPort()) {
      // For the time being we use 'rootd' service as default.
      // This will be changed to 'proofd' as soon as XRD will be able to
      // accept on multiple ports
      Int_t port = gSystem->GetServiceByName("proofd");
      if (port < 0) {
         if (gDebug > 0)
            Info("TProofMgr","service 'proofd' not found by GetServiceByName"
                              ": using default IANA assigned tcp port 1093");
         port = 1093;
      } else {
         if (gDebug > 1)
            Info("TProofMgr","port from GetServiceByName: %d", port);
      }
      fUrl.SetPort(port);
   }

   // Check and save the host FQDN ...
   if (strcmp(fUrl.GetHost(), "__lite__")) {
      if (strcmp(fUrl.GetHost(), fUrl.GetHostFQDN()))
         fUrl.SetHost(fUrl.GetHostFQDN());
   }

   SetName(fUrl.GetUrl(kTRUE));
   if (alias)
      SetAlias(alias);
   else
      SetAlias(fUrl.GetHost());
}

//______________________________________________________________________________
TProofMgr::~TProofMgr()
{
   // Destroy a TProofMgr instance

   SafeDelete(fSessions);
   SafeDelete(fIntHandler);

   fgListOfManagers.Remove(this);
   gROOT->GetListOfProofs()->Remove(this);
}

//______________________________________________________________________________
TProof *TProofMgr::AttachSession(Int_t id, Bool_t gui)
{
   // Dummy version provided for completeness. Just returns a pointer to
   // existing session 'id' (as shown by TProof::QuerySessions) or 0 if 'id' is
   // not valid. The boolena 'gui' should be kTRUE when invoked from the GUI.

   TProofDesc *d = GetProofDesc(id);
   if (d)
      return AttachSession(d, gui);

   Info("AttachSession","invalid proofserv id (%d)", id);
   return 0;
}

//______________________________________________________________________________
TProof *TProofMgr::AttachSession(TProofDesc *d, Bool_t)
{
   // Dummy version provided for completeness. Just returns a pointer to
   // existing session 'id' (as shown by TProof::QuerySessions) or 0 if 'id' is
   // not valid.

   if (!d) {
      Warning("AttachSession","invalid description object - do nothing");
      return 0;
   }

   if (d->GetProof())
      // Nothing to do if already in contact with proofserv
      return d->GetProof();

   Warning("AttachSession","session not available - do nothing");
   return 0;
}

//______________________________________________________________________________
void TProofMgr::DetachSession(Int_t id, Option_t *opt)
{
   // Detach session with 'id' from its proofserv. The 'id' is the number
   // shown by QuerySessions. The correspondent TProof object is deleted.
   // If id == 0 all the known sessions are detached.
   // Option opt="S" or "s" forces session shutdown.

   if (!IsValid()) {
      Warning("DetachSession","invalid TProofMgr - do nothing");
      return;
   }

   if (id > 0) {

      TProofDesc *d = GetProofDesc(id);
      if (d) {
         if (d->GetProof())
            d->GetProof()->Detach(opt);
         TProof *p = d->GetProof();
         fSessions->Remove(d);
         SafeDelete(p);
         delete d;
      }

   } else if (id == 0) {

      // Requesto to destroy all sessions
      if (fSessions) {
         // Delete PROOF sessions
         TIter nxd(fSessions);
         TProofDesc *d = 0;
         while ((d = (TProofDesc *)nxd())) {
            if (d->GetProof())
               d->GetProof()->Detach(opt);
            TProof *p = d->GetProof();
            fSessions->Remove(d);
            SafeDelete(p);
         }
         fSessions->Delete();
      }
   }

   return;
}

//______________________________________________________________________________
void TProofMgr::DetachSession(TProof *p, Option_t *opt)
{
   // Detach session 'p' from its proofserv. The instance 'p' is invalidated
   // and should be deleted by the caller

   if (!IsValid()) {
      Warning("DetachSession","invalid TProofMgr - do nothing");
      return;
   }

   if (p) {
      // Single session request
      TProofDesc *d = GetProofDesc(p);
      if (d) {
         if (d->GetProof())
            // The session is closed here
            d->GetProof()->Detach(opt);
         fSessions->Remove(d);
         delete d;
      }
   }

   return;
}

//______________________________________________________________________________
TList *TProofMgr::QuerySessions(Option_t *opt)
{
   // Get list of sessions accessible to this manager.

   if (opt && !strncasecmp(opt,"L",1))
      // Just return the existing list
      return fSessions;

   // Create list if not existing
   if (!fSessions) {
      fSessions = new TList();
      fSessions->SetOwner();
   }

   // Fill-in entries from the official list
   if (gROOT->GetListOfProofs()) {
      // Loop over
      TIter nxp(gROOT->GetListOfProofs());
      TObject *o = 0;
      TProof *p = 0;
      Int_t ns = 0;
      while ((o = nxp())) {
         if (o->InheritsFrom(TProof::Class())) {
            p = (TProof *)o;
            // Only those belonging to this server
            if (MatchUrl(p->GetUrl())) {
               if (!(fSessions->FindObject(p->GetSessionTag()))) {
                  Int_t st = (p->IsIdle()) ? TProofDesc::kIdle
                                          : TProofDesc::kRunning;
                  TProofDesc *d =
                     new TProofDesc(p->GetName(), p->GetTitle(), p->GetUrl(),
                                          ++ns, p->GetSessionID(), st, p);
                  fSessions->Add(d);
               }
            }
         }
      }
   }

   // Drop entries not existing any longer
   if (fSessions->GetSize() > 0) {
      TIter nxd(fSessions);
      TProofDesc *d = 0;
      while ((d = (TProofDesc *)nxd())) {
         if (d->GetProof()) {
            if (!(gROOT->GetListOfProofs()->FindObject(d->GetProof()))) {
               fSessions->Remove(d);
               SafeDelete(d);
            } else {
               if (opt && !strncasecmp(opt,"S",1))
                  d->Print("");
            }
         }
      }
   }

   // We are done
   return fSessions;
}

//______________________________________________________________________________
Int_t TProofMgr::SendMsgToUsers(const char *, const char *)
{
   // Send a message to connected users. Only superusers can do this.
   // The first argument specifies the message or the file from where to take
   // the message.
   // The second argument specifies the user to which to send the message: if
   // empty or null the message is send to all the connected users.
   // return 0 in case of success, -1 in case of error

   Warning("SendMsgToUsers","functionality not supported");

   return -1;
}

//______________________________________________________________________________
Int_t TProofMgr::Reset(Bool_t, const char *)
{
   // Send a cleanup request for the sessions associated with the current
   // user.
   // Not supported.

   Warning("Reset","functionality not supported");

   return -1;
}

//______________________________________________________________________________
void TProofMgr::ShowWorkers()
{
   // Show available workers

   AbstractMethod("ShowWorkers");
}

//______________________________________________________________________________
TProofDesc *TProofMgr::GetProofDesc(Int_t id)
{
   // Get TProofDesc instance corresponding to 'id'.

   TProofDesc *d = 0;
   if (id > 0) {
      // Retrieve an updated list
      QuerySessions("");
      if (fSessions) {
         TIter nxd(fSessions);
         while ((d = (TProofDesc *)nxd())) {
            if (d->MatchId(id))
               return d;
         }
      }
   }

   return d;
}

//______________________________________________________________________________
TProofDesc *TProofMgr::GetProofDesc(TProof *p)
{
   // Get TProofDesc instance corresponding to TProof object 'p'.

   TProofDesc *d = 0;
   if (p) {
      // Retrieve an updated list
      QuerySessions("");
      if (fSessions) {
         TIter nxd(fSessions);
         while ((d = (TProofDesc *)nxd())) {
            if (p == d->GetProof())
               return d;
         }
      }
   }

   return d;
}

//______________________________________________________________________________
void TProofMgr::DiscardSession(TProof *p)
{
   // Discard TProofDesc of session 'p' from the internal list

   if (p) {
      TProofDesc *d = 0;
      if (fSessions) {
         TIter nxd(fSessions);
         while ((d = (TProofDesc *)nxd())) {
            if (p == d->GetProof()) {
               fSessions->Remove(d);
               delete d;
               break;
            }
         }
      }
   }
}

//______________________________________________________________________________
TProof *TProofMgr::CreateSession(const char *cfg,
                                 const char *cfgdir, Int_t loglevel)
{
   // Create a new remote session (master and associated workers).

   // Create
   if (IsProofd())
      fUrl.SetOptions("std");

   // Create the instance
   TProof *p = new TProof(fUrl.GetUrl(), cfg, cfgdir, loglevel, 0, this);

   if (p && p->IsValid()) {

      // Save record about this session
      Int_t ns = 1;
      if (fSessions) {
         // To avoid ambiguities in case of removal of some elements
         if (fSessions->Last())
            ns = ((TProofDesc *)(fSessions->Last()))->GetLocalId() + 1;
      } else {
         // Create the list
         fSessions = new TList;
      }

      // Create the description class
      Int_t st = (p->IsIdle()) ? TProofDesc::kIdle : TProofDesc::kRunning ;
      TProofDesc *d =
         new TProofDesc(p->GetName(), p->GetTitle(), p->GetUrl(),
                               ns, p->GetSessionID(), st, p);
      fSessions->Add(d);

   } else {
      // Session creation failed
      if (gDebug > 0) Error("CreateSession", "PROOF session creation failed");
      SafeDelete(p);
   }

   // We are done
   return p;
}

//______________________________________________________________________________
Bool_t TProofMgr::MatchUrl(const char *url)
{
   // Checks if 'url' refers to the same 'user@host:port' entity as the URL
   // in memory

   TUrl u(url);

   // Correct URL protocol
   if (!strcmp(u.GetProtocol(), TUrl("a").GetProtocol()))
      u.SetProtocol("proof");

   // Correct port
   if (u.GetPort() == TUrl("a").GetPort()) {
      Int_t port = gSystem->GetServiceByName("proofd");
      if (port < 0)
         port = 1093;
      u.SetPort(port);
   }

   // Now we can check
   if (!strcmp(u.GetHostFQDN(), fUrl.GetHostFQDN()))
      if (u.GetPort() == fUrl.GetPort())
         if (strlen(u.GetUser()) <= 0 || !strcmp(u.GetUser(),fUrl.GetUser()))
            return kTRUE;

   // Match failed
   return kFALSE;
}

//________________________________________________________________________
TList *TProofMgr::GetListOfManagers()
{
   // Extract pointers to PROOF managers from TROOT::fProofs.

   // Update the list with new entries
   if (gROOT->GetListOfProofs()) {
      TIter nxp(gROOT->GetListOfProofs());
      TObject *o = 0;
      while ((o = nxp())) {
         if (o->InheritsFrom(TProofMgr::Class()) && !fgListOfManagers.FindObject(o))
            fgListOfManagers.Add(o);
      }
   }

   // Get rid of invalid entries and notify
   if (fgListOfManagers.GetSize() > 0) {
      TIter nxp(&fgListOfManagers);
      TObject *o = 0;
      Int_t nm = 0;
      while ((o = nxp())) {
         if (!(gROOT->GetListOfProofs()->FindObject(o))) {
            fgListOfManagers.Remove(o);
         } else {
            TProofMgr *p = (TProofMgr *)o;
            if (gDebug > 0)
               Printf("// #%d: \"%s\" (%s)", ++nm, p->GetName(), p->GetTitle());
         }
      }
   } else {
      if (gDebug > 0)
         Printf("No managers found");
   }

   // We are done
   return &fgListOfManagers;
}

//______________________________________________________________________________
TProofMgr *TProofMgr::Create(const char *uin, Int_t loglevel,
                             const char *alias, Bool_t xpd)
{
   // Static method returning the appropriate TProofMgr object using
   // the plugin manager.
   TProofMgr *m= 0;

   Bool_t isLite = kFALSE;

   // Resolve url; if empty the actions depend of the default
   TUrl u(uin);
   TString proto = u.GetProtocol();
   if (proto.IsNull()) {
      u.SetUrl(gEnv->GetValue("Proof.LocalDefault", "lite://"));
      proto = u.GetProtocol();
   }
   TString host = u.GetHost();
   if (proto == "lite" || host == "__lite__" ) {
#ifndef WIN32
      isLite = kTRUE;
      u.SetHost("__lite__");
      u.SetProtocol("proof");
      u.SetPort(1093);
#else
      ::Info("TProofMgr::Create","'lite' not yet supported on Windows");
      return m;
#endif
   }

   if (!isLite) {
      // in case user gave as url: "machine.dom.ain", replace
      // "http" by "proof" and "80" by "1093"
      if (!strcmp(u.GetProtocol(), TUrl("a").GetProtocol()))
         u.SetProtocol("proof");
      if (u.GetPort() == TUrl("a").GetPort())
         u.SetPort(1093);
   }

   // Avoid multiple calls to GetUrl
   const char *url = u.GetUrl();

   // Make sure we do not have already a manager for this URL
   TList *lm = TProofMgr::GetListOfManagers();
   if (lm) {
      TIter nxm(lm);
      while ((m = (TProofMgr *)nxm())) {
         if (m->IsValid()) {
            if (m->MatchUrl(url)) return m;
         } else {
            fgListOfManagers.Remove(m);
            SafeDelete(m);
            break;
         }
      }
   }

   if (isLite) {
      // Init the lite version
      return new TProofMgrLite(url, loglevel, alias);
   }

   m = 0;
   Bool_t trystd = kTRUE;

   // If required, we assume first that the remote server is based on XrdProofd
   if (xpd) {
      TProofMgr_t cm = TProofMgr::GetXProofMgrHook();
      if (cm) {
         m = (TProofMgr *) (*cm)(url, loglevel, alias);
         // Update trystd flag
         trystd = (m && !(m->IsValid()) && m->IsProofd()) ? kTRUE : kFALSE;
      }
   }

   // If the first attempt failed, we instantiate an old interface
   if (trystd) {
      SafeDelete(m);
      m = new TProofMgr(url, loglevel, alias);
   }

   // Record the new manager, if any
   if (m) {
      fgListOfManagers.Add(m);
      if (m->IsValid() && !(m->IsProofd())) {
         R__LOCKGUARD2(gROOTMutex);
         gROOT->GetListOfProofs()->Add(m);
         gROOT->GetListOfSockets()->Add(m);
      }
   }

   // We are done
   return m;
}

//________________________________________________________________________
TProofMgr_t TProofMgr::GetXProofMgrHook()
{
   // Get the constructor hook fro TXProofMgr.
   // We do this without the plugin manager because it blocks the
   // CINT mutex breaking the parallel startup.

   if (!fgTXProofMgrHook) {
      // Load the appropriate library ...
      TString prooflib = "libProofx";
      char *p = 0;
      if ((p = gSystem->DynamicPathName(prooflib, kTRUE))) {
         delete[] p;
         if (gSystem->Load(prooflib) == -1)
            ::Error("TProofMgr::GetXProofMgrCtor",
                    "can't load %s", prooflib.Data());
      } else
         ::Error("TProofMgr::GetXProofMgrCtor",
                 "can't locate %s", prooflib.Data());
   }

   // Done
   return fgTXProofMgrHook;
}

//_____________________________________________________________________________
void TProofMgr::SetTXProofMgrHook(TProofMgr_t pmh)
{
   // Set hook to TXProofMgr ctor

   fgTXProofMgrHook = pmh;
}

//______________________________________________________________________________
Int_t TProofMgr::Ping(const char *url, Bool_t checkxrd)
{
   // Non-blocking check for a PROOF (or Xrootd, if checkxrd) service at 'url'
   // Return
   //        0 if a XProofd (or Xrootd, if checkxrd) daemon is listening at 'url'
   //       -1 if nothing is listening on the port (connection cannot be open)
   //        1 if something is listening but not XProofd (or not Xrootd, if checkxrd)

   if (!url || (url && strlen(url) <= 0)) {
      ::Error("TProofMgr::Ping", "empty url - fail");
      return -1;
   }

   TUrl u(url);
   // Check the port and set the defaults
   if (!strcmp(u.GetProtocol(), "http") && u.GetPort() == 80) {
      if (!checkxrd) {
         u.SetPort(1093);
      } else {
         u.SetPort(1094);
      }
   }

   // Open the connection, disabling warnings ...
   Int_t oldLevel = gErrorIgnoreLevel;
   gErrorIgnoreLevel = kSysError+1;
   TSocket s(u.GetHost(), u.GetPort());
   if (!(s.IsValid())) {
      if (gDebug > 0)
         ::Info("TProofMgr::Ping", "could not open connection to %s:%d", u.GetHost(), u.GetPort());
      gErrorIgnoreLevel = oldLevel;
      return -1;
   }
   // Send the first bytes
   int writeCount = -1;
   clnt_HS_t initHS;
   memset(&initHS, 0, sizeof(initHS));
   int len = sizeof(initHS);
   if (checkxrd) {
      initHS.fourth = (int)host2net((int)4);
      initHS.fifth = (int)host2net((int)2012);
      if ((writeCount = s.SendRaw(&initHS, len)) != len) {
         if (gDebug > 0)
            ::Info("TProofMgr::Ping", "1st: wrong number of bytes sent: %d (expected: %d)",
                                    writeCount, len);
         gErrorIgnoreLevel = oldLevel;
         return 1;
      }
   } else {
      initHS.third  = (int)host2net((int)1);
      if ((writeCount = s.SendRaw(&initHS, len)) != len) {
         if (gDebug > 0)
            ::Info("TProofMgr::Ping", "1st: wrong number of bytes sent: %d (expected: %d)",
                                    writeCount, len);
         gErrorIgnoreLevel = oldLevel;
         return 1;
      }
      // These 8 bytes are need by 'proofd' and discarded by XPD
      int dum[2];
      dum[0] = (int)host2net((int)4);
      dum[1] = (int)host2net((int)2012);
      if ((writeCount = s.SendRaw(&dum[0], sizeof(dum))) !=  sizeof(dum)) {
         if (gDebug > 0)
            ::Info("TProofMgr::Ping", "2nd: wrong number of bytes sent: %d (expected: %d)",
                                    writeCount, (int) sizeof(dum));
         gErrorIgnoreLevel = oldLevel;
         return 1;
      }
   }
   // Read first server response
   int type;
   len = sizeof(type);
   int readCount = s.RecvRaw(&type, len); // 4(2+2) bytes
   if (readCount != len) {
      if (gDebug > 0)
         ::Info("TProofMgr::Ping", "1st: wrong number of bytes read: %d (expected: %d)",
                        readCount, len);
      gErrorIgnoreLevel = oldLevel;
      return 1;
   }
   // to host byte order
   type = net2host(type);
   // Check if the server is the eXtended proofd
   if (type == 0) {
      srv_HS_t xbody;
      len = sizeof(xbody);
      readCount = s.RecvRaw(&xbody, len); // 12(4+4+4) bytes
      if (readCount != len) {
         if (gDebug > 0)
            ::Info("TProofMgr::Ping", "2nd: wrong number of bytes read: %d (expected: %d)",
                           readCount, len);
         gErrorIgnoreLevel = oldLevel;
         return 1;
      }
      xbody.protover = net2host(xbody.protover);
      xbody.msgval = net2host(xbody.msglen);
      xbody.msglen = net2host(xbody.msgval);

   } else if (type == 8) {
      // Standard proofd
      if (gDebug > 0) ::Info("TProofMgr::Ping", "server is old %s", (checkxrd ? "ROOTD" : "PROOFD"));
      gErrorIgnoreLevel = oldLevel;
      return 1;
   } else {
      // We don't know the server type
      if (gDebug > 0) ::Info("TProofMgr::Ping", "unknown server type: %d", type);
      gErrorIgnoreLevel = oldLevel;
      return 1;
   }

   // Restore ignore level
   gErrorIgnoreLevel = oldLevel;
   // Done
   return 0;
}

//________________________________________________________________________
void TProofMgr::ReplaceSubdirs(const char *fn, TString &fdst, TList &dirph)
{
   // Parse file name extracting the directory subcomponents in dirs, stored
   // as TObjStrings.

   if (!fn || (fn && strlen(fn) <= 0)) return;
   if (dirph.GetSize() <= 0) return;

   // Parse fn
   TList dirs;
   TString dd(fn), d;
   Ssiz_t from = 0;
   while (dd.Tokenize(d, from, "/")) {
      if (!d.IsNull()) dirs.Add(new TObjString(d));
   }
   if (dirs.GetSize() <= 0) return;
   dirs.SetOwner(kTRUE);

   TIter nxph(&dirph);
   TParameter<Int_t> *pi = 0;
   while ((pi = (TParameter<Int_t> *) nxph())) {
      if (pi->GetVal() < dirs.GetSize()) {
         TObjString *os = (TObjString *) dirs.At(pi->GetVal());
         if (os) fdst.ReplaceAll(pi->GetName(), os->GetName());
      } else {
         ::Warning("TProofMgr::ReplaceSubdirs",
                   "requested directory level '%s' is not available in the file path",
                   pi->GetName());
      }
   }
}

//________________________________________________________________________
TFileCollection *TProofMgr::UploadFiles(TList *src,
                                        const char *mss, const char *dest)
{
   // Upload files provided via the list 'src' (as TFileInfo or TObjString)
   // to 'mss'. The path under 'mss' is determined by 'dest'; the following
   // place-holders can be used in 'dest':
   //      <d0>, <d1>, <d2>, ...         referring to the n-th sub-component
   //                                    of the src path
   //      <bn>                          basename in the source path
   //      <bs>                          basename sans extension
   //      <ex>                          Extension
   //      <sn>                          serial number of file in the list
   //      <s0>                          as <sn> but zero padded
   //      <fn>                          the full file path
   //      <us>, <gr>                    the local user and group names.
   //      <pg>                          the users PROOF group
   //      <pa>                          immediate parent directory
   //      <gp>                          next-to immediate parent directory
   // So, for example, if the source filename for the 99-th file is
   //               protosrc://host//d0/d1/d2/d3/d4/d5/myfile
   // then with dest = '/pool/user/<d3>/<d4>/<d5>/<s>/<bn>' and
   //           mss = 'protodst://hostdst//nm/
   // the corresponding destination path is
   //           protodst://hostdst//nm/pool/user/d3/d4/d5/99/myfile
   //
   // If 'dest' is empty, <fn> is used.
   //
   // Returns a TFileCollection with the destination files created; this
   // TFileCollection is, for example, ready to be registered as dataset.

   TFileCollection *ds = 0;

   // The inputs must be make sense
   if (!src || (src && src->GetSize() <= 0)) {
      ::Warning("TProofMgr::UploadFiles", "list is empty!");
      return ds;
   }
   if (!mss || (mss && strlen(mss) <= 0)) {
      ::Warning("TProofMgr::UploadFiles", "MSS is undefined!");
      return ds;
   }

   TList dirph;

   // If the destination is defined we need to understand if we have place-holders
   if (dest && strlen(dest) > 0) {
      TString dst(dest), dt;
      Ssiz_t from = 0;
      TRegexp re("<d+[0-9]>");
      while (dst.Tokenize(dt, from, "/")) {
         if (dt.Contains(re)) {
            TParameter<Int_t> *pi = new TParameter<Int_t>(dt, -1);
            dt.ReplaceAll("<d", "");
            dt.ReplaceAll(">", "");
            if (dt.IsDigit()) {
               pi->SetVal(dt.Atoi());
               dirph.Add(pi);
            } else {
               SafeDelete(pi);
            }
         }
      }
      dirph.SetOwner(kTRUE);
   }
   // Generate template for zero-padded serial numbers
   TString sForm = TString::Format("%%0%dd",
                                   Int_t(TMath::Log10(src->GetEntries()+1)));

   // Now we will actually copy files and create the TList object
   ds = new TFileCollection();
   TIter nxf(src);
   TObject *o = 0;
   TObjString *os = 0;
   TFileInfo *fi = 0;
   Int_t kn = 0;
   while ((o = nxf())) {
      TUrl *furl = 0;
      if (!strcmp(o->ClassName(), "TFileInfo")) {
         if (!(fi = dynamic_cast<TFileInfo *>(o))) {
            ::Warning("TProofMgr::UploadFiles",
                      "object of class name '%s' does not cast to %s - ignore",
                      o->ClassName(), o->ClassName());
            continue;
         }
         furl = fi->GetFirstUrl();
      } else if (!strcmp(o->ClassName(), "TObjString")) {
         if (!(os = dynamic_cast<TObjString *>(o))) {
            ::Warning("TProofMgr::UploadFiles",
                      "object of class name '%s' does not cast to %s - ignore",
                      o->ClassName(), o->ClassName());
            continue;
         }
         furl = new TUrl(os->GetName());
      } else {
         ::Warning("TProofMgr::UploadFiles",
                   "object of unsupported class '%s' found in list - ignore", o->ClassName());
         continue;
      }

      // The file must be accessible
      if (gSystem->AccessPathName(furl->GetUrl()) == kFALSE) {

         // Create the destination path
         TString fdst(mss);
         if (dest && strlen(dest) > 0) {
            fdst += dest;
         } else {
            fdst += TString::Format("/%s", furl->GetFile());
         }

         // Replace filename and basename
         if (fdst.Contains("<bn>")) fdst.ReplaceAll("<bn>", gSystem->BaseName(furl->GetFile()));
         if (fdst.Contains("<fn>")) fdst.ReplaceAll("<fn>", furl->GetFile());
         if (fdst.Contains("<bs>")) {
            // Basename sans 'extension'
            TString bs(gSystem->BaseName(furl->GetFile()));
            Int_t idx = bs.Last('.');
            if (idx != kNPOS) bs.Remove(idx);
            fdst.ReplaceAll("<bs>", bs.Data());
         }
         if (fdst.Contains("<ex>")) {
            // 'Extension' - that is the last part after the last '.'
            TString ex(furl->GetFile());
            Int_t idx = ex.Last('.');
            if (idx != kNPOS) ex.Remove(0, idx+1);
            else                       ex = "";
            fdst.ReplaceAll("<ex>", ex);
         }
         if (fdst.Contains("<pa>")) {
            fdst.ReplaceAll("<pa>",
                            gSystem->BaseName(gSystem
                                              ->DirName(furl->GetFile())));

         }
         if (fdst.Contains("<gp>")) {
            fdst.ReplaceAll("<gp>",
                            gSystem->BaseName(gSystem
                                              ->DirName(gSystem
                                                        ->DirName(furl->GetFile()))));

         }


         // Replace serial number
         if (fdst.Contains("<sn>")) {
            TString skn = TString::Format("%d", kn);
            fdst.ReplaceAll("<sn>", skn);
         }
         if (fdst.Contains("<s0>")) {
            TString skn = TString::Format(sForm.Data(), kn);
            fdst.ReplaceAll("<s0>", skn);
         }
         kn++;

         // Replace user and group name
         UserGroup_t *pw = gSystem->GetUserInfo();
         if (pw) {
            if (fdst.Contains("<us>")) fdst.ReplaceAll("<us>", pw->fUser);
            if (fdst.Contains("<gr>")) fdst.ReplaceAll("<gr>", pw->fGroup);
            delete pw;
         }
         if (gProof && fdst.Contains("<pg>"))
            fdst.ReplaceAll("<pg>", gProof->GetGroup());

         // Now replace the subdirs, if required
         if (dirph.GetSize() > 0)
            TProofMgr::ReplaceSubdirs(gSystem->DirName(furl->GetFile()), fdst, dirph);

         // Check double slashes in the file field (Turl sets things correctly inside)
         TUrl u(fdst);
         fdst = u.GetUrl();

         // Copy the file now
         ::Info("TProofMgr::UploadFiles", "uploading '%s' to '%s'", furl->GetUrl(), fdst.Data());
         if (TFile::Cp(furl->GetUrl(), fdst.Data())) {
            // Build TFileCollection
            ds->Add(new TFileInfo(fdst.Data()));
         } else {
            ::Error("TProofMgr::UploadFiles", "file %s was not copied", furl->GetUrl());
         }
      }
   }

   // Return the TFileCollection
   return ds;
}

//______________________________________________________________________________
TFileCollection *TProofMgr::UploadFiles(const char *srcfiles,
                                        const char *mss, const char *dest)
{
   // Upload to 'mss' the files listed in the text file 'srcfiles' or contained
   // in the directory 'srcfiles'.
   // In the case 'srcfiles' is a text file, the files must be specified one per
   // line, with line beginning by '#' ignored (i.e. considered comments).
   // The path under 'mss' is defined by 'dest'; the following
   // place-holders can be used in 'dest':
   //      <d0>, <d1>, <d2>, ...         referring to the n-th sub-component
   //                                    of the src path
   //      <bn>                          basename in the source path
   //      <sn>                          serial number of file in the list
   //      <fn>                          the full file path
   //      <us>, <gr>                    the local user and group names.
   // So, for example, if the source filename for the 99-th file is
   //               protosrc://host//d0/d1/d2/d3/d4/d5/myfile
   // then with dest = '/pool/user/<d3>/<d4>/<d5>/<s>/<bn>' and
   //           mss = 'protodst://hostdst//nm/
   // the corresponding destination path is
   //           protodst://hostdst//nm/pool/user/d3/d4/d5/99/myfile
   //
   // If 'dest' is empty, <fn> is used.
   //
   // Returns a TFileCollection with the destination files created; this
   // TFileCollection is, for example, ready to be registered as dataset.

   TFileCollection *ds = 0;

   // The inputs must be make sense
   if (!srcfiles || (srcfiles && strlen(srcfiles) <= 0)) {
      ::Error("TProofMgr::UploadFiles", "input text file or directory undefined!");
      return ds;
   }
   if (!mss || (mss && strlen(mss) <= 0)) {
      ::Error("TProofMgr::UploadFiles", "MSS is undefined!");
      return ds;
   }

   TString inpath(gSystem->ExpandPathName(srcfiles));

   FileStat_t fst;
   if (gSystem->GetPathInfo(inpath.Data(), fst)) {
      ::Error("TProofMgr::UploadFiles",
              "could not get information about the input path '%s':"
              " make sure that it exists and is readable", srcfiles);
      return ds;
   }

   // Create the list to feed UploadFile(TList *, ...)
   TList files;
   files.SetOwner();

   TString line;
   if (R_ISREG(fst.fMode)) {
      // Text file
      std::ifstream f;
      f.open(inpath.Data(), std::ifstream::out);
      if (f.is_open()) {
         while (f.good()) {
            line.ReadToDelim(f);
            line.Strip(TString::kTrailing, '\n');
            // Skip comments
            if (line.BeginsWith("#")) continue;
            if (gSystem->AccessPathName(line, kReadPermission) == kFALSE)
               files.Add(new TFileInfo(line));
         }
         f.close();
      } else {
         ::Error("TProofMgr::UploadFiles", "unable to open file '%s'", srcfiles);
      }
   } else if (R_ISDIR(fst.fMode)) {
      // Directory
      void *dirp = gSystem->OpenDirectory(inpath.Data());
      if (dirp) {
         const char *ent = 0;
         while ((ent = gSystem->GetDirEntry(dirp))) {
            if (!strcmp(ent, ".") || !strcmp(ent, "..")) continue;
            line.Form("%s/%s", inpath.Data(), ent);
            if (gSystem->AccessPathName(line, kReadPermission) == kFALSE)
               files.Add(new TFileInfo(line));
         }
         gSystem->FreeDirectory(dirp);
      } else {
         ::Error("TProofMgr::UploadFiles", "unable to open directory '%s'", inpath.Data());
      }
   } else {
      ::Error("TProofMgr::UploadFiles",
              "input path '%s' is neither a regular file nor a directory!", inpath.Data());
      return ds;
   }
   if (files.GetSize() <= 0) {
      ::Warning("TProofMgr::UploadFiles", "no files found in file or directory '%s'", inpath.Data());
   } else {
      ds = TProofMgr::UploadFiles(&files, mss, dest);
   }
   // Done
   return ds;
}

//______________________________________________________________________________
Int_t TProofMgr::Rm(const char *what, const char *, const char *)
{
   // Run 'rm' on 'what'. Locally it is just a call to TSystem::Unlink .

   Int_t rc = -1;
   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Rm", "invalid TProofMgr - do nothing");
      return rc;
   }
   // Nothing to do if not in contact with proofserv
   if (!what || (what && strlen(what) <= 0)) {
      Error("Rm", "path undefined!");
      return rc;
   }

   TUrl u(what);
   if (!strcmp(u.GetProtocol(), "file")) {
      rc = gSystem->Unlink(u.GetFile());
   } else {
      rc = gSystem->Unlink(what);
   }
   // Done
   return (rc == 0) ? 0 : -1;
}

//
//  TProofDesc
//

ClassImp(TProofDesc)

//________________________________________________________________________
void TProofDesc::Print(Option_t *) const
{
   // Dump the content to the screen.
   const char *st[] = { "unknown", "idle", "processing", "shutting down"};

   Printf("// # %d", fLocalId);
   Printf("// alias: %s, url: \"%s\"", GetTitle(), GetUrl());
   Printf("// tag: %s", GetName());
   Printf("// status: %s, attached: %s (remote ID: %d)",st[fStatus+1], (fProof ? "YES" : "NO"), fRemoteId);
}
 TProofMgr.cxx:1
 TProofMgr.cxx:2
 TProofMgr.cxx:3
 TProofMgr.cxx:4
 TProofMgr.cxx:5
 TProofMgr.cxx:6
 TProofMgr.cxx:7
 TProofMgr.cxx:8
 TProofMgr.cxx:9
 TProofMgr.cxx:10
 TProofMgr.cxx:11
 TProofMgr.cxx:12
 TProofMgr.cxx:13
 TProofMgr.cxx:14
 TProofMgr.cxx:15
 TProofMgr.cxx:16
 TProofMgr.cxx:17
 TProofMgr.cxx:18
 TProofMgr.cxx:19
 TProofMgr.cxx:20
 TProofMgr.cxx:21
 TProofMgr.cxx:22
 TProofMgr.cxx:23
 TProofMgr.cxx:24
 TProofMgr.cxx:25
 TProofMgr.cxx:26
 TProofMgr.cxx:27
 TProofMgr.cxx:28
 TProofMgr.cxx:29
 TProofMgr.cxx:30
 TProofMgr.cxx:31
 TProofMgr.cxx:32
 TProofMgr.cxx:33
 TProofMgr.cxx:34
 TProofMgr.cxx:35
 TProofMgr.cxx:36
 TProofMgr.cxx:37
 TProofMgr.cxx:38
 TProofMgr.cxx:39
 TProofMgr.cxx:40
 TProofMgr.cxx:41
 TProofMgr.cxx:42
 TProofMgr.cxx:43
 TProofMgr.cxx:44
 TProofMgr.cxx:45
 TProofMgr.cxx:46
 TProofMgr.cxx:47
 TProofMgr.cxx:48
 TProofMgr.cxx:49
 TProofMgr.cxx:50
 TProofMgr.cxx:51
 TProofMgr.cxx:52
 TProofMgr.cxx:53
 TProofMgr.cxx:54
 TProofMgr.cxx:55
 TProofMgr.cxx:56
 TProofMgr.cxx:57
 TProofMgr.cxx:58
 TProofMgr.cxx:59
 TProofMgr.cxx:60
 TProofMgr.cxx:61
 TProofMgr.cxx:62
 TProofMgr.cxx:63
 TProofMgr.cxx:64
 TProofMgr.cxx:65
 TProofMgr.cxx:66
 TProofMgr.cxx:67
 TProofMgr.cxx:68
 TProofMgr.cxx:69
 TProofMgr.cxx:70
 TProofMgr.cxx:71
 TProofMgr.cxx:72
 TProofMgr.cxx:73
 TProofMgr.cxx:74
 TProofMgr.cxx:75
 TProofMgr.cxx:76
 TProofMgr.cxx:77
 TProofMgr.cxx:78
 TProofMgr.cxx:79
 TProofMgr.cxx:80
 TProofMgr.cxx:81
 TProofMgr.cxx:82
 TProofMgr.cxx:83
 TProofMgr.cxx:84
 TProofMgr.cxx:85
 TProofMgr.cxx:86
 TProofMgr.cxx:87
 TProofMgr.cxx:88
 TProofMgr.cxx:89
 TProofMgr.cxx:90
 TProofMgr.cxx:91
 TProofMgr.cxx:92
 TProofMgr.cxx:93
 TProofMgr.cxx:94
 TProofMgr.cxx:95
 TProofMgr.cxx:96
 TProofMgr.cxx:97
 TProofMgr.cxx:98
 TProofMgr.cxx:99
 TProofMgr.cxx:100
 TProofMgr.cxx:101
 TProofMgr.cxx:102
 TProofMgr.cxx:103
 TProofMgr.cxx:104
 TProofMgr.cxx:105
 TProofMgr.cxx:106
 TProofMgr.cxx:107
 TProofMgr.cxx:108
 TProofMgr.cxx:109
 TProofMgr.cxx:110
 TProofMgr.cxx:111
 TProofMgr.cxx:112
 TProofMgr.cxx:113
 TProofMgr.cxx:114
 TProofMgr.cxx:115
 TProofMgr.cxx:116
 TProofMgr.cxx:117
 TProofMgr.cxx:118
 TProofMgr.cxx:119
 TProofMgr.cxx:120
 TProofMgr.cxx:121
 TProofMgr.cxx:122
 TProofMgr.cxx:123
 TProofMgr.cxx:124
 TProofMgr.cxx:125
 TProofMgr.cxx:126
 TProofMgr.cxx:127
 TProofMgr.cxx:128
 TProofMgr.cxx:129
 TProofMgr.cxx:130
 TProofMgr.cxx:131
 TProofMgr.cxx:132
 TProofMgr.cxx:133
 TProofMgr.cxx:134
 TProofMgr.cxx:135
 TProofMgr.cxx:136
 TProofMgr.cxx:137
 TProofMgr.cxx:138
 TProofMgr.cxx:139
 TProofMgr.cxx:140
 TProofMgr.cxx:141
 TProofMgr.cxx:142
 TProofMgr.cxx:143
 TProofMgr.cxx:144
 TProofMgr.cxx:145
 TProofMgr.cxx:146
 TProofMgr.cxx:147
 TProofMgr.cxx:148
 TProofMgr.cxx:149
 TProofMgr.cxx:150
 TProofMgr.cxx:151
 TProofMgr.cxx:152
 TProofMgr.cxx:153
 TProofMgr.cxx:154
 TProofMgr.cxx:155
 TProofMgr.cxx:156
 TProofMgr.cxx:157
 TProofMgr.cxx:158
 TProofMgr.cxx:159
 TProofMgr.cxx:160
 TProofMgr.cxx:161
 TProofMgr.cxx:162
 TProofMgr.cxx:163
 TProofMgr.cxx:164
 TProofMgr.cxx:165
 TProofMgr.cxx:166
 TProofMgr.cxx:167
 TProofMgr.cxx:168
 TProofMgr.cxx:169
 TProofMgr.cxx:170
 TProofMgr.cxx:171
 TProofMgr.cxx:172
 TProofMgr.cxx:173
 TProofMgr.cxx:174
 TProofMgr.cxx:175
 TProofMgr.cxx:176
 TProofMgr.cxx:177
 TProofMgr.cxx:178
 TProofMgr.cxx:179
 TProofMgr.cxx:180
 TProofMgr.cxx:181
 TProofMgr.cxx:182
 TProofMgr.cxx:183
 TProofMgr.cxx:184
 TProofMgr.cxx:185
 TProofMgr.cxx:186
 TProofMgr.cxx:187
 TProofMgr.cxx:188
 TProofMgr.cxx:189
 TProofMgr.cxx:190
 TProofMgr.cxx:191
 TProofMgr.cxx:192
 TProofMgr.cxx:193
 TProofMgr.cxx:194
 TProofMgr.cxx:195
 TProofMgr.cxx:196
 TProofMgr.cxx:197
 TProofMgr.cxx:198
 TProofMgr.cxx:199
 TProofMgr.cxx:200
 TProofMgr.cxx:201
 TProofMgr.cxx:202
 TProofMgr.cxx:203
 TProofMgr.cxx:204
 TProofMgr.cxx:205
 TProofMgr.cxx:206
 TProofMgr.cxx:207
 TProofMgr.cxx:208
 TProofMgr.cxx:209
 TProofMgr.cxx:210
 TProofMgr.cxx:211
 TProofMgr.cxx:212
 TProofMgr.cxx:213
 TProofMgr.cxx:214
 TProofMgr.cxx:215
 TProofMgr.cxx:216
 TProofMgr.cxx:217
 TProofMgr.cxx:218
 TProofMgr.cxx:219
 TProofMgr.cxx:220
 TProofMgr.cxx:221
 TProofMgr.cxx:222
 TProofMgr.cxx:223
 TProofMgr.cxx:224
 TProofMgr.cxx:225
 TProofMgr.cxx:226
 TProofMgr.cxx:227
 TProofMgr.cxx:228
 TProofMgr.cxx:229
 TProofMgr.cxx:230
 TProofMgr.cxx:231
 TProofMgr.cxx:232
 TProofMgr.cxx:233
 TProofMgr.cxx:234
 TProofMgr.cxx:235
 TProofMgr.cxx:236
 TProofMgr.cxx:237
 TProofMgr.cxx:238
 TProofMgr.cxx:239
 TProofMgr.cxx:240
 TProofMgr.cxx:241
 TProofMgr.cxx:242
 TProofMgr.cxx:243
 TProofMgr.cxx:244
 TProofMgr.cxx:245
 TProofMgr.cxx:246
 TProofMgr.cxx:247
 TProofMgr.cxx:248
 TProofMgr.cxx:249
 TProofMgr.cxx:250
 TProofMgr.cxx:251
 TProofMgr.cxx:252
 TProofMgr.cxx:253
 TProofMgr.cxx:254
 TProofMgr.cxx:255
 TProofMgr.cxx:256
 TProofMgr.cxx:257
 TProofMgr.cxx:258
 TProofMgr.cxx:259
 TProofMgr.cxx:260
 TProofMgr.cxx:261
 TProofMgr.cxx:262
 TProofMgr.cxx:263
 TProofMgr.cxx:264
 TProofMgr.cxx:265
 TProofMgr.cxx:266
 TProofMgr.cxx:267
 TProofMgr.cxx:268
 TProofMgr.cxx:269
 TProofMgr.cxx:270
 TProofMgr.cxx:271
 TProofMgr.cxx:272
 TProofMgr.cxx:273
 TProofMgr.cxx:274
 TProofMgr.cxx:275
 TProofMgr.cxx:276
 TProofMgr.cxx:277
 TProofMgr.cxx:278
 TProofMgr.cxx:279
 TProofMgr.cxx:280
 TProofMgr.cxx:281
 TProofMgr.cxx:282
 TProofMgr.cxx:283
 TProofMgr.cxx:284
 TProofMgr.cxx:285
 TProofMgr.cxx:286
 TProofMgr.cxx:287
 TProofMgr.cxx:288
 TProofMgr.cxx:289
 TProofMgr.cxx:290
 TProofMgr.cxx:291
 TProofMgr.cxx:292
 TProofMgr.cxx:293
 TProofMgr.cxx:294
 TProofMgr.cxx:295
 TProofMgr.cxx:296
 TProofMgr.cxx:297
 TProofMgr.cxx:298
 TProofMgr.cxx:299
 TProofMgr.cxx:300
 TProofMgr.cxx:301
 TProofMgr.cxx:302
 TProofMgr.cxx:303
 TProofMgr.cxx:304
 TProofMgr.cxx:305
 TProofMgr.cxx:306
 TProofMgr.cxx:307
 TProofMgr.cxx:308
 TProofMgr.cxx:309
 TProofMgr.cxx:310
 TProofMgr.cxx:311
 TProofMgr.cxx:312
 TProofMgr.cxx:313
 TProofMgr.cxx:314
 TProofMgr.cxx:315
 TProofMgr.cxx:316
 TProofMgr.cxx:317
 TProofMgr.cxx:318
 TProofMgr.cxx:319
 TProofMgr.cxx:320
 TProofMgr.cxx:321
 TProofMgr.cxx:322
 TProofMgr.cxx:323
 TProofMgr.cxx:324
 TProofMgr.cxx:325
 TProofMgr.cxx:326
 TProofMgr.cxx:327
 TProofMgr.cxx:328
 TProofMgr.cxx:329
 TProofMgr.cxx:330
 TProofMgr.cxx:331
 TProofMgr.cxx:332
 TProofMgr.cxx:333
 TProofMgr.cxx:334
 TProofMgr.cxx:335
 TProofMgr.cxx:336
 TProofMgr.cxx:337
 TProofMgr.cxx:338
 TProofMgr.cxx:339
 TProofMgr.cxx:340
 TProofMgr.cxx:341
 TProofMgr.cxx:342
 TProofMgr.cxx:343
 TProofMgr.cxx:344
 TProofMgr.cxx:345
 TProofMgr.cxx:346
 TProofMgr.cxx:347
 TProofMgr.cxx:348
 TProofMgr.cxx:349
 TProofMgr.cxx:350
 TProofMgr.cxx:351
 TProofMgr.cxx:352
 TProofMgr.cxx:353
 TProofMgr.cxx:354
 TProofMgr.cxx:355
 TProofMgr.cxx:356
 TProofMgr.cxx:357
 TProofMgr.cxx:358
 TProofMgr.cxx:359
 TProofMgr.cxx:360
 TProofMgr.cxx:361
 TProofMgr.cxx:362
 TProofMgr.cxx:363
 TProofMgr.cxx:364
 TProofMgr.cxx:365
 TProofMgr.cxx:366
 TProofMgr.cxx:367
 TProofMgr.cxx:368
 TProofMgr.cxx:369
 TProofMgr.cxx:370
 TProofMgr.cxx:371
 TProofMgr.cxx:372
 TProofMgr.cxx:373
 TProofMgr.cxx:374
 TProofMgr.cxx:375
 TProofMgr.cxx:376
 TProofMgr.cxx:377
 TProofMgr.cxx:378
 TProofMgr.cxx:379
 TProofMgr.cxx:380
 TProofMgr.cxx:381
 TProofMgr.cxx:382
 TProofMgr.cxx:383
 TProofMgr.cxx:384
 TProofMgr.cxx:385
 TProofMgr.cxx:386
 TProofMgr.cxx:387
 TProofMgr.cxx:388
 TProofMgr.cxx:389
 TProofMgr.cxx:390
 TProofMgr.cxx:391
 TProofMgr.cxx:392
 TProofMgr.cxx:393
 TProofMgr.cxx:394
 TProofMgr.cxx:395
 TProofMgr.cxx:396
 TProofMgr.cxx:397
 TProofMgr.cxx:398
 TProofMgr.cxx:399
 TProofMgr.cxx:400
 TProofMgr.cxx:401
 TProofMgr.cxx:402
 TProofMgr.cxx:403
 TProofMgr.cxx:404
 TProofMgr.cxx:405
 TProofMgr.cxx:406
 TProofMgr.cxx:407
 TProofMgr.cxx:408
 TProofMgr.cxx:409
 TProofMgr.cxx:410
 TProofMgr.cxx:411
 TProofMgr.cxx:412
 TProofMgr.cxx:413
 TProofMgr.cxx:414
 TProofMgr.cxx:415
 TProofMgr.cxx:416
 TProofMgr.cxx:417
 TProofMgr.cxx:418
 TProofMgr.cxx:419
 TProofMgr.cxx:420
 TProofMgr.cxx:421
 TProofMgr.cxx:422
 TProofMgr.cxx:423
 TProofMgr.cxx:424
 TProofMgr.cxx:425
 TProofMgr.cxx:426
 TProofMgr.cxx:427
 TProofMgr.cxx:428
 TProofMgr.cxx:429
 TProofMgr.cxx:430
 TProofMgr.cxx:431
 TProofMgr.cxx:432
 TProofMgr.cxx:433
 TProofMgr.cxx:434
 TProofMgr.cxx:435
 TProofMgr.cxx:436
 TProofMgr.cxx:437
 TProofMgr.cxx:438
 TProofMgr.cxx:439
 TProofMgr.cxx:440
 TProofMgr.cxx:441
 TProofMgr.cxx:442
 TProofMgr.cxx:443
 TProofMgr.cxx:444
 TProofMgr.cxx:445
 TProofMgr.cxx:446
 TProofMgr.cxx:447
 TProofMgr.cxx:448
 TProofMgr.cxx:449
 TProofMgr.cxx:450
 TProofMgr.cxx:451
 TProofMgr.cxx:452
 TProofMgr.cxx:453
 TProofMgr.cxx:454
 TProofMgr.cxx:455
 TProofMgr.cxx:456
 TProofMgr.cxx:457
 TProofMgr.cxx:458
 TProofMgr.cxx:459
 TProofMgr.cxx:460
 TProofMgr.cxx:461
 TProofMgr.cxx:462
 TProofMgr.cxx:463
 TProofMgr.cxx:464
 TProofMgr.cxx:465
 TProofMgr.cxx:466
 TProofMgr.cxx:467
 TProofMgr.cxx:468
 TProofMgr.cxx:469
 TProofMgr.cxx:470
 TProofMgr.cxx:471
 TProofMgr.cxx:472
 TProofMgr.cxx:473
 TProofMgr.cxx:474
 TProofMgr.cxx:475
 TProofMgr.cxx:476
 TProofMgr.cxx:477
 TProofMgr.cxx:478
 TProofMgr.cxx:479
 TProofMgr.cxx:480
 TProofMgr.cxx:481
 TProofMgr.cxx:482
 TProofMgr.cxx:483
 TProofMgr.cxx:484
 TProofMgr.cxx:485
 TProofMgr.cxx:486
 TProofMgr.cxx:487
 TProofMgr.cxx:488
 TProofMgr.cxx:489
 TProofMgr.cxx:490
 TProofMgr.cxx:491
 TProofMgr.cxx:492
 TProofMgr.cxx:493
 TProofMgr.cxx:494
 TProofMgr.cxx:495
 TProofMgr.cxx:496
 TProofMgr.cxx:497
 TProofMgr.cxx:498
 TProofMgr.cxx:499
 TProofMgr.cxx:500
 TProofMgr.cxx:501
 TProofMgr.cxx:502
 TProofMgr.cxx:503
 TProofMgr.cxx:504
 TProofMgr.cxx:505
 TProofMgr.cxx:506
 TProofMgr.cxx:507
 TProofMgr.cxx:508
 TProofMgr.cxx:509
 TProofMgr.cxx:510
 TProofMgr.cxx:511
 TProofMgr.cxx:512
 TProofMgr.cxx:513
 TProofMgr.cxx:514
 TProofMgr.cxx:515
 TProofMgr.cxx:516
 TProofMgr.cxx:517
 TProofMgr.cxx:518
 TProofMgr.cxx:519
 TProofMgr.cxx:520
 TProofMgr.cxx:521
 TProofMgr.cxx:522
 TProofMgr.cxx:523
 TProofMgr.cxx:524
 TProofMgr.cxx:525
 TProofMgr.cxx:526
 TProofMgr.cxx:527
 TProofMgr.cxx:528
 TProofMgr.cxx:529
 TProofMgr.cxx:530
 TProofMgr.cxx:531
 TProofMgr.cxx:532
 TProofMgr.cxx:533
 TProofMgr.cxx:534
 TProofMgr.cxx:535
 TProofMgr.cxx:536
 TProofMgr.cxx:537
 TProofMgr.cxx:538
 TProofMgr.cxx:539
 TProofMgr.cxx:540
 TProofMgr.cxx:541
 TProofMgr.cxx:542
 TProofMgr.cxx:543
 TProofMgr.cxx:544
 TProofMgr.cxx:545
 TProofMgr.cxx:546
 TProofMgr.cxx:547
 TProofMgr.cxx:548
 TProofMgr.cxx:549
 TProofMgr.cxx:550
 TProofMgr.cxx:551
 TProofMgr.cxx:552
 TProofMgr.cxx:553
 TProofMgr.cxx:554
 TProofMgr.cxx:555
 TProofMgr.cxx:556
 TProofMgr.cxx:557
 TProofMgr.cxx:558
 TProofMgr.cxx:559
 TProofMgr.cxx:560
 TProofMgr.cxx:561
 TProofMgr.cxx:562
 TProofMgr.cxx:563
 TProofMgr.cxx:564
 TProofMgr.cxx:565
 TProofMgr.cxx:566
 TProofMgr.cxx:567
 TProofMgr.cxx:568
 TProofMgr.cxx:569
 TProofMgr.cxx:570
 TProofMgr.cxx:571
 TProofMgr.cxx:572
 TProofMgr.cxx:573
 TProofMgr.cxx:574
 TProofMgr.cxx:575
 TProofMgr.cxx:576
 TProofMgr.cxx:577
 TProofMgr.cxx:578
 TProofMgr.cxx:579
 TProofMgr.cxx:580
 TProofMgr.cxx:581
 TProofMgr.cxx:582
 TProofMgr.cxx:583
 TProofMgr.cxx:584
 TProofMgr.cxx:585
 TProofMgr.cxx:586
 TProofMgr.cxx:587
 TProofMgr.cxx:588
 TProofMgr.cxx:589
 TProofMgr.cxx:590
 TProofMgr.cxx:591
 TProofMgr.cxx:592
 TProofMgr.cxx:593
 TProofMgr.cxx:594
 TProofMgr.cxx:595
 TProofMgr.cxx:596
 TProofMgr.cxx:597
 TProofMgr.cxx:598
 TProofMgr.cxx:599
 TProofMgr.cxx:600
 TProofMgr.cxx:601
 TProofMgr.cxx:602
 TProofMgr.cxx:603
 TProofMgr.cxx:604
 TProofMgr.cxx:605
 TProofMgr.cxx:606
 TProofMgr.cxx:607
 TProofMgr.cxx:608
 TProofMgr.cxx:609
 TProofMgr.cxx:610
 TProofMgr.cxx:611
 TProofMgr.cxx:612
 TProofMgr.cxx:613
 TProofMgr.cxx:614
 TProofMgr.cxx:615
 TProofMgr.cxx:616
 TProofMgr.cxx:617
 TProofMgr.cxx:618
 TProofMgr.cxx:619
 TProofMgr.cxx:620
 TProofMgr.cxx:621
 TProofMgr.cxx:622
 TProofMgr.cxx:623
 TProofMgr.cxx:624
 TProofMgr.cxx:625
 TProofMgr.cxx:626
 TProofMgr.cxx:627
 TProofMgr.cxx:628
 TProofMgr.cxx:629
 TProofMgr.cxx:630
 TProofMgr.cxx:631
 TProofMgr.cxx:632
 TProofMgr.cxx:633
 TProofMgr.cxx:634
 TProofMgr.cxx:635
 TProofMgr.cxx:636
 TProofMgr.cxx:637
 TProofMgr.cxx:638
 TProofMgr.cxx:639
 TProofMgr.cxx:640
 TProofMgr.cxx:641
 TProofMgr.cxx:642
 TProofMgr.cxx:643
 TProofMgr.cxx:644
 TProofMgr.cxx:645
 TProofMgr.cxx:646
 TProofMgr.cxx:647
 TProofMgr.cxx:648
 TProofMgr.cxx:649
 TProofMgr.cxx:650
 TProofMgr.cxx:651
 TProofMgr.cxx:652
 TProofMgr.cxx:653
 TProofMgr.cxx:654
 TProofMgr.cxx:655
 TProofMgr.cxx:656
 TProofMgr.cxx:657
 TProofMgr.cxx:658
 TProofMgr.cxx:659
 TProofMgr.cxx:660
 TProofMgr.cxx:661
 TProofMgr.cxx:662
 TProofMgr.cxx:663
 TProofMgr.cxx:664
 TProofMgr.cxx:665
 TProofMgr.cxx:666
 TProofMgr.cxx:667
 TProofMgr.cxx:668
 TProofMgr.cxx:669
 TProofMgr.cxx:670
 TProofMgr.cxx:671
 TProofMgr.cxx:672
 TProofMgr.cxx:673
 TProofMgr.cxx:674
 TProofMgr.cxx:675
 TProofMgr.cxx:676
 TProofMgr.cxx:677
 TProofMgr.cxx:678
 TProofMgr.cxx:679
 TProofMgr.cxx:680
 TProofMgr.cxx:681
 TProofMgr.cxx:682
 TProofMgr.cxx:683
 TProofMgr.cxx:684
 TProofMgr.cxx:685
 TProofMgr.cxx:686
 TProofMgr.cxx:687
 TProofMgr.cxx:688
 TProofMgr.cxx:689
 TProofMgr.cxx:690
 TProofMgr.cxx:691
 TProofMgr.cxx:692
 TProofMgr.cxx:693
 TProofMgr.cxx:694
 TProofMgr.cxx:695
 TProofMgr.cxx:696
 TProofMgr.cxx:697
 TProofMgr.cxx:698
 TProofMgr.cxx:699
 TProofMgr.cxx:700
 TProofMgr.cxx:701
 TProofMgr.cxx:702
 TProofMgr.cxx:703
 TProofMgr.cxx:704
 TProofMgr.cxx:705
 TProofMgr.cxx:706
 TProofMgr.cxx:707
 TProofMgr.cxx:708
 TProofMgr.cxx:709
 TProofMgr.cxx:710
 TProofMgr.cxx:711
 TProofMgr.cxx:712
 TProofMgr.cxx:713
 TProofMgr.cxx:714
 TProofMgr.cxx:715
 TProofMgr.cxx:716
 TProofMgr.cxx:717
 TProofMgr.cxx:718
 TProofMgr.cxx:719
 TProofMgr.cxx:720
 TProofMgr.cxx:721
 TProofMgr.cxx:722
 TProofMgr.cxx:723
 TProofMgr.cxx:724
 TProofMgr.cxx:725
 TProofMgr.cxx:726
 TProofMgr.cxx:727
 TProofMgr.cxx:728
 TProofMgr.cxx:729
 TProofMgr.cxx:730
 TProofMgr.cxx:731
 TProofMgr.cxx:732
 TProofMgr.cxx:733
 TProofMgr.cxx:734
 TProofMgr.cxx:735
 TProofMgr.cxx:736
 TProofMgr.cxx:737
 TProofMgr.cxx:738
 TProofMgr.cxx:739
 TProofMgr.cxx:740
 TProofMgr.cxx:741
 TProofMgr.cxx:742
 TProofMgr.cxx:743
 TProofMgr.cxx:744
 TProofMgr.cxx:745
 TProofMgr.cxx:746
 TProofMgr.cxx:747
 TProofMgr.cxx:748
 TProofMgr.cxx:749
 TProofMgr.cxx:750
 TProofMgr.cxx:751
 TProofMgr.cxx:752
 TProofMgr.cxx:753
 TProofMgr.cxx:754
 TProofMgr.cxx:755
 TProofMgr.cxx:756
 TProofMgr.cxx:757
 TProofMgr.cxx:758
 TProofMgr.cxx:759
 TProofMgr.cxx:760
 TProofMgr.cxx:761
 TProofMgr.cxx:762
 TProofMgr.cxx:763
 TProofMgr.cxx:764
 TProofMgr.cxx:765
 TProofMgr.cxx:766
 TProofMgr.cxx:767
 TProofMgr.cxx:768
 TProofMgr.cxx:769
 TProofMgr.cxx:770
 TProofMgr.cxx:771
 TProofMgr.cxx:772
 TProofMgr.cxx:773
 TProofMgr.cxx:774
 TProofMgr.cxx:775
 TProofMgr.cxx:776
 TProofMgr.cxx:777
 TProofMgr.cxx:778
 TProofMgr.cxx:779
 TProofMgr.cxx:780
 TProofMgr.cxx:781
 TProofMgr.cxx:782
 TProofMgr.cxx:783
 TProofMgr.cxx:784
 TProofMgr.cxx:785
 TProofMgr.cxx:786
 TProofMgr.cxx:787
 TProofMgr.cxx:788
 TProofMgr.cxx:789
 TProofMgr.cxx:790
 TProofMgr.cxx:791
 TProofMgr.cxx:792
 TProofMgr.cxx:793
 TProofMgr.cxx:794
 TProofMgr.cxx:795
 TProofMgr.cxx:796
 TProofMgr.cxx:797
 TProofMgr.cxx:798
 TProofMgr.cxx:799
 TProofMgr.cxx:800
 TProofMgr.cxx:801
 TProofMgr.cxx:802
 TProofMgr.cxx:803
 TProofMgr.cxx:804
 TProofMgr.cxx:805
 TProofMgr.cxx:806
 TProofMgr.cxx:807
 TProofMgr.cxx:808
 TProofMgr.cxx:809
 TProofMgr.cxx:810
 TProofMgr.cxx:811
 TProofMgr.cxx:812
 TProofMgr.cxx:813
 TProofMgr.cxx:814
 TProofMgr.cxx:815
 TProofMgr.cxx:816
 TProofMgr.cxx:817
 TProofMgr.cxx:818
 TProofMgr.cxx:819
 TProofMgr.cxx:820
 TProofMgr.cxx:821
 TProofMgr.cxx:822
 TProofMgr.cxx:823
 TProofMgr.cxx:824
 TProofMgr.cxx:825
 TProofMgr.cxx:826
 TProofMgr.cxx:827
 TProofMgr.cxx:828
 TProofMgr.cxx:829
 TProofMgr.cxx:830
 TProofMgr.cxx:831
 TProofMgr.cxx:832
 TProofMgr.cxx:833
 TProofMgr.cxx:834
 TProofMgr.cxx:835
 TProofMgr.cxx:836
 TProofMgr.cxx:837
 TProofMgr.cxx:838
 TProofMgr.cxx:839
 TProofMgr.cxx:840
 TProofMgr.cxx:841
 TProofMgr.cxx:842
 TProofMgr.cxx:843
 TProofMgr.cxx:844
 TProofMgr.cxx:845
 TProofMgr.cxx:846
 TProofMgr.cxx:847
 TProofMgr.cxx:848
 TProofMgr.cxx:849
 TProofMgr.cxx:850
 TProofMgr.cxx:851
 TProofMgr.cxx:852
 TProofMgr.cxx:853
 TProofMgr.cxx:854
 TProofMgr.cxx:855
 TProofMgr.cxx:856
 TProofMgr.cxx:857
 TProofMgr.cxx:858
 TProofMgr.cxx:859
 TProofMgr.cxx:860
 TProofMgr.cxx:861
 TProofMgr.cxx:862
 TProofMgr.cxx:863
 TProofMgr.cxx:864
 TProofMgr.cxx:865
 TProofMgr.cxx:866
 TProofMgr.cxx:867
 TProofMgr.cxx:868
 TProofMgr.cxx:869
 TProofMgr.cxx:870
 TProofMgr.cxx:871
 TProofMgr.cxx:872
 TProofMgr.cxx:873
 TProofMgr.cxx:874
 TProofMgr.cxx:875
 TProofMgr.cxx:876
 TProofMgr.cxx:877
 TProofMgr.cxx:878
 TProofMgr.cxx:879
 TProofMgr.cxx:880
 TProofMgr.cxx:881
 TProofMgr.cxx:882
 TProofMgr.cxx:883
 TProofMgr.cxx:884
 TProofMgr.cxx:885
 TProofMgr.cxx:886
 TProofMgr.cxx:887
 TProofMgr.cxx:888
 TProofMgr.cxx:889
 TProofMgr.cxx:890
 TProofMgr.cxx:891
 TProofMgr.cxx:892
 TProofMgr.cxx:893
 TProofMgr.cxx:894
 TProofMgr.cxx:895
 TProofMgr.cxx:896
 TProofMgr.cxx:897
 TProofMgr.cxx:898
 TProofMgr.cxx:899
 TProofMgr.cxx:900
 TProofMgr.cxx:901
 TProofMgr.cxx:902
 TProofMgr.cxx:903
 TProofMgr.cxx:904
 TProofMgr.cxx:905
 TProofMgr.cxx:906
 TProofMgr.cxx:907
 TProofMgr.cxx:908
 TProofMgr.cxx:909
 TProofMgr.cxx:910
 TProofMgr.cxx:911
 TProofMgr.cxx:912
 TProofMgr.cxx:913
 TProofMgr.cxx:914
 TProofMgr.cxx:915
 TProofMgr.cxx:916
 TProofMgr.cxx:917
 TProofMgr.cxx:918
 TProofMgr.cxx:919
 TProofMgr.cxx:920
 TProofMgr.cxx:921
 TProofMgr.cxx:922
 TProofMgr.cxx:923
 TProofMgr.cxx:924
 TProofMgr.cxx:925
 TProofMgr.cxx:926
 TProofMgr.cxx:927
 TProofMgr.cxx:928
 TProofMgr.cxx:929
 TProofMgr.cxx:930
 TProofMgr.cxx:931
 TProofMgr.cxx:932
 TProofMgr.cxx:933
 TProofMgr.cxx:934
 TProofMgr.cxx:935
 TProofMgr.cxx:936
 TProofMgr.cxx:937
 TProofMgr.cxx:938
 TProofMgr.cxx:939
 TProofMgr.cxx:940
 TProofMgr.cxx:941
 TProofMgr.cxx:942
 TProofMgr.cxx:943
 TProofMgr.cxx:944
 TProofMgr.cxx:945
 TProofMgr.cxx:946
 TProofMgr.cxx:947
 TProofMgr.cxx:948
 TProofMgr.cxx:949
 TProofMgr.cxx:950
 TProofMgr.cxx:951
 TProofMgr.cxx:952
 TProofMgr.cxx:953
 TProofMgr.cxx:954
 TProofMgr.cxx:955
 TProofMgr.cxx:956
 TProofMgr.cxx:957
 TProofMgr.cxx:958
 TProofMgr.cxx:959
 TProofMgr.cxx:960
 TProofMgr.cxx:961
 TProofMgr.cxx:962
 TProofMgr.cxx:963
 TProofMgr.cxx:964
 TProofMgr.cxx:965
 TProofMgr.cxx:966
 TProofMgr.cxx:967
 TProofMgr.cxx:968
 TProofMgr.cxx:969
 TProofMgr.cxx:970
 TProofMgr.cxx:971
 TProofMgr.cxx:972
 TProofMgr.cxx:973
 TProofMgr.cxx:974
 TProofMgr.cxx:975
 TProofMgr.cxx:976
 TProofMgr.cxx:977
 TProofMgr.cxx:978
 TProofMgr.cxx:979
 TProofMgr.cxx:980
 TProofMgr.cxx:981
 TProofMgr.cxx:982
 TProofMgr.cxx:983
 TProofMgr.cxx:984
 TProofMgr.cxx:985
 TProofMgr.cxx:986
 TProofMgr.cxx:987
 TProofMgr.cxx:988
 TProofMgr.cxx:989
 TProofMgr.cxx:990
 TProofMgr.cxx:991
 TProofMgr.cxx:992
 TProofMgr.cxx:993
 TProofMgr.cxx:994
 TProofMgr.cxx:995
 TProofMgr.cxx:996
 TProofMgr.cxx:997
 TProofMgr.cxx:998
 TProofMgr.cxx:999
 TProofMgr.cxx:1000
 TProofMgr.cxx:1001
 TProofMgr.cxx:1002
 TProofMgr.cxx:1003
 TProofMgr.cxx:1004
 TProofMgr.cxx:1005
 TProofMgr.cxx:1006
 TProofMgr.cxx:1007
 TProofMgr.cxx:1008
 TProofMgr.cxx:1009
 TProofMgr.cxx:1010
 TProofMgr.cxx:1011
 TProofMgr.cxx:1012
 TProofMgr.cxx:1013
 TProofMgr.cxx:1014
 TProofMgr.cxx:1015
 TProofMgr.cxx:1016
 TProofMgr.cxx:1017
 TProofMgr.cxx:1018
 TProofMgr.cxx:1019
 TProofMgr.cxx:1020
 TProofMgr.cxx:1021
 TProofMgr.cxx:1022
 TProofMgr.cxx:1023
 TProofMgr.cxx:1024
 TProofMgr.cxx:1025
 TProofMgr.cxx:1026
 TProofMgr.cxx:1027
 TProofMgr.cxx:1028
 TProofMgr.cxx:1029
 TProofMgr.cxx:1030
 TProofMgr.cxx:1031
 TProofMgr.cxx:1032
 TProofMgr.cxx:1033
 TProofMgr.cxx:1034
 TProofMgr.cxx:1035
 TProofMgr.cxx:1036
 TProofMgr.cxx:1037
 TProofMgr.cxx:1038
 TProofMgr.cxx:1039
 TProofMgr.cxx:1040
 TProofMgr.cxx:1041
 TProofMgr.cxx:1042
 TProofMgr.cxx:1043
 TProofMgr.cxx:1044
 TProofMgr.cxx:1045
 TProofMgr.cxx:1046
 TProofMgr.cxx:1047
 TProofMgr.cxx:1048
 TProofMgr.cxx:1049
 TProofMgr.cxx:1050
 TProofMgr.cxx:1051
 TProofMgr.cxx:1052
 TProofMgr.cxx:1053
 TProofMgr.cxx:1054
 TProofMgr.cxx:1055
 TProofMgr.cxx:1056
 TProofMgr.cxx:1057
 TProofMgr.cxx:1058
 TProofMgr.cxx:1059
 TProofMgr.cxx:1060
 TProofMgr.cxx:1061
 TProofMgr.cxx:1062
 TProofMgr.cxx:1063
 TProofMgr.cxx:1064
 TProofMgr.cxx:1065
 TProofMgr.cxx:1066
 TProofMgr.cxx:1067
 TProofMgr.cxx:1068
 TProofMgr.cxx:1069
 TProofMgr.cxx:1070
 TProofMgr.cxx:1071
 TProofMgr.cxx:1072
 TProofMgr.cxx:1073
 TProofMgr.cxx:1074
 TProofMgr.cxx:1075
 TProofMgr.cxx:1076
 TProofMgr.cxx:1077
 TProofMgr.cxx:1078
 TProofMgr.cxx:1079
 TProofMgr.cxx:1080
 TProofMgr.cxx:1081
 TProofMgr.cxx:1082
 TProofMgr.cxx:1083
 TProofMgr.cxx:1084
 TProofMgr.cxx:1085
 TProofMgr.cxx:1086
 TProofMgr.cxx:1087
 TProofMgr.cxx:1088
 TProofMgr.cxx:1089
 TProofMgr.cxx:1090
 TProofMgr.cxx:1091
 TProofMgr.cxx:1092
 TProofMgr.cxx:1093
 TProofMgr.cxx:1094
 TProofMgr.cxx:1095
 TProofMgr.cxx:1096
 TProofMgr.cxx:1097
 TProofMgr.cxx:1098
 TProofMgr.cxx:1099
 TProofMgr.cxx:1100
 TProofMgr.cxx:1101
 TProofMgr.cxx:1102
 TProofMgr.cxx:1103
 TProofMgr.cxx:1104
 TProofMgr.cxx:1105