ROOT logo
// @(#)root/proofx:$Id$
// Author: Gerardo Ganis  12/12/2005

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TXProofMgr                                                           //
//                                                                      //
// 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 <errno.h>
#ifdef WIN32
#include <io.h>
#endif

#include "Getline.h"
#include "TList.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TProof.h"
#include "TProofLog.h"
#include "TXProofMgr.h"
#include "TXSocket.h"
#include "TXSocketHandler.h"
#include "TROOT.h"
#include "TStopwatch.h"
#include "TSysEvtHandler.h"
#include "XProofProtocol.h"

ClassImp(TXProofMgr)

//
//----- ProofMgr Interrupt signal handler
//
class TProofMgrInterruptHandler : public TSignalHandler {
private:
   TProofMgr *fMgr;

   TProofMgrInterruptHandler(const TProofMgrInterruptHandler&); // Not implemented
   TProofMgrInterruptHandler& operator=(const TProofMgrInterruptHandler&); // Not implemented
public:
   TProofMgrInterruptHandler(TProofMgr *mgr)
      : TSignalHandler(kSigInterrupt, kFALSE), fMgr(mgr) { }
   Bool_t Notify();
};

//______________________________________________________________________________
Bool_t TProofMgrInterruptHandler::Notify()
{
   // TProofMgr interrupt handler.

   // Only on clients
   if (isatty(0) != 0 && isatty(1) != 0) {
      TString u = fMgr->GetUrl();
      Printf("Opening new connection to %s", u.Data());
      TXSocket *s = new TXSocket(u, 'C', kPROOF_Protocol,
                                 kXPROOF_Protocol, 0, -1, (TXHandler *)fMgr);
      if (s && s->IsValid()) {
         // Set the interrupt flag on the server
         s->CtrlC();
      }
   }
   return kTRUE;
}

// Autoloading hooks.
// These are needed to avoid using the plugin manager which may create
// problems in multi-threaded environments.
TProofMgr *GetTXProofMgr(const char *url, Int_t l, const char *al)
{ return ((TProofMgr *) new TXProofMgr(url, l, al)); }

class TXProofMgrInit {
public:
   TXProofMgrInit() {
      TProofMgr::SetTXProofMgrHook(&GetTXProofMgr);
}};
static TXProofMgrInit gxproofmgr_init;

//______________________________________________________________________________
TXProofMgr::TXProofMgr(const char *url, Int_t dbg, const char *alias)
          : TProofMgr(url, dbg, alias)
{
   // Create a PROOF manager for the standard (old) environment.

   // Set the correct servert type
   fServType = kXProofd;

   // Initialize
   if (Init(dbg) != 0) {
      // Failure: make sure the socket is deleted so that its lack of
      // validity is correctly transmitted
      SafeDelete(fSocket);
   }
}

//______________________________________________________________________________
Int_t TXProofMgr::Init(Int_t)
{
   // Do real initialization: open the connection and set the relevant
   // variables.
   // Login and authentication are dealt with at this level, if required.
   // Return 0 in case of success, 1 if the remote server is a 'proofd',
   // -1 in case of error.

   // Here we make sure that the port is explicitly specified in the URL,
   // even when it matches the default value
   TString u = fUrl.GetUrl(kTRUE);

   fSocket = 0;
   if (!(fSocket = new TXSocket(u, 'C', kPROOF_Protocol,
                                kXPROOF_Protocol, 0, -1, this)) ||
       !(fSocket->IsValid())) {
      if (!fSocket || !(fSocket->IsServProofd()))
         if (gDebug > 0)
            Error("Init", "while opening the connection to %s - exit (error: %d)",
                          u.Data(), (fSocket ? fSocket->GetOpenError() : -1));
      if (fSocket && fSocket->IsServProofd())
         fServType = TProofMgr::kProofd;
      return -1;
   }

   // Protocol run by remote PROOF server
   fRemoteProtocol = fSocket->GetRemoteProtocol();

   // We add the manager itself for correct destruction
   {  R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Remove(fSocket);
   }

   // Set interrupt PROOF handler from now on
   fIntHandler = new TProofMgrInterruptHandler(this);

   // We are done
   return 0;
}

//______________________________________________________________________________
TXProofMgr::~TXProofMgr()
{
   // Destructor: close the connection

   SetInvalid();
}

//______________________________________________________________________________
void TXProofMgr::SetInvalid()
{
   // Invalidate this manager by closing the connection

   if (fSocket)
      fSocket->Close("P");
   SafeDelete(fSocket);

   // Avoid destroying twice
   {  R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Remove(this);
   }
}

//______________________________________________________________________________
TProof *TXProofMgr::AttachSession(TProofDesc *d, 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.

   if (!IsValid()) {
      Warning("AttachSession","invalid TXProofMgr - do nothing");
      return 0;
   }
   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();

   // Re-compose url
   TString u(Form("%s/?%d", fUrl.GetUrl(kTRUE), d->GetRemoteId()));

   // We need this to set correctly the kUsingSessionGui bit before the first
   // feedback messages arrive
   if (gui)
      u += "GUI";

   // Attach
   TProof *p = new TProof(u, 0, 0, gDebug, 0, this);
   if (p && p->IsValid()) {

      // Set reference manager
      p->SetManager(this);

      // Save record about this session
      Int_t st = (p->IsIdle()) ? TProofDesc::kIdle
                                 : TProofDesc::kRunning;
      d->SetStatus(st);
      d->SetProof(p);

      // Set session tag
      p->SetName(d->GetName());

   } else {
      // Session creation failed
      Error("AttachSession", "attaching to PROOF session");
   }
   return p;
}

//______________________________________________________________________________
void TXProofMgr::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 TXProofMgr - do nothing");
      return;
   }

   if (id > 0) {
      // Single session request
      TProofDesc *d = GetProofDesc(id);
      if (d) {
         if (fSocket)
            fSocket->DisconnectSession(d->GetRemoteId(), opt);
         TProof *p = d->GetProof();
         fSessions->Remove(d);
         SafeDelete(p);
         delete d;
      }
   } else if (id == 0) {

      // Requesto to destroy all sessions
      if (fSocket) {
         TString o = Form("%sA",opt);
         fSocket->DisconnectSession(-1, o);
      }
      if (fSessions) {
         // Delete PROOF sessions
         TIter nxd(fSessions);
         TProofDesc *d = 0;
         while ((d = (TProofDesc *)nxd())) {
            TProof *p = d->GetProof();
            SafeDelete(p);
         }
         fSessions->Delete();
      }
   }

   return;
}

//______________________________________________________________________________
void TXProofMgr::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 TXProofMgr - do nothing");
      return;
   }

   if (p) {
      // Single session request
      TProofDesc *d = GetProofDesc(p);
      if (d) {
         if (fSocket)
            fSocket->DisconnectSession(d->GetRemoteId(), opt);
         fSessions->Remove(d);
         p->Close(opt);
         delete d;
      }
   }

   return;
}

//______________________________________________________________________________
Bool_t TXProofMgr::MatchUrl(const char *url)
{
   // Checks if 'url' refers to the same 'user@host:port' entity as the URL
   // in memory. TProofMgr::MatchUrl cannot be used here because of the
   // 'double' default port, implying an additional check on the port effectively
   // open.

   if (!IsValid()) {
      Warning("MatchUrl","invalid TXProofMgr - do nothing");
      return 0;
   }

   TUrl u(url);

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

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

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

   // Match failed
   return kFALSE;
}

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

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

   // Send the request
   TObjString *os = fSocket->SendCoordinator(kQueryWorkers);
   if (os) {
      TObjArray *oa = TString(os->GetName()).Tokenize(TString("&"));
      if (oa) {
         TIter nxos(oa);
         TObjString *to = 0;
         while ((to = (TObjString *) nxos()))
            // Now parse them ...
            Printf("+  %s", to->GetName());
      }
   }
}

//______________________________________________________________________________
const char *TXProofMgr::GetMssUrl(Bool_t retrieve)
{
   // Gets the URL to be prepended to paths when accessing the MSS associated
   // with the connected cluster, if any. The information is retrieved from
   // the cluster the first time or if retrieve is true.

   if (fMssUrl.IsNull() || retrieve) {
      // Nothing to do if not in contact with proofserv
      if (!IsValid()) {
         Error("GetMssUrl", "invalid TXProofMgr - do nothing");
         return 0;
      }
      // Server may not support it
      if (fSocket->GetXrdProofdVersion() < 1007) {
         Error("GetMssUrl", "functionality not supported by server");
         return 0;
      }
      TObjString *os = fSocket->SendCoordinator(kQueryMssUrl);
      if (os) {
         Printf("os: '%s'", os->GetName());
         fMssUrl = os->GetName();
         SafeDelete(os);
      } else {
         Error("GetMssUrl", "problems retrieving the required information");
         return 0;
      }
   } else if (!IsValid()) {
      Warning("GetMssUrl", "TXProofMgr is now invalid: information may not be valid");
      return 0;
   }

   // Done
   return fMssUrl.Data();
}

//______________________________________________________________________________
TList *TXProofMgr::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;

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("QuerySessions","invalid TXProofMgr - do nothing");
      return 0;
   }

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

   // Send the request
   TList *ocl = new TList;
   TObjString *os = fSocket->SendCoordinator(kQuerySessions);
   if (os) {
      TObjArray *oa = TString(os->GetName()).Tokenize(TString("|"));
      if (oa) {
         TProofDesc *d = 0;
         TIter nxos(oa);
         TObjString *to = (TObjString *) nxos();
         if (to && to->GetString().IsDigit() && !strncasecmp(opt,"S",1))
            Printf("// +++ %s session(s) currently active +++", to->GetName());
         while ((to = (TObjString *) nxos())) {
            // Now parse them ...
            Int_t id = -1, st = -1;
            TString al, tg, tk;
            Ssiz_t from = 0;
            while (to->GetString()[from] == ' ') { from++; }
            if (!to->GetString().Tokenize(tk, from, " ") || !tk.IsDigit()) continue;
            id = tk.Atoi();
            if (!to->GetString().Tokenize(tg, from, " ")) continue;
            if (!to->GetString().Tokenize(al, from, " ")) continue;
            if (!to->GetString().Tokenize(tk, from, " ") || !tk.IsDigit()) continue;
            st = tk.Atoi();
            // Add to the list, if not already there
            if (!(d = (TProofDesc *) fSessions->FindObject(tg))) {
               Int_t locid = fSessions->GetSize() + 1;
               d = new TProofDesc(tg, al, GetUrl(), locid, id, st, 0);
               fSessions->Add(d);
            } else {
               // Set missing / update info
               d->SetStatus(st);
               d->SetRemoteId(id);
               d->SetTitle(al);
            }
            // Add to the list for final garbage collection
            ocl->Add(new TObjString(tg));
         }
         SafeDelete(oa);
      }
      SafeDelete(os);
   }

   // Printout and Garbage collection
   if (fSessions->GetSize() > 0) {
      TIter nxd(fSessions);
      TProofDesc *d = 0;
      while ((d = (TProofDesc *)nxd())) {
         if (ocl->FindObject(d->GetName())) {
            if (opt && !strncasecmp(opt,"S",1))
               d->Print("");
         } else {
            fSessions->Remove(d);
            SafeDelete(d);
         }
      }
   }

   // We are done
   return fSessions;
}

//_____________________________________________________________________________
Bool_t TXProofMgr::HandleInput(const void *)
{
   // Handle asynchronous input on the socket

   if (fSocket && fSocket->IsValid()) {
      TMessage *mess;
      if (fSocket->Recv(mess) >= 0) {
         Int_t what = mess->What();
         if (gDebug > 0)
            Info("HandleInput", "%p: got message type: %d", this, what);
         switch (what) {
            case kPROOF_TOUCH:
               fSocket->RemoteTouch();
               break;
            default:
               Warning("HandleInput", "%p: got unknown message type: %d", this, what);
               break;
         }
      }
   } else {
      Warning("HandleInput", "%p: got message but socket is invalid!", this);
   }

   // We are done
   return kTRUE;
}

//_____________________________________________________________________________
Bool_t TXProofMgr::HandleError(const void *in)
{
   // Handle error on the input socket

   XHandleErr_t *herr = in ? (XHandleErr_t *)in : 0;

   // Try reconnection
   if (fSocket && herr && (herr->fOpt == 1)) {
      fSocket->Reconnect();
      if (fSocket && fSocket->IsValid()) {
         if (gDebug > 0)
            Printf("ProofMgr: connection to coordinator at %s re-established",
                   fUrl.GetUrl());
         return kFALSE;
      }
   }
   Printf("TXProofMgr::HandleError: %p: got called ...", this);

   // Interrupt any PROOF session in Collect
   if (fSessions && fSessions->GetSize() > 0) {
      TIter nxd(fSessions);
      TProofDesc *d = 0;
      while ((d = (TProofDesc *)nxd())) {
         TProof *p = (TProof *) d->GetProof();
         if (p)
            p->InterruptCurrentMonitor();
      }
   }
   if (gDebug > 0)
      Printf("TXProofMgr::HandleError: %p: DONE ... ", this);

   // We are done
   return kTRUE;
}

//______________________________________________________________________________
Int_t TXProofMgr::Reset(Bool_t hard, const char *usr)
{
   // Send a cleanup request for the sessions associated with the current user.
   // If 'hard' is true sessions are signalled for termination and moved to
   // terminate at all stages (top master, sub-master, workers). Otherwise
   // (default) only top-master sessions are asked to terminate, triggering
   // a gentle session termination. In all cases all sessions should be gone
   // after a few (2 or 3) session checking cycles.
   // A user with superuser privileges can also asks cleaning for an different
   // user, specified by 'usr', or for all users (usr = *)
   // Return 0 on success, -1 in case of error.

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("Reset","invalid TXProofMgr - do nothing");
      return -1;
   }

   Int_t h = (hard) ? 1 : 0;
   fSocket->SendCoordinator(kCleanupSessions, usr, h);

   return 0;
}

//_____________________________________________________________________________
TProofLog *TXProofMgr::GetSessionLogs(Int_t isess, const char *stag,
                                      const char *pattern, Bool_t rescan)
{
   // Get logs or log tails from last session associated with this manager
   // instance.
   // The arguments allow to specify a session different from the last one:
   //      isess   specifies a position relative to the last one, i.e. 1
   //              for the next to last session; the absolute value is taken
   //              so -1 and 1 are equivalent.
   //      stag    specifies the unique tag of the wanted session
   // The special value stag = "NR" allows to just initialize the TProofLog
   // object w/o retrieving the files; this may be useful when the number
   // of workers is large and only a subset of logs is required.
   // If 'stag' is specified 'isess' is ignored (unless stag = "NR").
   // If 'pattern' is specified only the lines containing it are retrieved
   // (remote grep functionality); to filter out a pattern 'pat' use
   // pattern = "-v pat".
   // If 'rescan' is TRUE, masters will rescan the worker sandboxes for the exact
   // paths, instead of using the save information; may be useful when the 
   // ssave information looks wrong or incomplete. 
   // Returns a TProofLog object (to be deleted by the caller) on success,
   // 0 if something wrong happened.

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("GetSessionLogs","invalid TXProofMgr - do nothing");
      return 0;
   }

   TProofLog *pl = 0;

   // The absolute value of isess counts
   isess = (isess > 0) ? -isess : isess;

   // Special option in stag
   bool retrieve = 1;
   TString sesstag(stag);
   if (sesstag == "NR") {
      retrieve = 0;
      sesstag = "";
   }

   // Get the list of paths
   Int_t xrs = (rescan) ? 1 : 0;
   TObjString *os = fSocket->SendCoordinator(kQueryLogPaths, sesstag.Data(), isess, -1, xrs);

   // Analyse it now
   Int_t ii = 0;
   if (os) {
      TString rs(os->GetName());
      Ssiz_t from = 0;
      // The session tag
      TString tag;
      if (!rs.Tokenize(tag, from, "|")) {
         Warning("GetSessionLogs", "Session tag undefined: corruption?\n"
                                   " (received string: %s)", os->GetName());
         return (TProofLog *)0;
      }
      // The pool url
      TString purl;
      if (!rs.Tokenize(purl, from, "|")) {
         Warning("GetSessionLogs", "Pool URL undefined: corruption?\n"
                                   " (received string: %s)", os->GetName());
         return (TProofLog *)0;
      }
      // Create the instance now
      if (!pl)
         pl = new TProofLog(tag, GetUrl(), this);

      // Per-node info
      TString to;
      while (rs.Tokenize(to, from, "|")) {
         if (!to.IsNull()) {
            TString ord(to);
            ord.Strip(TString::kLeading, ' ');
            TString url(ord);
            if ((ii = ord.Index(" ")) != kNPOS)
               ord.Remove(ii);
            if ((ii = url.Index(" ")) != kNPOS)
               url.Remove(0, ii + 1);
            // Add to the list (special tag for valgrind outputs)
            if (url.Contains(".valgrind")) ord += "-valgrind";
            pl->Add(ord, url);
            // Notify
            if (gDebug > 1)
               Info("GetSessionLogs", "ord: %s, url: %s", ord.Data(), url.Data());
         }
      }
      // Cleanup
      SafeDelete(os);
      // Retrieve the default part if required
      if (pl && retrieve) {
         const char *pat = pattern ? pattern : "-v \"| SvcMsg\"";
         if (pat && strlen(pat) > 0)
            pl->Retrieve("*", TProofLog::kGrep, 0, pat);
         else
            pl->Retrieve();
      }
   }

   // Done
   return pl;
}

//______________________________________________________________________________
TObjString *TXProofMgr::ReadBuffer(const char *fin, Long64_t ofs, Int_t len)
{
   // Read, via the coordinator, 'len' bytes from offset 'ofs' of 'file'.
   // Returns a TObjString with the content or 0, in case of failure

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("ReadBuffer","invalid TXProofMgr - do nothing");
      return (TObjString *)0;
   }

   // Send the request
   return fSocket->SendCoordinator(kReadBuffer, fin, len, ofs, 0);
}

//______________________________________________________________________________
TObjString *TXProofMgr::ReadBuffer(const char *fin, const char *pattern)
{
   // Read, via the coordinator, 'fin' filtered. If 'pattern' starts with '|',
   // it represents a command filtering the output. Elsewhere, it is a grep
   // pattern. Returns a TObjString with the content or 0 in case of failure

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("ReadBuffer", "invalid TXProofMgr - do nothing");
      return (TObjString *)0;
   }

   const char *ptr;
   Int_t type;  // 1 = grep, 2 = grep -v, 3 = pipe through cmd
   if (*pattern == '|') {
      ptr = &pattern[1];  // strip first char if it is a command
      type = 3;
   }
   else {
      ptr = pattern;
      type = 1;
   }

   // Prepare the buffer
   Int_t plen = strlen(ptr);
   Int_t lfi = strlen(fin);
   char *buf = new char[lfi + plen + 1];
   memcpy(buf, fin, lfi);
   memcpy(buf+lfi, ptr, plen);
   buf[lfi+plen] = 0;

   // Send the request
   return fSocket->SendCoordinator(kReadBuffer, buf, plen, 0, type);
}

//______________________________________________________________________________
void TXProofMgr::ShowROOTVersions()
{
   // Display what ROOT versions are available on the cluster

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("ShowROOTVersions","invalid TXProofMgr - do nothing");
      return;
   }

   // Send the request
   TObjString *os = fSocket->SendCoordinator(kQueryROOTVersions);
   if (os) {
      // Display it
      Printf("----------------------------------------------------------\n");
      Printf("Available versions (tag ROOT-vers remote-path PROOF-version):\n");
      Printf("%s", os->GetName());
      Printf("----------------------------------------------------------");
      SafeDelete(os);
   }

   // We are done
   return;
}

//______________________________________________________________________________
Int_t TXProofMgr::SetROOTVersion(const char *tag)
{
   // Set the default ROOT version to be used

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Warning("SetROOTVersion","invalid TXProofMgr - do nothing");
      return -1;
   }

   // Send the request
   fSocket->SendCoordinator(kROOTVersion, tag);

   // We are done
   return (fSocket->GetOpenError() != kXR_noErrorYet) ? -1 : 0;
}

//______________________________________________________________________________
Int_t TXProofMgr::SendMsgToUsers(const char *msg, const char *usr)
{
   // 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

   Int_t rc = 0;

   // Check input
   if (!msg || strlen(msg) <= 0) {
      Error("SendMsgToUsers","no message to send - do nothing");
      return -1;
   }

   // Buffer (max 32K)
   const Int_t kMAXBUF = 32768;
   char buf[kMAXBUF] = {0};
   char *p = &buf[0];
   size_t space = kMAXBUF - 1;
   Int_t lusr = 0;

   // A specific user?
   if (usr && strlen(usr) > 0 && (strlen(usr) != 1 || usr[0] != '*')) {
      lusr = (strlen(usr) + 3);
      snprintf(buf, kMAXBUF, "u:%s ", usr);
      p += lusr;
      space -= lusr;
   }

   ssize_t len = 0;
   // Is it from file ?
   if (!gSystem->AccessPathName(msg, kFileExists)) {
      // From file: can we read it ?
      if (gSystem->AccessPathName(msg, kReadPermission)) {
         Error("SendMsgToUsers","request to read message from unreadable file '%s'", msg);
         return -1;
      }
      // Open the file
      FILE *f = 0;
      if (!(f = fopen(msg, "r"))) {
         Error("SendMsgToUsers", "file '%s' cannot be open", msg);
         return -1;
      }
      // Determine the number of bytes to be read from the file.
      size_t left = 0;
      off_t rcsk = lseek(fileno(f), (off_t) 0, SEEK_END);
      if ((rcsk != (off_t)(-1))) {
         left = (size_t) rcsk;
         if ((lseek(fileno(f), (off_t) 0, SEEK_SET) == (off_t)(-1))) {
            Error("SendMsgToUsers", "cannot rewind open file (seek to 0)");
            fclose(f);      
            return -1;
         }
      } else {
         Error("SendMsgToUsers", "cannot get size of open file (seek to END)");
         fclose(f);      
         return -1;
      }
      // Now readout from file
      size_t wanted = left;
      if (wanted > space) {
         wanted = space;
         Warning("SendMsgToUsers",
                 "requested to send %lld bytes: max size is %lld bytes: truncating",
                 (Long64_t)left, (Long64_t)space);
      }
      do {
         while ((len = read(fileno(f), p, wanted)) < 0 &&
                  TSystem::GetErrno() == EINTR)
            TSystem::ResetErrno();
         if (len < 0) {
            SysError("SendMsgToUsers", "error reading file");
            break;
         }

         // Update counters
         left = (len >= (ssize_t)left) ? 0 : left - len;
         p += len;
         wanted = (left > kMAXBUF-1) ? kMAXBUF-1 : left;

      } while (len > 0 && left > 0);
      // Close file
      fclose(f);
   } else {
      // Add the message to the buffer
      len = strlen(msg);
      if (len > (ssize_t)space) {
         Warning("SendMsgToUsers",
                 "requested to send %lld bytes: max size is %lld bytes: truncating",
                 (Long64_t)len, (Long64_t)space);
         len = space;
      }
      memcpy(p, msg, len);
   }

   // Null-terminate
   buf[len + lusr] = 0;

   // Send the request
   fSocket->SendCoordinator(kSendMsgToUser, buf);

   return rc;
}

//______________________________________________________________________________
void TXProofMgr::Grep(const char *what, const char *how, const char *where)
{
   // Run 'grep' on the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Grep","invalid TXProofMgr - do nothing");
      return;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Grep", "functionality not supported by server");
      return;
   }

   // Send the request
   TObjString *os = Exec(kGrep, what, how, where);

   // Show the result, if any
   if (os) Printf("%s", os->GetName());

   // Cleanup
   SafeDelete(os);
}

//______________________________________________________________________________
void TXProofMgr::Find(const char *what, const char *how, const char *where)
{
   // Run 'find' on the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Find","invalid TXProofMgr - do nothing");
      return;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Find", "functionality not supported by server (XrdProofd version: %d)",
                     fSocket->GetXrdProofdVersion());
      return;
   }

   // Send the request
   TObjString *os = Exec(kFind, what, how, where);

   // Show the result, if any
   if (os) Printf("%s", os->GetName());

   // Cleanup
   SafeDelete(os);
}

//______________________________________________________________________________
void TXProofMgr::Ls(const char *what, const char *how, const char *where)
{
   // Run 'ls' on the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Ls","invalid TXProofMgr - do nothing");
      return;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Ls", "functionality not supported by server");
      return;
   }

   // Send the request
   TObjString *os = Exec(kLs, what, how, where);

   // Show the result, if any
   if (os) Printf("%s", os->GetName());

   // Cleanup
   SafeDelete(os);
}

//______________________________________________________________________________
void TXProofMgr::More(const char *what, const char *how, const char *where)
{
   // Run 'more' on the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("More","invalid TXProofMgr - do nothing");
      return;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("More", "functionality not supported by server");
      return;
   }

   // Send the request
   TObjString *os = Exec(kMore, what, how, where);

   // Show the result, if any
   if (os) Printf("%s", os->GetName());

   // Cleanup
   SafeDelete(os);
}

//______________________________________________________________________________
Int_t TXProofMgr::Rm(const char *what, const char *how, const char *where)
{
   // Run 'rm' on the nodes. The user is prompted before removal, unless 'how'
   // contains "--force" or a combination of single letter options including 'f',
   // e.g. "-fv".

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Rm","invalid TXProofMgr - do nothing");
      return -1;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Rm", "functionality not supported by server");
      return -1;
   }

   TString prompt, ans("Y"), opt(how);
   Bool_t force = kFALSE;
   if (!opt.IsNull()) {
      TString t;
      Int_t from = 0;
      while (!force && opt.Tokenize(t, from, " ")) {
         if (t == "--force") {
            force = kTRUE;
         } else if (t.BeginsWith("-") && !t.BeginsWith("--") && t.Contains("f")) {
            force = kTRUE;
         }
      }
   }

   if (!force && isatty(0) != 0 && isatty(1) != 0) {
      // Really remove the file?
      prompt.Form("Do you really want to remove '%s'? [N/y]", what);
      ans = "";
      while (ans != "N" && ans != "Y") {
         ans = Getline(prompt.Data());
         ans.Remove(TString::kTrailing, '\n');
         if (ans == "") ans = "N";
         ans.ToUpper();
         if (ans != "N" && ans != "Y")
            Printf("Please answer y, Y, n or N");
      }
   }

   if (ans == "Y") {
      // Send the request
      TObjString *os = Exec(kRm, what, how, where);
      // Show the result, if any
      if (os) {
         if (gDebug > 1) Printf("%s", os->GetName());
         // Cleanup
         SafeDelete(os);
         // Success
         return 0;
      }
      // Failure
      return -1;
   }
   // Done
   return 0;
}

//______________________________________________________________________________
void TXProofMgr::Tail(const char *what, const char *how, const char *where)
{
   // Run 'tail' on the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Tail","invalid TXProofMgr - do nothing");
      return;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Tail", "functionality not supported by server");
      return;
   }

   // Send the request
   TObjString *os = Exec(kTail, what, how, where);

   // Show the result, if any
   if (os) Printf("%s", os->GetName());

   // Cleanup
   SafeDelete(os);
}

//______________________________________________________________________________
Int_t TXProofMgr::Md5sum(const char *what, TString &sum, const char *where)
{
   // Run 'md5sum' on one of the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Md5sum","invalid TXProofMgr - do nothing");
      return -1;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Md5sum", "functionality not supported by server");
      return -1;
   }

   if (where && !strcmp(where, "all")) {
      Error("Md5sum","cannot run on all nodes at once: please specify one");
      return -1;
   }

   // Send the request
   TObjString *os = Exec(kMd5sum, what, 0, where);

   // Show the result, if any
   if (os) {
      if (gDebug > 1) Printf("%s", os->GetName());
      sum = os->GetName();
      // Cleanup
      SafeDelete(os);
      // Success
      return 0;
   }
   // Failure
   return -1;
}

//______________________________________________________________________________
Int_t TXProofMgr::Stat(const char *what, FileStat_t &st, const char *where)
{
   // Run 'stat' on one of the nodes

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Stat","invalid TXProofMgr - do nothing");
      return -1;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Stat", "functionality not supported by server");
      return -1;
   }

   if (where && !strcmp(where, "all")) {
      Error("Stat","cannot run on all nodes at once: please specify one");
      return -1;
   }

   // Send the request
   TObjString *os = Exec(kStat, what, 0, where);

   // Show the result, if any
   if (os) {
      if (gDebug > 1) Printf("%s", os->GetName());
#if 0
      Int_t    mode, uid, gid, islink;
      Long_t   dev, ino, mtime;
      Long64_t size;
#ifdef R__WIN32
      sscanf(os->GetName(), "%ld %ld %d %d %d %I64d %ld %d", &dev, &ino, &mode,
                            &uid, &gid, &size, &mtime, &islink);
#else
      sscanf(os->GetName(), "%ld %ld %d %d %d %lld %ld %d", &dev, &ino, &mode,
                            &uid, &gid, &size, &mtime, &islink);
#endif
      if (dev == -1)
         return -1;
      st.fDev    = dev;
      st.fIno    = ino;
      st.fMode   = mode;
      st.fUid    = uid;
      st.fGid    = gid;
      st.fSize   = size;
      st.fMtime  = mtime;
      st.fIsLink = (islink == 1);
#else
      TString tkn;
      Ssiz_t from = 0;
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fDev = tkn.Atoi();
      if (st.fDev == -1) return -1;
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fIno = tkn.Atoi();
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fMode = tkn.Atoi();
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fUid = tkn.Atoi();
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fGid = tkn.Atoi();
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fSize = tkn.Atoll();
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fMtime = tkn.Atoi();
      if (!os->GetString().Tokenize(tkn, from, "[ ]+") || !tkn.IsDigit()) return -1;
      st.fIsLink = (tkn.Atoi() == 1) ? kTRUE : kFALSE;
#endif

      // Cleanup
      SafeDelete(os);
      // Success
      return 0;
   }
   // Failure
   return -1;
}

//______________________________________________________________________________
TObjString *TXProofMgr::Exec(Int_t action,
                             const char *what, const char *how, const char *where)
{
   // Execute 'action' (see EAdminExecType in 'XProofProtocol.h') at 'where'
   // (default master), with options 'how', on 'what'. The option specified by
   // 'how' are typically unix option for the relate commands. In addition to
   // the unix authorizations, the limitations are:
   //
   //      action = kRm        limited to the sandbox (but basic dirs cannot be
   //                          removed) and on files owned by the user in the
   //                          allowed directories
   //      action = kTail      option '-f' is not supported and will be ignored
   //

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Exec","invalid TXProofMgr - do nothing");
      return (TObjString *)0;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Exec", "functionality not supported by server");
      return (TObjString *)0;
   }
   // Check 'what'
   if (!what || strlen(what) <= 0) {
      Error("Exec","specifying a path is mandatory");
      return (TObjString *)0;
   }
   // Check the options
   TString opt(how);
   if (action == kTail && !opt.IsNull()) {
      // Keep only static options: -c, --bytes=N, -n , --lines=N, -N
      TString opts(how), o;
      Int_t from = 0;
      Bool_t isc = kFALSE, isn = kFALSE;
      while (opts.Tokenize(o, from, " ")) {
         // Skip values not starting with '-' is not argument to '-c' or '-n'
         if (!o.BeginsWith("-") && !isc && isn) continue;
         if (isc) {
            opt.Form("-c %s", o.Data());
            isc = kFALSE;
         }
         if (isn) {
            opt.Form("-n %s", o.Data());
            isn = kFALSE;
         }
         if (o == "-c") {
            isc = kTRUE;
         } else if (o == "-n") {
            isn = kTRUE;
         } else if (o == "--bytes=" || o == "--lines=") {
            opt = o;
         } else if (o.BeginsWith("-")) {
            o.Remove(TString::kLeading,'-');
            if (o.IsDigit()) opt.Form("-%s", o.Data());
         }
      }
   }

   // Build the command line
   TString cmd(where);
   if (cmd.IsNull()) cmd.Form("%s:%d", fUrl.GetHost(), fUrl.GetPort());
   cmd += "|";
   cmd += what;
   cmd += "|";
   cmd += opt;

   // On clients, handle Ctrl-C during collection
   if (fIntHandler) fIntHandler->Add();

   // Send the request
   TObjString *os = fSocket->SendCoordinator(kExec, cmd.Data(), action);

   // On clients, handle Ctrl-C during collection
   if (fIntHandler) fIntHandler->Remove();

   // Done
   return os;
}

//______________________________________________________________________________
Int_t TXProofMgr::GetFile(const char *remote, const char *local, const char *opt)
{
   // Get file 'remote' into 'local' from the master.
   // If opt contains "force", the file, if it exists remotely, is copied in all cases,
   // otherwise a check is done on the MD5sum.
   // If opt contains "silent" standard notificatons are not printed (errors and
   // warnings and prompts still are).
   // Return 0 on success, -1 on error.

   Int_t rc = -1;
   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("GetFile", "invalid TXProofMgr - do nothing");
      return rc;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("GetFile", "functionality not supported by server");
      return rc;
   }

   // Check remote path name
   TString filerem(remote);
   if (filerem.IsNull()) {
      Error("GetFile", "remote file path undefined");
      return rc;
   }

   // Parse option
   TString oo(opt);
   oo.ToUpper();
   Bool_t force = (oo.Contains("FORCE")) ? kTRUE : kFALSE;
   Bool_t silent = (oo.Contains("SILENT")) ? kTRUE : kFALSE;

   // Check local path name
   TString fileloc(local);
   if (fileloc.IsNull()) {
      // Set the same as the remote one, in the working dir
      fileloc = gSystem->BaseName(filerem);
   }
   gSystem->ExpandPathName(fileloc);

   // Default open and mode flags
#ifdef WIN32
   UInt_t openflags =  O_WRONLY | O_BINARY;
#else
   UInt_t openflags =  O_WRONLY;
#endif
   UInt_t openmode = 0600;

   // Get information about the local file
   UserGroup_t *ugloc = 0;
   Int_t rcloc = 0;
   FileStat_t stloc;
   if ((rcloc = gSystem->GetPathInfo(fileloc, stloc)) == 0) {
      if (R_ISDIR(stloc.fMode)) {
         // Add the filename of the remote file and re-check
         if (!fileloc.EndsWith("/")) fileloc += "/";
         fileloc += gSystem->BaseName(filerem);
         // Get again the status of the path
         rcloc = gSystem->GetPathInfo(fileloc, stloc);
      }
      if (rcloc == 0) {
         // It exists already. If it is not a regular file we cannot continue
         if (!R_ISREG(stloc.fMode)) {
            if (!silent)
               Printf("[GetFile] local file '%s' exists and is not regular: cannot continue",
                      fileloc.Data());
            return rc;
         }
         // Get our info
         if (!(ugloc = gSystem->GetUserInfo(gSystem->GetUid()))) {
            Error("GetFile", "cannot get user info for additional checks");
            return rc;
         }
         // Can we delete or overwrite it ?
         Bool_t owner = (ugloc->fUid == stloc.fUid && ugloc->fGid == stloc.fGid) ? kTRUE : kFALSE;
         Bool_t group = (!owner && ugloc->fGid == stloc.fGid) ? kTRUE : kFALSE;
         Bool_t other = (!owner && !group) ? kTRUE : kFALSE;
         delete ugloc;
         if ((owner && !(stloc.fMode & kS_IWUSR)) ||
             (group && !(stloc.fMode & kS_IWGRP)) || (other && !(stloc.fMode & kS_IWOTH))) {
            if (!silent) {
               Printf("[GetFile] file '%s' exists: no permission to delete or overwrite the file", fileloc.Data());
               Printf("[GetFile] ownership: owner: %d, group: %d, other: %d", owner, group, other);
               Printf("[GetFile] mode: %x", stloc.fMode);
            }
            return rc;
         }
         // In case we open the file, we need to truncate it
         openflags |=  O_CREAT | O_TRUNC;
      } else {
         // In case we open the file, we need to create it
         openflags |=  O_CREAT;
      }
   } else {
      // In case we open the file, we need to create it
      openflags |=  O_CREAT;
   }

   // Check the remote file exists and get it check sum
   TString remsum;
   if (Md5sum(filerem, remsum) != 0) {
      if (!silent)
         Printf("[GetFile] remote file '%s' does not exists or cannot be read", filerem.Data());
      return rc;
   }

   // If the file exists already locally, check if it is different
   bool same = 0;
   if (rcloc == 0 && !force) {
      TMD5 *md5loc = TMD5::FileChecksum(fileloc);
      if (md5loc) {
         if (remsum == md5loc->AsString()) {
            if (!silent) {
               Printf("[GetFile] local file '%s' and remote file '%s' have the same MD5 check sum",
                      fileloc.Data(), filerem.Data());
               Printf("[GetFile] use option 'force' to override");
            }
            same = 1;
         }
         delete md5loc;
      }

      // If a different file with the same name exists already, ask what to do
      if (!same) {
         const char *a = Getline("Local file exists already: would you like to overwrite it? [N/y]");
         if (a[0] == 'n' || a[0] == 'N' || a[0] == '\0') return 0;
      } else {
         return 0;
      }
   }

   // Open the local file for writing
   Int_t fdout = open(fileloc, openflags, openmode);
   if (fdout < 0) {
      Error("GetFile", "could not open local file '%s' for writing: errno: %d", local, errno);
      return rc;
   }

   // Build the command line
   TString cmd(filerem);

   // Disable TXSocket handling while receiving the file (CpProgress processes
   // pending events and this could screw-up synchronization in the TXSocket pipe)
   gSystem->RemoveFileHandler(TXSocketHandler::GetSocketHandler());

   // Send the request
   TStopwatch watch;
   watch.Start();
   TObjString *os = fSocket->SendCoordinator(kGetFile, cmd.Data());

   if (os) {
      // The message contains the size
      TString ssz(os->GetName());
      ssz.ReplaceAll(" ", "");
      if (!ssz.IsDigit()) {
         Error("GetFile", "received non-digit size string: '%s' ('%s')", os->GetName(), ssz.Data());
         close(fdout);
         return rc;
      }
      Long64_t size = ssz.Atoll();
      if (size <= 0) {
         Error("GetFile", "received null or negative size: %lld", size);
         close(fdout);
         return rc;
      }

      // Receive the file
      const Int_t kMAXBUF = 16384;  //32768  //16384  //65536;
      char buf[kMAXBUF];

      rc = 0;
      Int_t rec, r;
      Long64_t filesize = 0, left = 0;
      while (rc == 0 && filesize < size) {
         left = size - filesize;
         if (left > kMAXBUF) left = kMAXBUF;
         rec = fSocket->RecvRaw(&buf, left);
         filesize = (rec > 0) ? (filesize + rec) : filesize;
         if (rec > 0) {
            char *p = buf;
            r = rec;
            while (r) {
               Int_t w = 0;
               while ((w = write(fdout, p, r)) < 0 && TSystem::GetErrno() == EINTR)
                  TSystem::ResetErrno();
               if (w < 0) {
                  SysError("GetFile", "error writing to unit: %d", fdout);
                  rc = -1;
                  break;
               }
               r -= w;
               p += w;
            }
            // Basic progress bar
            CpProgress("GetFile", filesize, size, &watch);
         } else if (rec < 0) {
            rc = -1;
            Error("GetFile", "error during receiving file");
            break;
         }
      }
      // Finalize the progress bar
      CpProgress("GetFile", filesize, size, &watch, kTRUE);

   } else {
      Error("GetFile", "size not received");
      rc = -1;
   }

   // Restore socket handling while receiving the file
   gSystem->AddFileHandler(TXSocketHandler::GetSocketHandler());

   // Close local file
   close(fdout);
   watch.Stop();
   watch.Reset();

   if (rc == 0) {
      // Check if everything went fine
      TMD5 *md5loc = TMD5::FileChecksum(fileloc);
      if (!md5loc) {
         Error("GetFile", "cannot get MD5 checksum of the new local file '%s'", fileloc.Data());
         rc = -1;
      } else if (remsum != md5loc->AsString()) {
         Error("GetFile", "checksums for the local copy and the remote file differ: {rem:%s,loc:%s}",
                           remsum.Data(), md5loc->AsString());
         rc = -1;
         delete md5loc;
      }
   }
   // Done
   return rc;
}

//______________________________________________________________________________
Int_t TXProofMgr::PutFile(const char *local, const char *remote, const char *opt)
{
   // Put file 'local'to 'remote' to the master
   // If opt is "force", the file, if it exists remotely, is copied in all cases,
   // otherwise a check is done on the MD5sum.
   // Return 0 on success, -1 on error

   Int_t rc = -1;
   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("PutFile", "invalid TXProofMgr - do nothing");
      return rc;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("PutFile", "functionality not supported by server");
      return rc;
   }

   // Check local path name
   TString fileloc(local);
   if (fileloc.IsNull()) {
      Error("PutFile", "local file path undefined");
      return rc;
   }
   gSystem->ExpandPathName(fileloc);

   // Parse option
   TString oo(opt);
   oo.ToUpper();
   Bool_t force = (oo == "FORCE") ? kTRUE : kFALSE;

   // Check remote path name
   TString filerem(remote);
   if (filerem.IsNull()) {
      // Set the same as the local one, in the working dir
      filerem.Form("~/%s", gSystem->BaseName(fileloc));
   } else if (filerem.EndsWith("/")) {
      // Remote path is a directory: add the file name as in the local one
      filerem += gSystem->BaseName(fileloc);
   }

   // Default open flags
#ifdef WIN32
   UInt_t openflags =  O_RDONLY | O_BINARY;
#else
   UInt_t openflags =  O_RDONLY;
#endif

   // Get information about the local file
   Int_t rcloc = 0;
   FileStat_t stloc;
   if ((rcloc = gSystem->GetPathInfo(fileloc, stloc)) != 0 || !R_ISREG(stloc.fMode)) {
      // It dies not exists or it is not a regular file: we cannot continue
      const char *why = (rcloc == 0) ? "is not regular" : "does not exists";
      Printf("[PutFile] local file '%s' %s: cannot continue", fileloc.Data(), why);
      return rc;
   }
   // Get our info
   UserGroup_t *ugloc = 0;
   if (!(ugloc = gSystem->GetUserInfo(gSystem->GetUid()))) {
      Error("PutFile", "cannot get user info for additional checks");
      return rc;
   }
   // Can we read it ?
   Bool_t owner = (ugloc->fUid == stloc.fUid && ugloc->fGid == stloc.fGid) ? kTRUE : kFALSE;
   Bool_t group = (!owner && ugloc->fGid == stloc.fGid) ? kTRUE : kFALSE;
   Bool_t other = (!owner && !group) ? kTRUE : kFALSE;
   delete ugloc;
   if ((owner && !(stloc.fMode & kS_IRUSR)) ||
       (group && !(stloc.fMode & kS_IRGRP)) || (other && !(stloc.fMode & kS_IROTH))) {
      Printf("[PutFile] file '%s': no permission to read the file", fileloc.Data());
      Printf("[PutFile] ownership: owner: %d, group: %d, other: %d", owner, group, other);
      Printf("[PutFile] mode: %x", stloc.fMode);
      return rc;
   }

   // Local MD5 sum
   TString locsum;
   TMD5 *md5loc = TMD5::FileChecksum(fileloc);
   if (!md5loc) {
      Error("PutFile", "cannot calculate the check sum for '%s'", fileloc.Data());
      return rc;
   } else {
      locsum = md5loc->AsString();
      delete md5loc;
   }

   // Check the remote file exists and get it check sum
   Bool_t same = kFALSE;
   FileStat_t strem;
   TString remsum;
   if (Stat(filerem, strem) == 0) {
      if (Md5sum(filerem, remsum) != 0) {
         Printf("[PutFile] remote file exists but the check sum calculation failed");
         return rc;
      }
      // Check sums
      if (remsum == locsum) {
         if (!force) {
            Printf("[PutFile] local file '%s' and remote file '%s' have the same MD5 check sum",
                              fileloc.Data(), filerem.Data());
            Printf("[PutFile] use option 'force' to override");
         }
         same = kTRUE;
      }
      if (!force) {
         // If a different file with the same name exists already, ask what to do
         if (!same) {
            const char *a = Getline("Remote file exists already: would you like to overwrite it? [N/y]");
            if (a[0] == 'n' || a[0] == 'N' || a[0] == '\0') return 0;
            force = kTRUE;
         } else {
            return 0;
         }
      }
   }

   // Open the local file
   int fd = open(fileloc.Data(), openflags);
   if (fd < 0) {
      Error("PutFile", "cannot open file '%s': %d", fileloc.Data(), errno);
      return -1;
   }

   // Build the command line: 'path size [opt]'
   TString cmd;
   cmd.Form("%s %lld", filerem.Data(), stloc.fSize);
   if (force) cmd += " force";

   // Disable TXSocket handling while sending the file (CpProgress processes
   // pending events and this could screw-up synchronization in the TXSocket pipe)
   gSystem->RemoveFileHandler(TXSocketHandler::GetSocketHandler());

   // Send the request
   TStopwatch watch;
   watch.Start();
   TObjString *os = fSocket->SendCoordinator(kPutFile, cmd.Data());

   if (os) {

      // Send over the file
      const Int_t kMAXBUF = 16384;  //32768  //16384  //65536;
      char buf[kMAXBUF];

      Long64_t pos = 0;
      lseek(fd, pos, SEEK_SET);

      rc = 0;
      while (rc == 0 && pos < stloc.fSize) {
         Long64_t left = stloc.fSize - pos;
         if (left > kMAXBUF) left = kMAXBUF;
         Int_t siz;
         while ((siz = read(fd, &buf[0], left)) < 0 && TSystem::GetErrno() == EINTR)
            TSystem::ResetErrno();
         if (siz < 0 || siz != left) {
            Error("PutFile", "error reading from file: errno: %d", errno);
            rc = -1;
            break;
         }
         Int_t src = 0;
         if ((src = fSocket->fConn->WriteRaw((void *)&buf[0], left)) != left) {
            Error("PutFile", "error sending over: errno: %d (rc: %d)", TSystem::GetErrno(), src);
            rc = -1;
            break;
         }
         // Basic progress bar
         CpProgress("PutFile", pos, stloc.fSize, &watch);
         // Re-position
         pos += left;
      }
      // Finalize the progress bar
      CpProgress("PutFile", pos, stloc.fSize, &watch, kTRUE);

   } else {
      Error("PutFile", "command could not be executed");
      rc = -1;
   }

   // Restore TXSocket handling
   gSystem->AddFileHandler(TXSocketHandler::GetSocketHandler());

   // Close local file
   close(fd);
   watch.Stop();
   watch.Reset();

   if (rc == 0) {
      // Check if everything went fine
      if (Md5sum(filerem, remsum) != 0) {
         Printf("[PutFile] cannot get MD5 checksum of the new remote file '%s'", filerem.Data());
         rc = -1;
      } else if (remsum != locsum) {
         Printf("[PutFile] checksums for the local copy and the remote file differ: {rem:%s, loc:%s}",
                           remsum.Data(), locsum.Data());
         rc = -1;
      }
   }

   // Done
   return rc;
}

//______________________________________________________________________________
void TXProofMgr::CpProgress(const char *pfx, Long64_t bytes,
                            Long64_t size, TStopwatch *watch, Bool_t cr)
{
   // Print file copy progress.

   // Protection
   if (!pfx || size == 0 || !watch) return;

   fprintf(stderr, "[%s] Total %.02f MB\t|", pfx, (Double_t)size/1048576);

   for (int l = 0; l < 20; l++) {
      if (size > 0) {
         if (l < 20*bytes/size)
            fprintf(stderr, "=");
         else if (l == 20*bytes/size)
            fprintf(stderr, ">");
         else if (l > 20*bytes/size)
            fprintf(stderr, ".");
      } else
         fprintf(stderr, "=");
   }
   // Allow to update the GUI while uploading files
   gSystem->ProcessEvents();
   watch->Stop();
   Double_t copytime = watch->RealTime();
   fprintf(stderr, "| %.02f %% [%.01f MB/s]\r",
           100.0*(size?(bytes/size):1), bytes/copytime/1048576.);
   if (cr) fprintf(stderr, "\n");
   watch->Continue();
}

//______________________________________________________________________________
Int_t TXProofMgr::Cp(const char *src, const char *dst, const char *fmt)
{
   // Copy files in/out of the sandbox. Either 'src' or 'dst' must be in the
   // sandbox.
   // Return 0 on success, -1 on error

   Int_t rc = -1;
   // Nothing to do if not in contact with proofserv
   if (!IsValid()) {
      Error("Cp", "invalid TXProofMgr - do nothing");
      return rc;
   }
   // Server may not support it
   if (fSocket->GetXrdProofdVersion() < 1006) {
      Error("Cp", "functionality not supported by server");
      return rc;
   }

   // Check source path name
   TString filesrc(src);
   if (filesrc.IsNull()) {
      Error("Cp", "source file path undefined");
      return rc;
   }
   // Check destination path name
   TString filedst(dst);
   if (filedst.IsNull()) {
      filedst = gSystem->BaseName(TUrl(filesrc.Data()).GetFile());
   } else if (filedst.EndsWith("/")) {
      // Remote path is a directory: add the file name as in the local one
      filedst += gSystem->BaseName(filesrc);
   }

   // Make sure that local files are in the format file://host/<file> otherwise
   // the URL class in the server will not parse them correctly
   TUrl usrc = TUrl(filesrc.Data(), kTRUE).GetUrl();
   filesrc = usrc.GetUrl();
   if (!strcmp(usrc.GetProtocol(), "file"))
      filesrc.Form("file://host/%s", usrc.GetFileAndOptions());
   TUrl udst = TUrl(filedst.Data(), kTRUE).GetUrl();
   filedst = udst.GetUrl();
   if (!strcmp(udst.GetProtocol(), "file"))
      filedst.Form("file://host/%s", udst.GetFileAndOptions());

   // Prepare the command
   TString cmd;
   cmd.Form("%s %s %s", filesrc.Data(), filedst.Data(), (fmt ? fmt : ""));

   // On clients, handle Ctrl-C during collection
   if (fIntHandler) fIntHandler->Add();

   // Send the request
   TObjString *os = fSocket->SendCoordinator(kCpFile, cmd.Data());

   // On clients, handle Ctrl-C during collection
   if (fIntHandler) fIntHandler->Remove();

   // Show the result, if any
   if (os) {
      if (gDebug > 0) Printf("%s", os->GetName());
      rc = 0;
   }

   // Done
   return rc;
}
 TXProofMgr.cxx:1
 TXProofMgr.cxx:2
 TXProofMgr.cxx:3
 TXProofMgr.cxx:4
 TXProofMgr.cxx:5
 TXProofMgr.cxx:6
 TXProofMgr.cxx:7
 TXProofMgr.cxx:8
 TXProofMgr.cxx:9
 TXProofMgr.cxx:10
 TXProofMgr.cxx:11
 TXProofMgr.cxx:12
 TXProofMgr.cxx:13
 TXProofMgr.cxx:14
 TXProofMgr.cxx:15
 TXProofMgr.cxx:16
 TXProofMgr.cxx:17
 TXProofMgr.cxx:18
 TXProofMgr.cxx:19
 TXProofMgr.cxx:20
 TXProofMgr.cxx:21
 TXProofMgr.cxx:22
 TXProofMgr.cxx:23
 TXProofMgr.cxx:24
 TXProofMgr.cxx:25
 TXProofMgr.cxx:26
 TXProofMgr.cxx:27
 TXProofMgr.cxx:28
 TXProofMgr.cxx:29
 TXProofMgr.cxx:30
 TXProofMgr.cxx:31
 TXProofMgr.cxx:32
 TXProofMgr.cxx:33
 TXProofMgr.cxx:34
 TXProofMgr.cxx:35
 TXProofMgr.cxx:36
 TXProofMgr.cxx:37
 TXProofMgr.cxx:38
 TXProofMgr.cxx:39
 TXProofMgr.cxx:40
 TXProofMgr.cxx:41
 TXProofMgr.cxx:42
 TXProofMgr.cxx:43
 TXProofMgr.cxx:44
 TXProofMgr.cxx:45
 TXProofMgr.cxx:46
 TXProofMgr.cxx:47
 TXProofMgr.cxx:48
 TXProofMgr.cxx:49
 TXProofMgr.cxx:50
 TXProofMgr.cxx:51
 TXProofMgr.cxx:52
 TXProofMgr.cxx:53
 TXProofMgr.cxx:54
 TXProofMgr.cxx:55
 TXProofMgr.cxx:56
 TXProofMgr.cxx:57
 TXProofMgr.cxx:58
 TXProofMgr.cxx:59
 TXProofMgr.cxx:60
 TXProofMgr.cxx:61
 TXProofMgr.cxx:62
 TXProofMgr.cxx:63
 TXProofMgr.cxx:64
 TXProofMgr.cxx:65
 TXProofMgr.cxx:66
 TXProofMgr.cxx:67
 TXProofMgr.cxx:68
 TXProofMgr.cxx:69
 TXProofMgr.cxx:70
 TXProofMgr.cxx:71
 TXProofMgr.cxx:72
 TXProofMgr.cxx:73
 TXProofMgr.cxx:74
 TXProofMgr.cxx:75
 TXProofMgr.cxx:76
 TXProofMgr.cxx:77
 TXProofMgr.cxx:78
 TXProofMgr.cxx:79
 TXProofMgr.cxx:80
 TXProofMgr.cxx:81
 TXProofMgr.cxx:82
 TXProofMgr.cxx:83
 TXProofMgr.cxx:84
 TXProofMgr.cxx:85
 TXProofMgr.cxx:86
 TXProofMgr.cxx:87
 TXProofMgr.cxx:88
 TXProofMgr.cxx:89
 TXProofMgr.cxx:90
 TXProofMgr.cxx:91
 TXProofMgr.cxx:92
 TXProofMgr.cxx:93
 TXProofMgr.cxx:94
 TXProofMgr.cxx:95
 TXProofMgr.cxx:96
 TXProofMgr.cxx:97
 TXProofMgr.cxx:98
 TXProofMgr.cxx:99
 TXProofMgr.cxx:100
 TXProofMgr.cxx:101
 TXProofMgr.cxx:102
 TXProofMgr.cxx:103
 TXProofMgr.cxx:104
 TXProofMgr.cxx:105
 TXProofMgr.cxx:106
 TXProofMgr.cxx:107
 TXProofMgr.cxx:108
 TXProofMgr.cxx:109
 TXProofMgr.cxx:110
 TXProofMgr.cxx:111
 TXProofMgr.cxx:112
 TXProofMgr.cxx:113
 TXProofMgr.cxx:114
 TXProofMgr.cxx:115
 TXProofMgr.cxx:116
 TXProofMgr.cxx:117
 TXProofMgr.cxx:118
 TXProofMgr.cxx:119
 TXProofMgr.cxx:120
 TXProofMgr.cxx:121
 TXProofMgr.cxx:122
 TXProofMgr.cxx:123
 TXProofMgr.cxx:124
 TXProofMgr.cxx:125
 TXProofMgr.cxx:126
 TXProofMgr.cxx:127
 TXProofMgr.cxx:128
 TXProofMgr.cxx:129
 TXProofMgr.cxx:130
 TXProofMgr.cxx:131
 TXProofMgr.cxx:132
 TXProofMgr.cxx:133
 TXProofMgr.cxx:134
 TXProofMgr.cxx:135
 TXProofMgr.cxx:136
 TXProofMgr.cxx:137
 TXProofMgr.cxx:138
 TXProofMgr.cxx:139
 TXProofMgr.cxx:140
 TXProofMgr.cxx:141
 TXProofMgr.cxx:142
 TXProofMgr.cxx:143
 TXProofMgr.cxx:144
 TXProofMgr.cxx:145
 TXProofMgr.cxx:146
 TXProofMgr.cxx:147
 TXProofMgr.cxx:148
 TXProofMgr.cxx:149
 TXProofMgr.cxx:150
 TXProofMgr.cxx:151
 TXProofMgr.cxx:152
 TXProofMgr.cxx:153
 TXProofMgr.cxx:154
 TXProofMgr.cxx:155
 TXProofMgr.cxx:156
 TXProofMgr.cxx:157
 TXProofMgr.cxx:158
 TXProofMgr.cxx:159
 TXProofMgr.cxx:160
 TXProofMgr.cxx:161
 TXProofMgr.cxx:162
 TXProofMgr.cxx:163
 TXProofMgr.cxx:164
 TXProofMgr.cxx:165
 TXProofMgr.cxx:166
 TXProofMgr.cxx:167
 TXProofMgr.cxx:168
 TXProofMgr.cxx:169
 TXProofMgr.cxx:170
 TXProofMgr.cxx:171
 TXProofMgr.cxx:172
 TXProofMgr.cxx:173
 TXProofMgr.cxx:174
 TXProofMgr.cxx:175
 TXProofMgr.cxx:176
 TXProofMgr.cxx:177
 TXProofMgr.cxx:178
 TXProofMgr.cxx:179
 TXProofMgr.cxx:180
 TXProofMgr.cxx:181
 TXProofMgr.cxx:182
 TXProofMgr.cxx:183
 TXProofMgr.cxx:184
 TXProofMgr.cxx:185
 TXProofMgr.cxx:186
 TXProofMgr.cxx:187
 TXProofMgr.cxx:188
 TXProofMgr.cxx:189
 TXProofMgr.cxx:190
 TXProofMgr.cxx:191
 TXProofMgr.cxx:192
 TXProofMgr.cxx:193
 TXProofMgr.cxx:194
 TXProofMgr.cxx:195
 TXProofMgr.cxx:196
 TXProofMgr.cxx:197
 TXProofMgr.cxx:198
 TXProofMgr.cxx:199
 TXProofMgr.cxx:200
 TXProofMgr.cxx:201
 TXProofMgr.cxx:202
 TXProofMgr.cxx:203
 TXProofMgr.cxx:204
 TXProofMgr.cxx:205
 TXProofMgr.cxx:206
 TXProofMgr.cxx:207
 TXProofMgr.cxx:208
 TXProofMgr.cxx:209
 TXProofMgr.cxx:210
 TXProofMgr.cxx:211
 TXProofMgr.cxx:212
 TXProofMgr.cxx:213
 TXProofMgr.cxx:214
 TXProofMgr.cxx:215
 TXProofMgr.cxx:216
 TXProofMgr.cxx:217
 TXProofMgr.cxx:218
 TXProofMgr.cxx:219
 TXProofMgr.cxx:220
 TXProofMgr.cxx:221
 TXProofMgr.cxx:222
 TXProofMgr.cxx:223
 TXProofMgr.cxx:224
 TXProofMgr.cxx:225
 TXProofMgr.cxx:226
 TXProofMgr.cxx:227
 TXProofMgr.cxx:228
 TXProofMgr.cxx:229
 TXProofMgr.cxx:230
 TXProofMgr.cxx:231
 TXProofMgr.cxx:232
 TXProofMgr.cxx:233
 TXProofMgr.cxx:234
 TXProofMgr.cxx:235
 TXProofMgr.cxx:236
 TXProofMgr.cxx:237
 TXProofMgr.cxx:238
 TXProofMgr.cxx:239
 TXProofMgr.cxx:240
 TXProofMgr.cxx:241
 TXProofMgr.cxx:242
 TXProofMgr.cxx:243
 TXProofMgr.cxx:244
 TXProofMgr.cxx:245
 TXProofMgr.cxx:246
 TXProofMgr.cxx:247
 TXProofMgr.cxx:248
 TXProofMgr.cxx:249
 TXProofMgr.cxx:250
 TXProofMgr.cxx:251
 TXProofMgr.cxx:252
 TXProofMgr.cxx:253
 TXProofMgr.cxx:254
 TXProofMgr.cxx:255
 TXProofMgr.cxx:256
 TXProofMgr.cxx:257
 TXProofMgr.cxx:258
 TXProofMgr.cxx:259
 TXProofMgr.cxx:260
 TXProofMgr.cxx:261
 TXProofMgr.cxx:262
 TXProofMgr.cxx:263
 TXProofMgr.cxx:264
 TXProofMgr.cxx:265
 TXProofMgr.cxx:266
 TXProofMgr.cxx:267
 TXProofMgr.cxx:268
 TXProofMgr.cxx:269
 TXProofMgr.cxx:270
 TXProofMgr.cxx:271
 TXProofMgr.cxx:272
 TXProofMgr.cxx:273
 TXProofMgr.cxx:274
 TXProofMgr.cxx:275
 TXProofMgr.cxx:276
 TXProofMgr.cxx:277
 TXProofMgr.cxx:278
 TXProofMgr.cxx:279
 TXProofMgr.cxx:280
 TXProofMgr.cxx:281
 TXProofMgr.cxx:282
 TXProofMgr.cxx:283
 TXProofMgr.cxx:284
 TXProofMgr.cxx:285
 TXProofMgr.cxx:286
 TXProofMgr.cxx:287
 TXProofMgr.cxx:288
 TXProofMgr.cxx:289
 TXProofMgr.cxx:290
 TXProofMgr.cxx:291
 TXProofMgr.cxx:292
 TXProofMgr.cxx:293
 TXProofMgr.cxx:294
 TXProofMgr.cxx:295
 TXProofMgr.cxx:296
 TXProofMgr.cxx:297
 TXProofMgr.cxx:298
 TXProofMgr.cxx:299
 TXProofMgr.cxx:300
 TXProofMgr.cxx:301
 TXProofMgr.cxx:302
 TXProofMgr.cxx:303
 TXProofMgr.cxx:304
 TXProofMgr.cxx:305
 TXProofMgr.cxx:306
 TXProofMgr.cxx:307
 TXProofMgr.cxx:308
 TXProofMgr.cxx:309
 TXProofMgr.cxx:310
 TXProofMgr.cxx:311
 TXProofMgr.cxx:312
 TXProofMgr.cxx:313
 TXProofMgr.cxx:314
 TXProofMgr.cxx:315
 TXProofMgr.cxx:316
 TXProofMgr.cxx:317
 TXProofMgr.cxx:318
 TXProofMgr.cxx:319
 TXProofMgr.cxx:320
 TXProofMgr.cxx:321
 TXProofMgr.cxx:322
 TXProofMgr.cxx:323
 TXProofMgr.cxx:324
 TXProofMgr.cxx:325
 TXProofMgr.cxx:326
 TXProofMgr.cxx:327
 TXProofMgr.cxx:328
 TXProofMgr.cxx:329
 TXProofMgr.cxx:330
 TXProofMgr.cxx:331
 TXProofMgr.cxx:332
 TXProofMgr.cxx:333
 TXProofMgr.cxx:334
 TXProofMgr.cxx:335
 TXProofMgr.cxx:336
 TXProofMgr.cxx:337
 TXProofMgr.cxx:338
 TXProofMgr.cxx:339
 TXProofMgr.cxx:340
 TXProofMgr.cxx:341
 TXProofMgr.cxx:342
 TXProofMgr.cxx:343
 TXProofMgr.cxx:344
 TXProofMgr.cxx:345
 TXProofMgr.cxx:346
 TXProofMgr.cxx:347
 TXProofMgr.cxx:348
 TXProofMgr.cxx:349
 TXProofMgr.cxx:350
 TXProofMgr.cxx:351
 TXProofMgr.cxx:352
 TXProofMgr.cxx:353
 TXProofMgr.cxx:354
 TXProofMgr.cxx:355
 TXProofMgr.cxx:356
 TXProofMgr.cxx:357
 TXProofMgr.cxx:358
 TXProofMgr.cxx:359
 TXProofMgr.cxx:360
 TXProofMgr.cxx:361
 TXProofMgr.cxx:362
 TXProofMgr.cxx:363
 TXProofMgr.cxx:364
 TXProofMgr.cxx:365
 TXProofMgr.cxx:366
 TXProofMgr.cxx:367
 TXProofMgr.cxx:368
 TXProofMgr.cxx:369
 TXProofMgr.cxx:370
 TXProofMgr.cxx:371
 TXProofMgr.cxx:372
 TXProofMgr.cxx:373
 TXProofMgr.cxx:374
 TXProofMgr.cxx:375
 TXProofMgr.cxx:376
 TXProofMgr.cxx:377
 TXProofMgr.cxx:378
 TXProofMgr.cxx:379
 TXProofMgr.cxx:380
 TXProofMgr.cxx:381
 TXProofMgr.cxx:382
 TXProofMgr.cxx:383
 TXProofMgr.cxx:384
 TXProofMgr.cxx:385
 TXProofMgr.cxx:386
 TXProofMgr.cxx:387
 TXProofMgr.cxx:388
 TXProofMgr.cxx:389
 TXProofMgr.cxx:390
 TXProofMgr.cxx:391
 TXProofMgr.cxx:392
 TXProofMgr.cxx:393
 TXProofMgr.cxx:394
 TXProofMgr.cxx:395
 TXProofMgr.cxx:396
 TXProofMgr.cxx:397
 TXProofMgr.cxx:398
 TXProofMgr.cxx:399
 TXProofMgr.cxx:400
 TXProofMgr.cxx:401
 TXProofMgr.cxx:402
 TXProofMgr.cxx:403
 TXProofMgr.cxx:404
 TXProofMgr.cxx:405
 TXProofMgr.cxx:406
 TXProofMgr.cxx:407
 TXProofMgr.cxx:408
 TXProofMgr.cxx:409
 TXProofMgr.cxx:410
 TXProofMgr.cxx:411
 TXProofMgr.cxx:412
 TXProofMgr.cxx:413
 TXProofMgr.cxx:414
 TXProofMgr.cxx:415
 TXProofMgr.cxx:416
 TXProofMgr.cxx:417
 TXProofMgr.cxx:418
 TXProofMgr.cxx:419
 TXProofMgr.cxx:420
 TXProofMgr.cxx:421
 TXProofMgr.cxx:422
 TXProofMgr.cxx:423
 TXProofMgr.cxx:424
 TXProofMgr.cxx:425
 TXProofMgr.cxx:426
 TXProofMgr.cxx:427
 TXProofMgr.cxx:428
 TXProofMgr.cxx:429
 TXProofMgr.cxx:430
 TXProofMgr.cxx:431
 TXProofMgr.cxx:432
 TXProofMgr.cxx:433
 TXProofMgr.cxx:434
 TXProofMgr.cxx:435
 TXProofMgr.cxx:436
 TXProofMgr.cxx:437
 TXProofMgr.cxx:438
 TXProofMgr.cxx:439
 TXProofMgr.cxx:440
 TXProofMgr.cxx:441
 TXProofMgr.cxx:442
 TXProofMgr.cxx:443
 TXProofMgr.cxx:444
 TXProofMgr.cxx:445
 TXProofMgr.cxx:446
 TXProofMgr.cxx:447
 TXProofMgr.cxx:448
 TXProofMgr.cxx:449
 TXProofMgr.cxx:450
 TXProofMgr.cxx:451
 TXProofMgr.cxx:452
 TXProofMgr.cxx:453
 TXProofMgr.cxx:454
 TXProofMgr.cxx:455
 TXProofMgr.cxx:456
 TXProofMgr.cxx:457
 TXProofMgr.cxx:458
 TXProofMgr.cxx:459
 TXProofMgr.cxx:460
 TXProofMgr.cxx:461
 TXProofMgr.cxx:462
 TXProofMgr.cxx:463
 TXProofMgr.cxx:464
 TXProofMgr.cxx:465
 TXProofMgr.cxx:466
 TXProofMgr.cxx:467
 TXProofMgr.cxx:468
 TXProofMgr.cxx:469
 TXProofMgr.cxx:470
 TXProofMgr.cxx:471
 TXProofMgr.cxx:472
 TXProofMgr.cxx:473
 TXProofMgr.cxx:474
 TXProofMgr.cxx:475
 TXProofMgr.cxx:476
 TXProofMgr.cxx:477
 TXProofMgr.cxx:478
 TXProofMgr.cxx:479
 TXProofMgr.cxx:480
 TXProofMgr.cxx:481
 TXProofMgr.cxx:482
 TXProofMgr.cxx:483
 TXProofMgr.cxx:484
 TXProofMgr.cxx:485
 TXProofMgr.cxx:486
 TXProofMgr.cxx:487
 TXProofMgr.cxx:488
 TXProofMgr.cxx:489
 TXProofMgr.cxx:490
 TXProofMgr.cxx:491
 TXProofMgr.cxx:492
 TXProofMgr.cxx:493
 TXProofMgr.cxx:494
 TXProofMgr.cxx:495
 TXProofMgr.cxx:496
 TXProofMgr.cxx:497
 TXProofMgr.cxx:498
 TXProofMgr.cxx:499
 TXProofMgr.cxx:500
 TXProofMgr.cxx:501
 TXProofMgr.cxx:502
 TXProofMgr.cxx:503
 TXProofMgr.cxx:504
 TXProofMgr.cxx:505
 TXProofMgr.cxx:506
 TXProofMgr.cxx:507
 TXProofMgr.cxx:508
 TXProofMgr.cxx:509
 TXProofMgr.cxx:510
 TXProofMgr.cxx:511
 TXProofMgr.cxx:512
 TXProofMgr.cxx:513
 TXProofMgr.cxx:514
 TXProofMgr.cxx:515
 TXProofMgr.cxx:516
 TXProofMgr.cxx:517
 TXProofMgr.cxx:518
 TXProofMgr.cxx:519
 TXProofMgr.cxx:520
 TXProofMgr.cxx:521
 TXProofMgr.cxx:522
 TXProofMgr.cxx:523
 TXProofMgr.cxx:524
 TXProofMgr.cxx:525
 TXProofMgr.cxx:526
 TXProofMgr.cxx:527
 TXProofMgr.cxx:528
 TXProofMgr.cxx:529
 TXProofMgr.cxx:530
 TXProofMgr.cxx:531
 TXProofMgr.cxx:532
 TXProofMgr.cxx:533
 TXProofMgr.cxx:534
 TXProofMgr.cxx:535
 TXProofMgr.cxx:536
 TXProofMgr.cxx:537
 TXProofMgr.cxx:538
 TXProofMgr.cxx:539
 TXProofMgr.cxx:540
 TXProofMgr.cxx:541
 TXProofMgr.cxx:542
 TXProofMgr.cxx:543
 TXProofMgr.cxx:544
 TXProofMgr.cxx:545
 TXProofMgr.cxx:546
 TXProofMgr.cxx:547
 TXProofMgr.cxx:548
 TXProofMgr.cxx:549
 TXProofMgr.cxx:550
 TXProofMgr.cxx:551
 TXProofMgr.cxx:552
 TXProofMgr.cxx:553
 TXProofMgr.cxx:554
 TXProofMgr.cxx:555
 TXProofMgr.cxx:556
 TXProofMgr.cxx:557
 TXProofMgr.cxx:558
 TXProofMgr.cxx:559
 TXProofMgr.cxx:560
 TXProofMgr.cxx:561
 TXProofMgr.cxx:562
 TXProofMgr.cxx:563
 TXProofMgr.cxx:564
 TXProofMgr.cxx:565
 TXProofMgr.cxx:566
 TXProofMgr.cxx:567
 TXProofMgr.cxx:568
 TXProofMgr.cxx:569
 TXProofMgr.cxx:570
 TXProofMgr.cxx:571
 TXProofMgr.cxx:572
 TXProofMgr.cxx:573
 TXProofMgr.cxx:574
 TXProofMgr.cxx:575
 TXProofMgr.cxx:576
 TXProofMgr.cxx:577
 TXProofMgr.cxx:578
 TXProofMgr.cxx:579
 TXProofMgr.cxx:580
 TXProofMgr.cxx:581
 TXProofMgr.cxx:582
 TXProofMgr.cxx:583
 TXProofMgr.cxx:584
 TXProofMgr.cxx:585
 TXProofMgr.cxx:586
 TXProofMgr.cxx:587
 TXProofMgr.cxx:588
 TXProofMgr.cxx:589
 TXProofMgr.cxx:590
 TXProofMgr.cxx:591
 TXProofMgr.cxx:592
 TXProofMgr.cxx:593
 TXProofMgr.cxx:594
 TXProofMgr.cxx:595
 TXProofMgr.cxx:596
 TXProofMgr.cxx:597
 TXProofMgr.cxx:598
 TXProofMgr.cxx:599
 TXProofMgr.cxx:600
 TXProofMgr.cxx:601
 TXProofMgr.cxx:602
 TXProofMgr.cxx:603
 TXProofMgr.cxx:604
 TXProofMgr.cxx:605
 TXProofMgr.cxx:606
 TXProofMgr.cxx:607
 TXProofMgr.cxx:608
 TXProofMgr.cxx:609
 TXProofMgr.cxx:610
 TXProofMgr.cxx:611
 TXProofMgr.cxx:612
 TXProofMgr.cxx:613
 TXProofMgr.cxx:614
 TXProofMgr.cxx:615
 TXProofMgr.cxx:616
 TXProofMgr.cxx:617
 TXProofMgr.cxx:618
 TXProofMgr.cxx:619
 TXProofMgr.cxx:620
 TXProofMgr.cxx:621
 TXProofMgr.cxx:622
 TXProofMgr.cxx:623
 TXProofMgr.cxx:624
 TXProofMgr.cxx:625
 TXProofMgr.cxx:626
 TXProofMgr.cxx:627
 TXProofMgr.cxx:628
 TXProofMgr.cxx:629
 TXProofMgr.cxx:630
 TXProofMgr.cxx:631
 TXProofMgr.cxx:632
 TXProofMgr.cxx:633
 TXProofMgr.cxx:634
 TXProofMgr.cxx:635
 TXProofMgr.cxx:636
 TXProofMgr.cxx:637
 TXProofMgr.cxx:638
 TXProofMgr.cxx:639
 TXProofMgr.cxx:640
 TXProofMgr.cxx:641
 TXProofMgr.cxx:642
 TXProofMgr.cxx:643
 TXProofMgr.cxx:644
 TXProofMgr.cxx:645
 TXProofMgr.cxx:646
 TXProofMgr.cxx:647
 TXProofMgr.cxx:648
 TXProofMgr.cxx:649
 TXProofMgr.cxx:650
 TXProofMgr.cxx:651
 TXProofMgr.cxx:652
 TXProofMgr.cxx:653
 TXProofMgr.cxx:654
 TXProofMgr.cxx:655
 TXProofMgr.cxx:656
 TXProofMgr.cxx:657
 TXProofMgr.cxx:658
 TXProofMgr.cxx:659
 TXProofMgr.cxx:660
 TXProofMgr.cxx:661
 TXProofMgr.cxx:662
 TXProofMgr.cxx:663
 TXProofMgr.cxx:664
 TXProofMgr.cxx:665
 TXProofMgr.cxx:666
 TXProofMgr.cxx:667
 TXProofMgr.cxx:668
 TXProofMgr.cxx:669
 TXProofMgr.cxx:670
 TXProofMgr.cxx:671
 TXProofMgr.cxx:672
 TXProofMgr.cxx:673
 TXProofMgr.cxx:674
 TXProofMgr.cxx:675
 TXProofMgr.cxx:676
 TXProofMgr.cxx:677
 TXProofMgr.cxx:678
 TXProofMgr.cxx:679
 TXProofMgr.cxx:680
 TXProofMgr.cxx:681
 TXProofMgr.cxx:682
 TXProofMgr.cxx:683
 TXProofMgr.cxx:684
 TXProofMgr.cxx:685
 TXProofMgr.cxx:686
 TXProofMgr.cxx:687
 TXProofMgr.cxx:688
 TXProofMgr.cxx:689
 TXProofMgr.cxx:690
 TXProofMgr.cxx:691
 TXProofMgr.cxx:692
 TXProofMgr.cxx:693
 TXProofMgr.cxx:694
 TXProofMgr.cxx:695
 TXProofMgr.cxx:696
 TXProofMgr.cxx:697
 TXProofMgr.cxx:698
 TXProofMgr.cxx:699
 TXProofMgr.cxx:700
 TXProofMgr.cxx:701
 TXProofMgr.cxx:702
 TXProofMgr.cxx:703
 TXProofMgr.cxx:704
 TXProofMgr.cxx:705
 TXProofMgr.cxx:706
 TXProofMgr.cxx:707
 TXProofMgr.cxx:708
 TXProofMgr.cxx:709
 TXProofMgr.cxx:710
 TXProofMgr.cxx:711
 TXProofMgr.cxx:712
 TXProofMgr.cxx:713
 TXProofMgr.cxx:714
 TXProofMgr.cxx:715
 TXProofMgr.cxx:716
 TXProofMgr.cxx:717
 TXProofMgr.cxx:718
 TXProofMgr.cxx:719
 TXProofMgr.cxx:720
 TXProofMgr.cxx:721
 TXProofMgr.cxx:722
 TXProofMgr.cxx:723
 TXProofMgr.cxx:724
 TXProofMgr.cxx:725
 TXProofMgr.cxx:726
 TXProofMgr.cxx:727
 TXProofMgr.cxx:728
 TXProofMgr.cxx:729
 TXProofMgr.cxx:730
 TXProofMgr.cxx:731
 TXProofMgr.cxx:732
 TXProofMgr.cxx:733
 TXProofMgr.cxx:734
 TXProofMgr.cxx:735
 TXProofMgr.cxx:736
 TXProofMgr.cxx:737
 TXProofMgr.cxx:738
 TXProofMgr.cxx:739
 TXProofMgr.cxx:740
 TXProofMgr.cxx:741
 TXProofMgr.cxx:742
 TXProofMgr.cxx:743
 TXProofMgr.cxx:744
 TXProofMgr.cxx:745
 TXProofMgr.cxx:746
 TXProofMgr.cxx:747
 TXProofMgr.cxx:748
 TXProofMgr.cxx:749
 TXProofMgr.cxx:750
 TXProofMgr.cxx:751
 TXProofMgr.cxx:752
 TXProofMgr.cxx:753
 TXProofMgr.cxx:754
 TXProofMgr.cxx:755
 TXProofMgr.cxx:756
 TXProofMgr.cxx:757
 TXProofMgr.cxx:758
 TXProofMgr.cxx:759
 TXProofMgr.cxx:760
 TXProofMgr.cxx:761
 TXProofMgr.cxx:762
 TXProofMgr.cxx:763
 TXProofMgr.cxx:764
 TXProofMgr.cxx:765
 TXProofMgr.cxx:766
 TXProofMgr.cxx:767
 TXProofMgr.cxx:768
 TXProofMgr.cxx:769
 TXProofMgr.cxx:770
 TXProofMgr.cxx:771
 TXProofMgr.cxx:772
 TXProofMgr.cxx:773
 TXProofMgr.cxx:774
 TXProofMgr.cxx:775
 TXProofMgr.cxx:776
 TXProofMgr.cxx:777
 TXProofMgr.cxx:778
 TXProofMgr.cxx:779
 TXProofMgr.cxx:780
 TXProofMgr.cxx:781
 TXProofMgr.cxx:782
 TXProofMgr.cxx:783
 TXProofMgr.cxx:784
 TXProofMgr.cxx:785
 TXProofMgr.cxx:786
 TXProofMgr.cxx:787
 TXProofMgr.cxx:788
 TXProofMgr.cxx:789
 TXProofMgr.cxx:790
 TXProofMgr.cxx:791
 TXProofMgr.cxx:792
 TXProofMgr.cxx:793
 TXProofMgr.cxx:794
 TXProofMgr.cxx:795
 TXProofMgr.cxx:796
 TXProofMgr.cxx:797
 TXProofMgr.cxx:798
 TXProofMgr.cxx:799
 TXProofMgr.cxx:800
 TXProofMgr.cxx:801
 TXProofMgr.cxx:802
 TXProofMgr.cxx:803
 TXProofMgr.cxx:804
 TXProofMgr.cxx:805
 TXProofMgr.cxx:806
 TXProofMgr.cxx:807
 TXProofMgr.cxx:808
 TXProofMgr.cxx:809
 TXProofMgr.cxx:810
 TXProofMgr.cxx:811
 TXProofMgr.cxx:812
 TXProofMgr.cxx:813
 TXProofMgr.cxx:814
 TXProofMgr.cxx:815
 TXProofMgr.cxx:816
 TXProofMgr.cxx:817
 TXProofMgr.cxx:818
 TXProofMgr.cxx:819
 TXProofMgr.cxx:820
 TXProofMgr.cxx:821
 TXProofMgr.cxx:822
 TXProofMgr.cxx:823
 TXProofMgr.cxx:824
 TXProofMgr.cxx:825
 TXProofMgr.cxx:826
 TXProofMgr.cxx:827
 TXProofMgr.cxx:828
 TXProofMgr.cxx:829
 TXProofMgr.cxx:830
 TXProofMgr.cxx:831
 TXProofMgr.cxx:832
 TXProofMgr.cxx:833
 TXProofMgr.cxx:834
 TXProofMgr.cxx:835
 TXProofMgr.cxx:836
 TXProofMgr.cxx:837
 TXProofMgr.cxx:838
 TXProofMgr.cxx:839
 TXProofMgr.cxx:840
 TXProofMgr.cxx:841
 TXProofMgr.cxx:842
 TXProofMgr.cxx:843
 TXProofMgr.cxx:844
 TXProofMgr.cxx:845
 TXProofMgr.cxx:846
 TXProofMgr.cxx:847
 TXProofMgr.cxx:848
 TXProofMgr.cxx:849
 TXProofMgr.cxx:850
 TXProofMgr.cxx:851
 TXProofMgr.cxx:852
 TXProofMgr.cxx:853
 TXProofMgr.cxx:854
 TXProofMgr.cxx:855
 TXProofMgr.cxx:856
 TXProofMgr.cxx:857
 TXProofMgr.cxx:858
 TXProofMgr.cxx:859
 TXProofMgr.cxx:860
 TXProofMgr.cxx:861
 TXProofMgr.cxx:862
 TXProofMgr.cxx:863
 TXProofMgr.cxx:864
 TXProofMgr.cxx:865
 TXProofMgr.cxx:866
 TXProofMgr.cxx:867
 TXProofMgr.cxx:868
 TXProofMgr.cxx:869
 TXProofMgr.cxx:870
 TXProofMgr.cxx:871
 TXProofMgr.cxx:872
 TXProofMgr.cxx:873
 TXProofMgr.cxx:874
 TXProofMgr.cxx:875
 TXProofMgr.cxx:876
 TXProofMgr.cxx:877
 TXProofMgr.cxx:878
 TXProofMgr.cxx:879
 TXProofMgr.cxx:880
 TXProofMgr.cxx:881
 TXProofMgr.cxx:882
 TXProofMgr.cxx:883
 TXProofMgr.cxx:884
 TXProofMgr.cxx:885
 TXProofMgr.cxx:886
 TXProofMgr.cxx:887
 TXProofMgr.cxx:888
 TXProofMgr.cxx:889
 TXProofMgr.cxx:890
 TXProofMgr.cxx:891
 TXProofMgr.cxx:892
 TXProofMgr.cxx:893
 TXProofMgr.cxx:894
 TXProofMgr.cxx:895
 TXProofMgr.cxx:896
 TXProofMgr.cxx:897
 TXProofMgr.cxx:898
 TXProofMgr.cxx:899
 TXProofMgr.cxx:900
 TXProofMgr.cxx:901
 TXProofMgr.cxx:902
 TXProofMgr.cxx:903
 TXProofMgr.cxx:904
 TXProofMgr.cxx:905
 TXProofMgr.cxx:906
 TXProofMgr.cxx:907
 TXProofMgr.cxx:908
 TXProofMgr.cxx:909
 TXProofMgr.cxx:910
 TXProofMgr.cxx:911
 TXProofMgr.cxx:912
 TXProofMgr.cxx:913
 TXProofMgr.cxx:914
 TXProofMgr.cxx:915
 TXProofMgr.cxx:916
 TXProofMgr.cxx:917
 TXProofMgr.cxx:918
 TXProofMgr.cxx:919
 TXProofMgr.cxx:920
 TXProofMgr.cxx:921
 TXProofMgr.cxx:922
 TXProofMgr.cxx:923
 TXProofMgr.cxx:924
 TXProofMgr.cxx:925
 TXProofMgr.cxx:926
 TXProofMgr.cxx:927
 TXProofMgr.cxx:928
 TXProofMgr.cxx:929
 TXProofMgr.cxx:930
 TXProofMgr.cxx:931
 TXProofMgr.cxx:932
 TXProofMgr.cxx:933
 TXProofMgr.cxx:934
 TXProofMgr.cxx:935
 TXProofMgr.cxx:936
 TXProofMgr.cxx:937
 TXProofMgr.cxx:938
 TXProofMgr.cxx:939
 TXProofMgr.cxx:940
 TXProofMgr.cxx:941
 TXProofMgr.cxx:942
 TXProofMgr.cxx:943
 TXProofMgr.cxx:944
 TXProofMgr.cxx:945
 TXProofMgr.cxx:946
 TXProofMgr.cxx:947
 TXProofMgr.cxx:948
 TXProofMgr.cxx:949
 TXProofMgr.cxx:950
 TXProofMgr.cxx:951
 TXProofMgr.cxx:952
 TXProofMgr.cxx:953
 TXProofMgr.cxx:954
 TXProofMgr.cxx:955
 TXProofMgr.cxx:956
 TXProofMgr.cxx:957
 TXProofMgr.cxx:958
 TXProofMgr.cxx:959
 TXProofMgr.cxx:960
 TXProofMgr.cxx:961
 TXProofMgr.cxx:962
 TXProofMgr.cxx:963
 TXProofMgr.cxx:964
 TXProofMgr.cxx:965
 TXProofMgr.cxx:966
 TXProofMgr.cxx:967
 TXProofMgr.cxx:968
 TXProofMgr.cxx:969
 TXProofMgr.cxx:970
 TXProofMgr.cxx:971
 TXProofMgr.cxx:972
 TXProofMgr.cxx:973
 TXProofMgr.cxx:974
 TXProofMgr.cxx:975
 TXProofMgr.cxx:976
 TXProofMgr.cxx:977
 TXProofMgr.cxx:978
 TXProofMgr.cxx:979
 TXProofMgr.cxx:980
 TXProofMgr.cxx:981
 TXProofMgr.cxx:982
 TXProofMgr.cxx:983
 TXProofMgr.cxx:984
 TXProofMgr.cxx:985
 TXProofMgr.cxx:986
 TXProofMgr.cxx:987
 TXProofMgr.cxx:988
 TXProofMgr.cxx:989
 TXProofMgr.cxx:990
 TXProofMgr.cxx:991
 TXProofMgr.cxx:992
 TXProofMgr.cxx:993
 TXProofMgr.cxx:994
 TXProofMgr.cxx:995
 TXProofMgr.cxx:996
 TXProofMgr.cxx:997
 TXProofMgr.cxx:998
 TXProofMgr.cxx:999
 TXProofMgr.cxx:1000
 TXProofMgr.cxx:1001
 TXProofMgr.cxx:1002
 TXProofMgr.cxx:1003
 TXProofMgr.cxx:1004
 TXProofMgr.cxx:1005
 TXProofMgr.cxx:1006
 TXProofMgr.cxx:1007
 TXProofMgr.cxx:1008
 TXProofMgr.cxx:1009
 TXProofMgr.cxx:1010
 TXProofMgr.cxx:1011
 TXProofMgr.cxx:1012
 TXProofMgr.cxx:1013
 TXProofMgr.cxx:1014
 TXProofMgr.cxx:1015
 TXProofMgr.cxx:1016
 TXProofMgr.cxx:1017
 TXProofMgr.cxx:1018
 TXProofMgr.cxx:1019
 TXProofMgr.cxx:1020
 TXProofMgr.cxx:1021
 TXProofMgr.cxx:1022
 TXProofMgr.cxx:1023
 TXProofMgr.cxx:1024
 TXProofMgr.cxx:1025
 TXProofMgr.cxx:1026
 TXProofMgr.cxx:1027
 TXProofMgr.cxx:1028
 TXProofMgr.cxx:1029
 TXProofMgr.cxx:1030
 TXProofMgr.cxx:1031
 TXProofMgr.cxx:1032
 TXProofMgr.cxx:1033
 TXProofMgr.cxx:1034
 TXProofMgr.cxx:1035
 TXProofMgr.cxx:1036
 TXProofMgr.cxx:1037
 TXProofMgr.cxx:1038
 TXProofMgr.cxx:1039
 TXProofMgr.cxx:1040
 TXProofMgr.cxx:1041
 TXProofMgr.cxx:1042
 TXProofMgr.cxx:1043
 TXProofMgr.cxx:1044
 TXProofMgr.cxx:1045
 TXProofMgr.cxx:1046
 TXProofMgr.cxx:1047
 TXProofMgr.cxx:1048
 TXProofMgr.cxx:1049
 TXProofMgr.cxx:1050
 TXProofMgr.cxx:1051
 TXProofMgr.cxx:1052
 TXProofMgr.cxx:1053
 TXProofMgr.cxx:1054
 TXProofMgr.cxx:1055
 TXProofMgr.cxx:1056
 TXProofMgr.cxx:1057
 TXProofMgr.cxx:1058
 TXProofMgr.cxx:1059
 TXProofMgr.cxx:1060
 TXProofMgr.cxx:1061
 TXProofMgr.cxx:1062
 TXProofMgr.cxx:1063
 TXProofMgr.cxx:1064
 TXProofMgr.cxx:1065
 TXProofMgr.cxx:1066
 TXProofMgr.cxx:1067
 TXProofMgr.cxx:1068
 TXProofMgr.cxx:1069
 TXProofMgr.cxx:1070
 TXProofMgr.cxx:1071
 TXProofMgr.cxx:1072
 TXProofMgr.cxx:1073
 TXProofMgr.cxx:1074
 TXProofMgr.cxx:1075
 TXProofMgr.cxx:1076
 TXProofMgr.cxx:1077
 TXProofMgr.cxx:1078
 TXProofMgr.cxx:1079
 TXProofMgr.cxx:1080
 TXProofMgr.cxx:1081
 TXProofMgr.cxx:1082
 TXProofMgr.cxx:1083
 TXProofMgr.cxx:1084
 TXProofMgr.cxx:1085
 TXProofMgr.cxx:1086
 TXProofMgr.cxx:1087
 TXProofMgr.cxx:1088
 TXProofMgr.cxx:1089
 TXProofMgr.cxx:1090
 TXProofMgr.cxx:1091
 TXProofMgr.cxx:1092
 TXProofMgr.cxx:1093
 TXProofMgr.cxx:1094
 TXProofMgr.cxx:1095
 TXProofMgr.cxx:1096
 TXProofMgr.cxx:1097
 TXProofMgr.cxx:1098
 TXProofMgr.cxx:1099
 TXProofMgr.cxx:1100
 TXProofMgr.cxx:1101
 TXProofMgr.cxx:1102
 TXProofMgr.cxx:1103
 TXProofMgr.cxx:1104
 TXProofMgr.cxx:1105
 TXProofMgr.cxx:1106
 TXProofMgr.cxx:1107
 TXProofMgr.cxx:1108
 TXProofMgr.cxx:1109
 TXProofMgr.cxx:1110
 TXProofMgr.cxx:1111
 TXProofMgr.cxx:1112
 TXProofMgr.cxx:1113
 TXProofMgr.cxx:1114
 TXProofMgr.cxx:1115
 TXProofMgr.cxx:1116
 TXProofMgr.cxx:1117
 TXProofMgr.cxx:1118
 TXProofMgr.cxx:1119
 TXProofMgr.cxx:1120
 TXProofMgr.cxx:1121
 TXProofMgr.cxx:1122
 TXProofMgr.cxx:1123
 TXProofMgr.cxx:1124
 TXProofMgr.cxx:1125
 TXProofMgr.cxx:1126
 TXProofMgr.cxx:1127
 TXProofMgr.cxx:1128
 TXProofMgr.cxx:1129
 TXProofMgr.cxx:1130
 TXProofMgr.cxx:1131
 TXProofMgr.cxx:1132
 TXProofMgr.cxx:1133
 TXProofMgr.cxx:1134
 TXProofMgr.cxx:1135
 TXProofMgr.cxx:1136
 TXProofMgr.cxx:1137
 TXProofMgr.cxx:1138
 TXProofMgr.cxx:1139
 TXProofMgr.cxx:1140
 TXProofMgr.cxx:1141
 TXProofMgr.cxx:1142
 TXProofMgr.cxx:1143
 TXProofMgr.cxx:1144
 TXProofMgr.cxx:1145
 TXProofMgr.cxx:1146
 TXProofMgr.cxx:1147
 TXProofMgr.cxx:1148
 TXProofMgr.cxx:1149
 TXProofMgr.cxx:1150
 TXProofMgr.cxx:1151
 TXProofMgr.cxx:1152
 TXProofMgr.cxx:1153
 TXProofMgr.cxx:1154
 TXProofMgr.cxx:1155
 TXProofMgr.cxx:1156
 TXProofMgr.cxx:1157
 TXProofMgr.cxx:1158
 TXProofMgr.cxx:1159
 TXProofMgr.cxx:1160
 TXProofMgr.cxx:1161
 TXProofMgr.cxx:1162
 TXProofMgr.cxx:1163
 TXProofMgr.cxx:1164
 TXProofMgr.cxx:1165
 TXProofMgr.cxx:1166
 TXProofMgr.cxx:1167
 TXProofMgr.cxx:1168
 TXProofMgr.cxx:1169
 TXProofMgr.cxx:1170
 TXProofMgr.cxx:1171
 TXProofMgr.cxx:1172
 TXProofMgr.cxx:1173
 TXProofMgr.cxx:1174
 TXProofMgr.cxx:1175
 TXProofMgr.cxx:1176
 TXProofMgr.cxx:1177
 TXProofMgr.cxx:1178
 TXProofMgr.cxx:1179
 TXProofMgr.cxx:1180
 TXProofMgr.cxx:1181
 TXProofMgr.cxx:1182
 TXProofMgr.cxx:1183
 TXProofMgr.cxx:1184
 TXProofMgr.cxx:1185
 TXProofMgr.cxx:1186
 TXProofMgr.cxx:1187
 TXProofMgr.cxx:1188
 TXProofMgr.cxx:1189
 TXProofMgr.cxx:1190
 TXProofMgr.cxx:1191
 TXProofMgr.cxx:1192
 TXProofMgr.cxx:1193
 TXProofMgr.cxx:1194
 TXProofMgr.cxx:1195
 TXProofMgr.cxx:1196
 TXProofMgr.cxx:1197
 TXProofMgr.cxx:1198
 TXProofMgr.cxx:1199
 TXProofMgr.cxx:1200
 TXProofMgr.cxx:1201
 TXProofMgr.cxx:1202
 TXProofMgr.cxx:1203
 TXProofMgr.cxx:1204
 TXProofMgr.cxx:1205
 TXProofMgr.cxx:1206
 TXProofMgr.cxx:1207
 TXProofMgr.cxx:1208
 TXProofMgr.cxx:1209
 TXProofMgr.cxx:1210
 TXProofMgr.cxx:1211
 TXProofMgr.cxx:1212
 TXProofMgr.cxx:1213
 TXProofMgr.cxx:1214
 TXProofMgr.cxx:1215
 TXProofMgr.cxx:1216
 TXProofMgr.cxx:1217
 TXProofMgr.cxx:1218
 TXProofMgr.cxx:1219
 TXProofMgr.cxx:1220
 TXProofMgr.cxx:1221
 TXProofMgr.cxx:1222
 TXProofMgr.cxx:1223
 TXProofMgr.cxx:1224
 TXProofMgr.cxx:1225
 TXProofMgr.cxx:1226
 TXProofMgr.cxx:1227
 TXProofMgr.cxx:1228
 TXProofMgr.cxx:1229
 TXProofMgr.cxx:1230
 TXProofMgr.cxx:1231
 TXProofMgr.cxx:1232
 TXProofMgr.cxx:1233
 TXProofMgr.cxx:1234
 TXProofMgr.cxx:1235
 TXProofMgr.cxx:1236
 TXProofMgr.cxx:1237
 TXProofMgr.cxx:1238
 TXProofMgr.cxx:1239
 TXProofMgr.cxx:1240
 TXProofMgr.cxx:1241
 TXProofMgr.cxx:1242
 TXProofMgr.cxx:1243
 TXProofMgr.cxx:1244
 TXProofMgr.cxx:1245
 TXProofMgr.cxx:1246
 TXProofMgr.cxx:1247
 TXProofMgr.cxx:1248
 TXProofMgr.cxx:1249
 TXProofMgr.cxx:1250
 TXProofMgr.cxx:1251
 TXProofMgr.cxx:1252
 TXProofMgr.cxx:1253
 TXProofMgr.cxx:1254
 TXProofMgr.cxx:1255
 TXProofMgr.cxx:1256
 TXProofMgr.cxx:1257
 TXProofMgr.cxx:1258
 TXProofMgr.cxx:1259
 TXProofMgr.cxx:1260
 TXProofMgr.cxx:1261
 TXProofMgr.cxx:1262
 TXProofMgr.cxx:1263
 TXProofMgr.cxx:1264
 TXProofMgr.cxx:1265
 TXProofMgr.cxx:1266
 TXProofMgr.cxx:1267
 TXProofMgr.cxx:1268
 TXProofMgr.cxx:1269
 TXProofMgr.cxx:1270
 TXProofMgr.cxx:1271
 TXProofMgr.cxx:1272
 TXProofMgr.cxx:1273
 TXProofMgr.cxx:1274
 TXProofMgr.cxx:1275
 TXProofMgr.cxx:1276
 TXProofMgr.cxx:1277
 TXProofMgr.cxx:1278
 TXProofMgr.cxx:1279
 TXProofMgr.cxx:1280
 TXProofMgr.cxx:1281
 TXProofMgr.cxx:1282
 TXProofMgr.cxx:1283
 TXProofMgr.cxx:1284
 TXProofMgr.cxx:1285
 TXProofMgr.cxx:1286
 TXProofMgr.cxx:1287
 TXProofMgr.cxx:1288
 TXProofMgr.cxx:1289
 TXProofMgr.cxx:1290
 TXProofMgr.cxx:1291
 TXProofMgr.cxx:1292
 TXProofMgr.cxx:1293
 TXProofMgr.cxx:1294
 TXProofMgr.cxx:1295
 TXProofMgr.cxx:1296
 TXProofMgr.cxx:1297
 TXProofMgr.cxx:1298
 TXProofMgr.cxx:1299
 TXProofMgr.cxx:1300
 TXProofMgr.cxx:1301
 TXProofMgr.cxx:1302
 TXProofMgr.cxx:1303
 TXProofMgr.cxx:1304
 TXProofMgr.cxx:1305
 TXProofMgr.cxx:1306
 TXProofMgr.cxx:1307
 TXProofMgr.cxx:1308
 TXProofMgr.cxx:1309
 TXProofMgr.cxx:1310
 TXProofMgr.cxx:1311
 TXProofMgr.cxx:1312
 TXProofMgr.cxx:1313
 TXProofMgr.cxx:1314
 TXProofMgr.cxx:1315
 TXProofMgr.cxx:1316
 TXProofMgr.cxx:1317
 TXProofMgr.cxx:1318
 TXProofMgr.cxx:1319
 TXProofMgr.cxx:1320
 TXProofMgr.cxx:1321
 TXProofMgr.cxx:1322
 TXProofMgr.cxx:1323
 TXProofMgr.cxx:1324
 TXProofMgr.cxx:1325
 TXProofMgr.cxx:1326
 TXProofMgr.cxx:1327
 TXProofMgr.cxx:1328
 TXProofMgr.cxx:1329
 TXProofMgr.cxx:1330
 TXProofMgr.cxx:1331
 TXProofMgr.cxx:1332
 TXProofMgr.cxx:1333
 TXProofMgr.cxx:1334
 TXProofMgr.cxx:1335
 TXProofMgr.cxx:1336
 TXProofMgr.cxx:1337
 TXProofMgr.cxx:1338
 TXProofMgr.cxx:1339
 TXProofMgr.cxx:1340
 TXProofMgr.cxx:1341
 TXProofMgr.cxx:1342
 TXProofMgr.cxx:1343
 TXProofMgr.cxx:1344
 TXProofMgr.cxx:1345
 TXProofMgr.cxx:1346
 TXProofMgr.cxx:1347
 TXProofMgr.cxx:1348
 TXProofMgr.cxx:1349
 TXProofMgr.cxx:1350
 TXProofMgr.cxx:1351
 TXProofMgr.cxx:1352
 TXProofMgr.cxx:1353
 TXProofMgr.cxx:1354
 TXProofMgr.cxx:1355
 TXProofMgr.cxx:1356
 TXProofMgr.cxx:1357
 TXProofMgr.cxx:1358
 TXProofMgr.cxx:1359
 TXProofMgr.cxx:1360
 TXProofMgr.cxx:1361
 TXProofMgr.cxx:1362
 TXProofMgr.cxx:1363
 TXProofMgr.cxx:1364
 TXProofMgr.cxx:1365
 TXProofMgr.cxx:1366
 TXProofMgr.cxx:1367
 TXProofMgr.cxx:1368
 TXProofMgr.cxx:1369
 TXProofMgr.cxx:1370
 TXProofMgr.cxx:1371
 TXProofMgr.cxx:1372
 TXProofMgr.cxx:1373
 TXProofMgr.cxx:1374
 TXProofMgr.cxx:1375
 TXProofMgr.cxx:1376
 TXProofMgr.cxx:1377
 TXProofMgr.cxx:1378
 TXProofMgr.cxx:1379
 TXProofMgr.cxx:1380
 TXProofMgr.cxx:1381
 TXProofMgr.cxx:1382
 TXProofMgr.cxx:1383
 TXProofMgr.cxx:1384
 TXProofMgr.cxx:1385
 TXProofMgr.cxx:1386
 TXProofMgr.cxx:1387
 TXProofMgr.cxx:1388
 TXProofMgr.cxx:1389
 TXProofMgr.cxx:1390
 TXProofMgr.cxx:1391
 TXProofMgr.cxx:1392
 TXProofMgr.cxx:1393
 TXProofMgr.cxx:1394
 TXProofMgr.cxx:1395
 TXProofMgr.cxx:1396
 TXProofMgr.cxx:1397
 TXProofMgr.cxx:1398
 TXProofMgr.cxx:1399
 TXProofMgr.cxx:1400
 TXProofMgr.cxx:1401
 TXProofMgr.cxx:1402
 TXProofMgr.cxx:1403
 TXProofMgr.cxx:1404
 TXProofMgr.cxx:1405
 TXProofMgr.cxx:1406
 TXProofMgr.cxx:1407
 TXProofMgr.cxx:1408
 TXProofMgr.cxx:1409
 TXProofMgr.cxx:1410
 TXProofMgr.cxx:1411
 TXProofMgr.cxx:1412
 TXProofMgr.cxx:1413
 TXProofMgr.cxx:1414
 TXProofMgr.cxx:1415
 TXProofMgr.cxx:1416
 TXProofMgr.cxx:1417
 TXProofMgr.cxx:1418
 TXProofMgr.cxx:1419
 TXProofMgr.cxx:1420
 TXProofMgr.cxx:1421
 TXProofMgr.cxx:1422
 TXProofMgr.cxx:1423
 TXProofMgr.cxx:1424
 TXProofMgr.cxx:1425
 TXProofMgr.cxx:1426
 TXProofMgr.cxx:1427
 TXProofMgr.cxx:1428
 TXProofMgr.cxx:1429
 TXProofMgr.cxx:1430
 TXProofMgr.cxx:1431
 TXProofMgr.cxx:1432
 TXProofMgr.cxx:1433
 TXProofMgr.cxx:1434
 TXProofMgr.cxx:1435
 TXProofMgr.cxx:1436
 TXProofMgr.cxx:1437
 TXProofMgr.cxx:1438
 TXProofMgr.cxx:1439
 TXProofMgr.cxx:1440
 TXProofMgr.cxx:1441
 TXProofMgr.cxx:1442
 TXProofMgr.cxx:1443
 TXProofMgr.cxx:1444
 TXProofMgr.cxx:1445
 TXProofMgr.cxx:1446
 TXProofMgr.cxx:1447
 TXProofMgr.cxx:1448
 TXProofMgr.cxx:1449
 TXProofMgr.cxx:1450
 TXProofMgr.cxx:1451
 TXProofMgr.cxx:1452
 TXProofMgr.cxx:1453
 TXProofMgr.cxx:1454
 TXProofMgr.cxx:1455
 TXProofMgr.cxx:1456
 TXProofMgr.cxx:1457
 TXProofMgr.cxx:1458
 TXProofMgr.cxx:1459
 TXProofMgr.cxx:1460
 TXProofMgr.cxx:1461
 TXProofMgr.cxx:1462
 TXProofMgr.cxx:1463
 TXProofMgr.cxx:1464
 TXProofMgr.cxx:1465
 TXProofMgr.cxx:1466
 TXProofMgr.cxx:1467
 TXProofMgr.cxx:1468
 TXProofMgr.cxx:1469
 TXProofMgr.cxx:1470
 TXProofMgr.cxx:1471
 TXProofMgr.cxx:1472
 TXProofMgr.cxx:1473
 TXProofMgr.cxx:1474
 TXProofMgr.cxx:1475
 TXProofMgr.cxx:1476
 TXProofMgr.cxx:1477
 TXProofMgr.cxx:1478
 TXProofMgr.cxx:1479
 TXProofMgr.cxx:1480
 TXProofMgr.cxx:1481
 TXProofMgr.cxx:1482
 TXProofMgr.cxx:1483
 TXProofMgr.cxx:1484
 TXProofMgr.cxx:1485
 TXProofMgr.cxx:1486
 TXProofMgr.cxx:1487
 TXProofMgr.cxx:1488
 TXProofMgr.cxx:1489
 TXProofMgr.cxx:1490
 TXProofMgr.cxx:1491
 TXProofMgr.cxx:1492
 TXProofMgr.cxx:1493
 TXProofMgr.cxx:1494
 TXProofMgr.cxx:1495
 TXProofMgr.cxx:1496
 TXProofMgr.cxx:1497
 TXProofMgr.cxx:1498
 TXProofMgr.cxx:1499
 TXProofMgr.cxx:1500
 TXProofMgr.cxx:1501
 TXProofMgr.cxx:1502
 TXProofMgr.cxx:1503
 TXProofMgr.cxx:1504
 TXProofMgr.cxx:1505
 TXProofMgr.cxx:1506
 TXProofMgr.cxx:1507
 TXProofMgr.cxx:1508
 TXProofMgr.cxx:1509
 TXProofMgr.cxx:1510
 TXProofMgr.cxx:1511
 TXProofMgr.cxx:1512
 TXProofMgr.cxx:1513
 TXProofMgr.cxx:1514
 TXProofMgr.cxx:1515
 TXProofMgr.cxx:1516
 TXProofMgr.cxx:1517
 TXProofMgr.cxx:1518
 TXProofMgr.cxx:1519
 TXProofMgr.cxx:1520
 TXProofMgr.cxx:1521
 TXProofMgr.cxx:1522
 TXProofMgr.cxx:1523
 TXProofMgr.cxx:1524
 TXProofMgr.cxx:1525
 TXProofMgr.cxx:1526
 TXProofMgr.cxx:1527
 TXProofMgr.cxx:1528
 TXProofMgr.cxx:1529
 TXProofMgr.cxx:1530
 TXProofMgr.cxx:1531
 TXProofMgr.cxx:1532
 TXProofMgr.cxx:1533
 TXProofMgr.cxx:1534
 TXProofMgr.cxx:1535
 TXProofMgr.cxx:1536
 TXProofMgr.cxx:1537
 TXProofMgr.cxx:1538
 TXProofMgr.cxx:1539
 TXProofMgr.cxx:1540
 TXProofMgr.cxx:1541
 TXProofMgr.cxx:1542
 TXProofMgr.cxx:1543
 TXProofMgr.cxx:1544
 TXProofMgr.cxx:1545
 TXProofMgr.cxx:1546
 TXProofMgr.cxx:1547
 TXProofMgr.cxx:1548
 TXProofMgr.cxx:1549
 TXProofMgr.cxx:1550
 TXProofMgr.cxx:1551
 TXProofMgr.cxx:1552
 TXProofMgr.cxx:1553
 TXProofMgr.cxx:1554
 TXProofMgr.cxx:1555
 TXProofMgr.cxx:1556
 TXProofMgr.cxx:1557
 TXProofMgr.cxx:1558
 TXProofMgr.cxx:1559
 TXProofMgr.cxx:1560
 TXProofMgr.cxx:1561
 TXProofMgr.cxx:1562
 TXProofMgr.cxx:1563
 TXProofMgr.cxx:1564
 TXProofMgr.cxx:1565
 TXProofMgr.cxx:1566
 TXProofMgr.cxx:1567
 TXProofMgr.cxx:1568
 TXProofMgr.cxx:1569
 TXProofMgr.cxx:1570
 TXProofMgr.cxx:1571
 TXProofMgr.cxx:1572
 TXProofMgr.cxx:1573
 TXProofMgr.cxx:1574
 TXProofMgr.cxx:1575
 TXProofMgr.cxx:1576
 TXProofMgr.cxx:1577
 TXProofMgr.cxx:1578
 TXProofMgr.cxx:1579
 TXProofMgr.cxx:1580
 TXProofMgr.cxx:1581
 TXProofMgr.cxx:1582
 TXProofMgr.cxx:1583
 TXProofMgr.cxx:1584
 TXProofMgr.cxx:1585
 TXProofMgr.cxx:1586
 TXProofMgr.cxx:1587
 TXProofMgr.cxx:1588
 TXProofMgr.cxx:1589
 TXProofMgr.cxx:1590
 TXProofMgr.cxx:1591
 TXProofMgr.cxx:1592
 TXProofMgr.cxx:1593
 TXProofMgr.cxx:1594
 TXProofMgr.cxx:1595
 TXProofMgr.cxx:1596
 TXProofMgr.cxx:1597
 TXProofMgr.cxx:1598
 TXProofMgr.cxx:1599
 TXProofMgr.cxx:1600
 TXProofMgr.cxx:1601
 TXProofMgr.cxx:1602
 TXProofMgr.cxx:1603
 TXProofMgr.cxx:1604
 TXProofMgr.cxx:1605
 TXProofMgr.cxx:1606
 TXProofMgr.cxx:1607
 TXProofMgr.cxx:1608
 TXProofMgr.cxx:1609
 TXProofMgr.cxx:1610
 TXProofMgr.cxx:1611
 TXProofMgr.cxx:1612
 TXProofMgr.cxx:1613
 TXProofMgr.cxx:1614
 TXProofMgr.cxx:1615
 TXProofMgr.cxx:1616
 TXProofMgr.cxx:1617
 TXProofMgr.cxx:1618
 TXProofMgr.cxx:1619
 TXProofMgr.cxx:1620
 TXProofMgr.cxx:1621
 TXProofMgr.cxx:1622
 TXProofMgr.cxx:1623
 TXProofMgr.cxx:1624
 TXProofMgr.cxx:1625
 TXProofMgr.cxx:1626
 TXProofMgr.cxx:1627
 TXProofMgr.cxx:1628
 TXProofMgr.cxx:1629
 TXProofMgr.cxx:1630
 TXProofMgr.cxx:1631
 TXProofMgr.cxx:1632
 TXProofMgr.cxx:1633
 TXProofMgr.cxx:1634
 TXProofMgr.cxx:1635
 TXProofMgr.cxx:1636
 TXProofMgr.cxx:1637
 TXProofMgr.cxx:1638
 TXProofMgr.cxx:1639
 TXProofMgr.cxx:1640
 TXProofMgr.cxx:1641
 TXProofMgr.cxx:1642
 TXProofMgr.cxx:1643
 TXProofMgr.cxx:1644
 TXProofMgr.cxx:1645
 TXProofMgr.cxx:1646
 TXProofMgr.cxx:1647
 TXProofMgr.cxx:1648
 TXProofMgr.cxx:1649
 TXProofMgr.cxx:1650
 TXProofMgr.cxx:1651
 TXProofMgr.cxx:1652
 TXProofMgr.cxx:1653
 TXProofMgr.cxx:1654
 TXProofMgr.cxx:1655
 TXProofMgr.cxx:1656
 TXProofMgr.cxx:1657
 TXProofMgr.cxx:1658
 TXProofMgr.cxx:1659
 TXProofMgr.cxx:1660
 TXProofMgr.cxx:1661
 TXProofMgr.cxx:1662
 TXProofMgr.cxx:1663
 TXProofMgr.cxx:1664
 TXProofMgr.cxx:1665
 TXProofMgr.cxx:1666
 TXProofMgr.cxx:1667
 TXProofMgr.cxx:1668
 TXProofMgr.cxx:1669
 TXProofMgr.cxx:1670
 TXProofMgr.cxx:1671
 TXProofMgr.cxx:1672
 TXProofMgr.cxx:1673
 TXProofMgr.cxx:1674
 TXProofMgr.cxx:1675
 TXProofMgr.cxx:1676
 TXProofMgr.cxx:1677
 TXProofMgr.cxx:1678
 TXProofMgr.cxx:1679
 TXProofMgr.cxx:1680
 TXProofMgr.cxx:1681
 TXProofMgr.cxx:1682
 TXProofMgr.cxx:1683
 TXProofMgr.cxx:1684
 TXProofMgr.cxx:1685
 TXProofMgr.cxx:1686
 TXProofMgr.cxx:1687
 TXProofMgr.cxx:1688
 TXProofMgr.cxx:1689
 TXProofMgr.cxx:1690
 TXProofMgr.cxx:1691
 TXProofMgr.cxx:1692
 TXProofMgr.cxx:1693
 TXProofMgr.cxx:1694
 TXProofMgr.cxx:1695
 TXProofMgr.cxx:1696
 TXProofMgr.cxx:1697
 TXProofMgr.cxx:1698
 TXProofMgr.cxx:1699
 TXProofMgr.cxx:1700
 TXProofMgr.cxx:1701
 TXProofMgr.cxx:1702
 TXProofMgr.cxx:1703
 TXProofMgr.cxx:1704
 TXProofMgr.cxx:1705
 TXProofMgr.cxx:1706
 TXProofMgr.cxx:1707
 TXProofMgr.cxx:1708
 TXProofMgr.cxx:1709
 TXProofMgr.cxx:1710
 TXProofMgr.cxx:1711
 TXProofMgr.cxx:1712
 TXProofMgr.cxx:1713
 TXProofMgr.cxx:1714
 TXProofMgr.cxx:1715
 TXProofMgr.cxx:1716
 TXProofMgr.cxx:1717
 TXProofMgr.cxx:1718
 TXProofMgr.cxx:1719
 TXProofMgr.cxx:1720
 TXProofMgr.cxx:1721
 TXProofMgr.cxx:1722
 TXProofMgr.cxx:1723
 TXProofMgr.cxx:1724
 TXProofMgr.cxx:1725
 TXProofMgr.cxx:1726
 TXProofMgr.cxx:1727
 TXProofMgr.cxx:1728
 TXProofMgr.cxx:1729
 TXProofMgr.cxx:1730
 TXProofMgr.cxx:1731
 TXProofMgr.cxx:1732
 TXProofMgr.cxx:1733
 TXProofMgr.cxx:1734
 TXProofMgr.cxx:1735
 TXProofMgr.cxx:1736
 TXProofMgr.cxx:1737
 TXProofMgr.cxx:1738
 TXProofMgr.cxx:1739
 TXProofMgr.cxx:1740
 TXProofMgr.cxx:1741
 TXProofMgr.cxx:1742
 TXProofMgr.cxx:1743
 TXProofMgr.cxx:1744
 TXProofMgr.cxx:1745
 TXProofMgr.cxx:1746
 TXProofMgr.cxx:1747
 TXProofMgr.cxx:1748
 TXProofMgr.cxx:1749
 TXProofMgr.cxx:1750
 TXProofMgr.cxx:1751
 TXProofMgr.cxx:1752
 TXProofMgr.cxx:1753
 TXProofMgr.cxx:1754
 TXProofMgr.cxx:1755
 TXProofMgr.cxx:1756
 TXProofMgr.cxx:1757
 TXProofMgr.cxx:1758
 TXProofMgr.cxx:1759
 TXProofMgr.cxx:1760
 TXProofMgr.cxx:1761
 TXProofMgr.cxx:1762
 TXProofMgr.cxx:1763
 TXProofMgr.cxx:1764
 TXProofMgr.cxx:1765
 TXProofMgr.cxx:1766
 TXProofMgr.cxx:1767
 TXProofMgr.cxx:1768
 TXProofMgr.cxx:1769
 TXProofMgr.cxx:1770
 TXProofMgr.cxx:1771
 TXProofMgr.cxx:1772
 TXProofMgr.cxx:1773
 TXProofMgr.cxx:1774
 TXProofMgr.cxx:1775
 TXProofMgr.cxx:1776
 TXProofMgr.cxx:1777
 TXProofMgr.cxx:1778
 TXProofMgr.cxx:1779
 TXProofMgr.cxx:1780
 TXProofMgr.cxx:1781
 TXProofMgr.cxx:1782
 TXProofMgr.cxx:1783
 TXProofMgr.cxx:1784
 TXProofMgr.cxx:1785
 TXProofMgr.cxx:1786
 TXProofMgr.cxx:1787
 TXProofMgr.cxx:1788
 TXProofMgr.cxx:1789
 TXProofMgr.cxx:1790
 TXProofMgr.cxx:1791
 TXProofMgr.cxx:1792
 TXProofMgr.cxx:1793
 TXProofMgr.cxx:1794
 TXProofMgr.cxx:1795
 TXProofMgr.cxx:1796
 TXProofMgr.cxx:1797
 TXProofMgr.cxx:1798
 TXProofMgr.cxx:1799
 TXProofMgr.cxx:1800
 TXProofMgr.cxx:1801
 TXProofMgr.cxx:1802
 TXProofMgr.cxx:1803
 TXProofMgr.cxx:1804
 TXProofMgr.cxx:1805