ROOT logo
// @(#)root/proof:$Id: TProofMgr.cxx 29579 2009-07-25 12:19:25Z ganis $
// Author: G. Ganis, Nov 2005

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

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

#include "TError.h"
#include "TEnv.h"
#include "TList.h"
#include "TProof.h"
#include "TProofMgr.h"
#include "TProofMgrLite.h"
#include "TROOT.h"

ClassImp(TProofMgr)

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

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

   fServType = kProofd;

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

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

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

   // Make sure that the user is defined
   if (strlen(fUrl.GetUser()) <= 0) {
      // Fill in the default user
      UserGroup_t *pw = gSystem->GetUserInfo();
      if (pw) {
         fUrl.SetUser(pw->fUser);
         delete pw;
      }
   }

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

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

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

   SafeDelete(fSessions);
   SafeDelete(fIntHandler);

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

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

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

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

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

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

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

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

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

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

   if (id > 0) {

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

   } else if (id == 0) {

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

   return;
}

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

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

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

   return;
}

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

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

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

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

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

   // We are done
   return fSessions;
}

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

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

   return -1;
}

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

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

   return -1;
}

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

   AbstractMethod("ShowWorkers");
}

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

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

   return d;
}

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

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

   return d;
}

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

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

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

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

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

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

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

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

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

   // We are done
   return p;
}

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

   TUrl u(url);

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

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

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

   // Match failed
   return kFALSE;
}

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

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

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

   // We are done
   return &fgListOfManagers;
}

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

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

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

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

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

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

   m = 0;
   Bool_t trystd = kTRUE;

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

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

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

   // We are done
   return m;
}

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

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

   // Done
   return fgTXProofMgrHook;
}

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

   fgTXProofMgrHook = pmh;
}


//
//  TProofDesc
//

ClassImp(TProofDesc)

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

   Printf("// # %d", fLocalId);
   Printf("// alias: %s, url: \"%s\"", GetTitle(), GetUrl());
   Printf("// tag: %s", GetName());
   Printf("// status: %s, attached: %s (remote ID: %d)",st[fStatus+1], (fProof ? "YES" : "NO"), fRemoteId);
}
 TProofMgr.cxx:1
 TProofMgr.cxx:2
 TProofMgr.cxx:3
 TProofMgr.cxx:4
 TProofMgr.cxx:5
 TProofMgr.cxx:6
 TProofMgr.cxx:7
 TProofMgr.cxx:8
 TProofMgr.cxx:9
 TProofMgr.cxx:10
 TProofMgr.cxx:11
 TProofMgr.cxx:12
 TProofMgr.cxx:13
 TProofMgr.cxx:14
 TProofMgr.cxx:15
 TProofMgr.cxx:16
 TProofMgr.cxx:17
 TProofMgr.cxx:18
 TProofMgr.cxx:19
 TProofMgr.cxx:20
 TProofMgr.cxx:21
 TProofMgr.cxx:22
 TProofMgr.cxx:23
 TProofMgr.cxx:24
 TProofMgr.cxx:25
 TProofMgr.cxx:26
 TProofMgr.cxx:27
 TProofMgr.cxx:28
 TProofMgr.cxx:29
 TProofMgr.cxx:30
 TProofMgr.cxx:31
 TProofMgr.cxx:32
 TProofMgr.cxx:33
 TProofMgr.cxx:34
 TProofMgr.cxx:35
 TProofMgr.cxx:36
 TProofMgr.cxx:37
 TProofMgr.cxx:38
 TProofMgr.cxx:39
 TProofMgr.cxx:40
 TProofMgr.cxx:41
 TProofMgr.cxx:42
 TProofMgr.cxx:43
 TProofMgr.cxx:44
 TProofMgr.cxx:45
 TProofMgr.cxx:46
 TProofMgr.cxx:47
 TProofMgr.cxx:48
 TProofMgr.cxx:49
 TProofMgr.cxx:50
 TProofMgr.cxx:51
 TProofMgr.cxx:52
 TProofMgr.cxx:53
 TProofMgr.cxx:54
 TProofMgr.cxx:55
 TProofMgr.cxx:56
 TProofMgr.cxx:57
 TProofMgr.cxx:58
 TProofMgr.cxx:59
 TProofMgr.cxx:60
 TProofMgr.cxx:61
 TProofMgr.cxx:62
 TProofMgr.cxx:63
 TProofMgr.cxx:64
 TProofMgr.cxx:65
 TProofMgr.cxx:66
 TProofMgr.cxx:67
 TProofMgr.cxx:68
 TProofMgr.cxx:69
 TProofMgr.cxx:70
 TProofMgr.cxx:71
 TProofMgr.cxx:72
 TProofMgr.cxx:73
 TProofMgr.cxx:74
 TProofMgr.cxx:75
 TProofMgr.cxx:76
 TProofMgr.cxx:77
 TProofMgr.cxx:78
 TProofMgr.cxx:79
 TProofMgr.cxx:80
 TProofMgr.cxx:81
 TProofMgr.cxx:82
 TProofMgr.cxx:83
 TProofMgr.cxx:84
 TProofMgr.cxx:85
 TProofMgr.cxx:86
 TProofMgr.cxx:87
 TProofMgr.cxx:88
 TProofMgr.cxx:89
 TProofMgr.cxx:90
 TProofMgr.cxx:91
 TProofMgr.cxx:92
 TProofMgr.cxx:93
 TProofMgr.cxx:94
 TProofMgr.cxx:95
 TProofMgr.cxx:96
 TProofMgr.cxx:97
 TProofMgr.cxx:98
 TProofMgr.cxx:99
 TProofMgr.cxx:100
 TProofMgr.cxx:101
 TProofMgr.cxx:102
 TProofMgr.cxx:103
 TProofMgr.cxx:104
 TProofMgr.cxx:105
 TProofMgr.cxx:106
 TProofMgr.cxx:107
 TProofMgr.cxx:108
 TProofMgr.cxx:109
 TProofMgr.cxx:110
 TProofMgr.cxx:111
 TProofMgr.cxx:112
 TProofMgr.cxx:113
 TProofMgr.cxx:114
 TProofMgr.cxx:115
 TProofMgr.cxx:116
 TProofMgr.cxx:117
 TProofMgr.cxx:118
 TProofMgr.cxx:119
 TProofMgr.cxx:120
 TProofMgr.cxx:121
 TProofMgr.cxx:122
 TProofMgr.cxx:123
 TProofMgr.cxx:124
 TProofMgr.cxx:125
 TProofMgr.cxx:126
 TProofMgr.cxx:127
 TProofMgr.cxx:128
 TProofMgr.cxx:129
 TProofMgr.cxx:130
 TProofMgr.cxx:131
 TProofMgr.cxx:132
 TProofMgr.cxx:133
 TProofMgr.cxx:134
 TProofMgr.cxx:135
 TProofMgr.cxx:136
 TProofMgr.cxx:137
 TProofMgr.cxx:138
 TProofMgr.cxx:139
 TProofMgr.cxx:140
 TProofMgr.cxx:141
 TProofMgr.cxx:142
 TProofMgr.cxx:143
 TProofMgr.cxx:144
 TProofMgr.cxx:145
 TProofMgr.cxx:146
 TProofMgr.cxx:147
 TProofMgr.cxx:148
 TProofMgr.cxx:149
 TProofMgr.cxx:150
 TProofMgr.cxx:151
 TProofMgr.cxx:152
 TProofMgr.cxx:153
 TProofMgr.cxx:154
 TProofMgr.cxx:155
 TProofMgr.cxx:156
 TProofMgr.cxx:157
 TProofMgr.cxx:158
 TProofMgr.cxx:159
 TProofMgr.cxx:160
 TProofMgr.cxx:161
 TProofMgr.cxx:162
 TProofMgr.cxx:163
 TProofMgr.cxx:164
 TProofMgr.cxx:165
 TProofMgr.cxx:166
 TProofMgr.cxx:167
 TProofMgr.cxx:168
 TProofMgr.cxx:169
 TProofMgr.cxx:170
 TProofMgr.cxx:171
 TProofMgr.cxx:172
 TProofMgr.cxx:173
 TProofMgr.cxx:174
 TProofMgr.cxx:175
 TProofMgr.cxx:176
 TProofMgr.cxx:177
 TProofMgr.cxx:178
 TProofMgr.cxx:179
 TProofMgr.cxx:180
 TProofMgr.cxx:181
 TProofMgr.cxx:182
 TProofMgr.cxx:183
 TProofMgr.cxx:184
 TProofMgr.cxx:185
 TProofMgr.cxx:186
 TProofMgr.cxx:187
 TProofMgr.cxx:188
 TProofMgr.cxx:189
 TProofMgr.cxx:190
 TProofMgr.cxx:191
 TProofMgr.cxx:192
 TProofMgr.cxx:193
 TProofMgr.cxx:194
 TProofMgr.cxx:195
 TProofMgr.cxx:196
 TProofMgr.cxx:197
 TProofMgr.cxx:198
 TProofMgr.cxx:199
 TProofMgr.cxx:200
 TProofMgr.cxx:201
 TProofMgr.cxx:202
 TProofMgr.cxx:203
 TProofMgr.cxx:204
 TProofMgr.cxx:205
 TProofMgr.cxx:206
 TProofMgr.cxx:207
 TProofMgr.cxx:208
 TProofMgr.cxx:209
 TProofMgr.cxx:210
 TProofMgr.cxx:211
 TProofMgr.cxx:212
 TProofMgr.cxx:213
 TProofMgr.cxx:214
 TProofMgr.cxx:215
 TProofMgr.cxx:216
 TProofMgr.cxx:217
 TProofMgr.cxx:218
 TProofMgr.cxx:219
 TProofMgr.cxx:220
 TProofMgr.cxx:221
 TProofMgr.cxx:222
 TProofMgr.cxx:223
 TProofMgr.cxx:224
 TProofMgr.cxx:225
 TProofMgr.cxx:226
 TProofMgr.cxx:227
 TProofMgr.cxx:228
 TProofMgr.cxx:229
 TProofMgr.cxx:230
 TProofMgr.cxx:231
 TProofMgr.cxx:232
 TProofMgr.cxx:233
 TProofMgr.cxx:234
 TProofMgr.cxx:235
 TProofMgr.cxx:236
 TProofMgr.cxx:237
 TProofMgr.cxx:238
 TProofMgr.cxx:239
 TProofMgr.cxx:240
 TProofMgr.cxx:241
 TProofMgr.cxx:242
 TProofMgr.cxx:243
 TProofMgr.cxx:244
 TProofMgr.cxx:245
 TProofMgr.cxx:246
 TProofMgr.cxx:247
 TProofMgr.cxx:248
 TProofMgr.cxx:249
 TProofMgr.cxx:250
 TProofMgr.cxx:251
 TProofMgr.cxx:252
 TProofMgr.cxx:253
 TProofMgr.cxx:254
 TProofMgr.cxx:255
 TProofMgr.cxx:256
 TProofMgr.cxx:257
 TProofMgr.cxx:258
 TProofMgr.cxx:259
 TProofMgr.cxx:260
 TProofMgr.cxx:261
 TProofMgr.cxx:262
 TProofMgr.cxx:263
 TProofMgr.cxx:264
 TProofMgr.cxx:265
 TProofMgr.cxx:266
 TProofMgr.cxx:267
 TProofMgr.cxx:268
 TProofMgr.cxx:269
 TProofMgr.cxx:270
 TProofMgr.cxx:271
 TProofMgr.cxx:272
 TProofMgr.cxx:273
 TProofMgr.cxx:274
 TProofMgr.cxx:275
 TProofMgr.cxx:276
 TProofMgr.cxx:277
 TProofMgr.cxx:278
 TProofMgr.cxx:279
 TProofMgr.cxx:280
 TProofMgr.cxx:281
 TProofMgr.cxx:282
 TProofMgr.cxx:283
 TProofMgr.cxx:284
 TProofMgr.cxx:285
 TProofMgr.cxx:286
 TProofMgr.cxx:287
 TProofMgr.cxx:288
 TProofMgr.cxx:289
 TProofMgr.cxx:290
 TProofMgr.cxx:291
 TProofMgr.cxx:292
 TProofMgr.cxx:293
 TProofMgr.cxx:294
 TProofMgr.cxx:295
 TProofMgr.cxx:296
 TProofMgr.cxx:297
 TProofMgr.cxx:298
 TProofMgr.cxx:299
 TProofMgr.cxx:300
 TProofMgr.cxx:301
 TProofMgr.cxx:302
 TProofMgr.cxx:303
 TProofMgr.cxx:304
 TProofMgr.cxx:305
 TProofMgr.cxx:306
 TProofMgr.cxx:307
 TProofMgr.cxx:308
 TProofMgr.cxx:309
 TProofMgr.cxx:310
 TProofMgr.cxx:311
 TProofMgr.cxx:312
 TProofMgr.cxx:313
 TProofMgr.cxx:314
 TProofMgr.cxx:315
 TProofMgr.cxx:316
 TProofMgr.cxx:317
 TProofMgr.cxx:318
 TProofMgr.cxx:319
 TProofMgr.cxx:320
 TProofMgr.cxx:321
 TProofMgr.cxx:322
 TProofMgr.cxx:323
 TProofMgr.cxx:324
 TProofMgr.cxx:325
 TProofMgr.cxx:326
 TProofMgr.cxx:327
 TProofMgr.cxx:328
 TProofMgr.cxx:329
 TProofMgr.cxx:330
 TProofMgr.cxx:331
 TProofMgr.cxx:332
 TProofMgr.cxx:333
 TProofMgr.cxx:334
 TProofMgr.cxx:335
 TProofMgr.cxx:336
 TProofMgr.cxx:337
 TProofMgr.cxx:338
 TProofMgr.cxx:339
 TProofMgr.cxx:340
 TProofMgr.cxx:341
 TProofMgr.cxx:342
 TProofMgr.cxx:343
 TProofMgr.cxx:344
 TProofMgr.cxx:345
 TProofMgr.cxx:346
 TProofMgr.cxx:347
 TProofMgr.cxx:348
 TProofMgr.cxx:349
 TProofMgr.cxx:350
 TProofMgr.cxx:351
 TProofMgr.cxx:352
 TProofMgr.cxx:353
 TProofMgr.cxx:354
 TProofMgr.cxx:355
 TProofMgr.cxx:356
 TProofMgr.cxx:357
 TProofMgr.cxx:358
 TProofMgr.cxx:359
 TProofMgr.cxx:360
 TProofMgr.cxx:361
 TProofMgr.cxx:362
 TProofMgr.cxx:363
 TProofMgr.cxx:364
 TProofMgr.cxx:365
 TProofMgr.cxx:366
 TProofMgr.cxx:367
 TProofMgr.cxx:368
 TProofMgr.cxx:369
 TProofMgr.cxx:370
 TProofMgr.cxx:371
 TProofMgr.cxx:372
 TProofMgr.cxx:373
 TProofMgr.cxx:374
 TProofMgr.cxx:375
 TProofMgr.cxx:376
 TProofMgr.cxx:377
 TProofMgr.cxx:378
 TProofMgr.cxx:379
 TProofMgr.cxx:380
 TProofMgr.cxx:381
 TProofMgr.cxx:382
 TProofMgr.cxx:383
 TProofMgr.cxx:384
 TProofMgr.cxx:385
 TProofMgr.cxx:386
 TProofMgr.cxx:387
 TProofMgr.cxx:388
 TProofMgr.cxx:389
 TProofMgr.cxx:390
 TProofMgr.cxx:391
 TProofMgr.cxx:392
 TProofMgr.cxx:393
 TProofMgr.cxx:394
 TProofMgr.cxx:395
 TProofMgr.cxx:396
 TProofMgr.cxx:397
 TProofMgr.cxx:398
 TProofMgr.cxx:399
 TProofMgr.cxx:400
 TProofMgr.cxx:401
 TProofMgr.cxx:402
 TProofMgr.cxx:403
 TProofMgr.cxx:404
 TProofMgr.cxx:405
 TProofMgr.cxx:406
 TProofMgr.cxx:407
 TProofMgr.cxx:408
 TProofMgr.cxx:409
 TProofMgr.cxx:410
 TProofMgr.cxx:411
 TProofMgr.cxx:412
 TProofMgr.cxx:413
 TProofMgr.cxx:414
 TProofMgr.cxx:415
 TProofMgr.cxx:416
 TProofMgr.cxx:417
 TProofMgr.cxx:418
 TProofMgr.cxx:419
 TProofMgr.cxx:420
 TProofMgr.cxx:421
 TProofMgr.cxx:422
 TProofMgr.cxx:423
 TProofMgr.cxx:424
 TProofMgr.cxx:425
 TProofMgr.cxx:426
 TProofMgr.cxx:427
 TProofMgr.cxx:428
 TProofMgr.cxx:429
 TProofMgr.cxx:430
 TProofMgr.cxx:431
 TProofMgr.cxx:432
 TProofMgr.cxx:433
 TProofMgr.cxx:434
 TProofMgr.cxx:435
 TProofMgr.cxx:436
 TProofMgr.cxx:437
 TProofMgr.cxx:438
 TProofMgr.cxx:439
 TProofMgr.cxx:440
 TProofMgr.cxx:441
 TProofMgr.cxx:442
 TProofMgr.cxx:443
 TProofMgr.cxx:444
 TProofMgr.cxx:445
 TProofMgr.cxx:446
 TProofMgr.cxx:447
 TProofMgr.cxx:448
 TProofMgr.cxx:449
 TProofMgr.cxx:450
 TProofMgr.cxx:451
 TProofMgr.cxx:452
 TProofMgr.cxx:453
 TProofMgr.cxx:454
 TProofMgr.cxx:455
 TProofMgr.cxx:456
 TProofMgr.cxx:457
 TProofMgr.cxx:458
 TProofMgr.cxx:459
 TProofMgr.cxx:460
 TProofMgr.cxx:461
 TProofMgr.cxx:462
 TProofMgr.cxx:463
 TProofMgr.cxx:464
 TProofMgr.cxx:465
 TProofMgr.cxx:466
 TProofMgr.cxx:467
 TProofMgr.cxx:468
 TProofMgr.cxx:469
 TProofMgr.cxx:470
 TProofMgr.cxx:471
 TProofMgr.cxx:472
 TProofMgr.cxx:473
 TProofMgr.cxx:474
 TProofMgr.cxx:475
 TProofMgr.cxx:476
 TProofMgr.cxx:477
 TProofMgr.cxx:478
 TProofMgr.cxx:479
 TProofMgr.cxx:480
 TProofMgr.cxx:481
 TProofMgr.cxx:482
 TProofMgr.cxx:483
 TProofMgr.cxx:484
 TProofMgr.cxx:485
 TProofMgr.cxx:486
 TProofMgr.cxx:487
 TProofMgr.cxx:488
 TProofMgr.cxx:489
 TProofMgr.cxx:490
 TProofMgr.cxx:491
 TProofMgr.cxx:492
 TProofMgr.cxx:493
 TProofMgr.cxx:494
 TProofMgr.cxx:495
 TProofMgr.cxx:496
 TProofMgr.cxx:497
 TProofMgr.cxx:498
 TProofMgr.cxx:499
 TProofMgr.cxx:500
 TProofMgr.cxx:501
 TProofMgr.cxx:502
 TProofMgr.cxx:503
 TProofMgr.cxx:504
 TProofMgr.cxx:505
 TProofMgr.cxx:506
 TProofMgr.cxx:507
 TProofMgr.cxx:508
 TProofMgr.cxx:509
 TProofMgr.cxx:510
 TProofMgr.cxx:511
 TProofMgr.cxx:512
 TProofMgr.cxx:513
 TProofMgr.cxx:514
 TProofMgr.cxx:515
 TProofMgr.cxx:516
 TProofMgr.cxx:517
 TProofMgr.cxx:518
 TProofMgr.cxx:519
 TProofMgr.cxx:520
 TProofMgr.cxx:521
 TProofMgr.cxx:522
 TProofMgr.cxx:523
 TProofMgr.cxx:524
 TProofMgr.cxx:525
 TProofMgr.cxx:526
 TProofMgr.cxx:527
 TProofMgr.cxx:528
 TProofMgr.cxx:529
 TProofMgr.cxx:530
 TProofMgr.cxx:531
 TProofMgr.cxx:532
 TProofMgr.cxx:533
 TProofMgr.cxx:534
 TProofMgr.cxx:535
 TProofMgr.cxx:536
 TProofMgr.cxx:537
 TProofMgr.cxx:538
 TProofMgr.cxx:539
 TProofMgr.cxx:540
 TProofMgr.cxx:541
 TProofMgr.cxx:542
 TProofMgr.cxx:543
 TProofMgr.cxx:544
 TProofMgr.cxx:545
 TProofMgr.cxx:546
 TProofMgr.cxx:547
 TProofMgr.cxx:548
 TProofMgr.cxx:549
 TProofMgr.cxx:550
 TProofMgr.cxx:551
 TProofMgr.cxx:552
 TProofMgr.cxx:553
 TProofMgr.cxx:554
 TProofMgr.cxx:555
 TProofMgr.cxx:556
 TProofMgr.cxx:557
 TProofMgr.cxx:558
 TProofMgr.cxx:559
 TProofMgr.cxx:560
 TProofMgr.cxx:561
 TProofMgr.cxx:562
 TProofMgr.cxx:563
 TProofMgr.cxx:564
 TProofMgr.cxx:565
 TProofMgr.cxx:566
 TProofMgr.cxx:567
 TProofMgr.cxx:568
 TProofMgr.cxx:569
 TProofMgr.cxx:570
 TProofMgr.cxx:571
 TProofMgr.cxx:572
 TProofMgr.cxx:573
 TProofMgr.cxx:574
 TProofMgr.cxx:575
 TProofMgr.cxx:576
 TProofMgr.cxx:577
 TProofMgr.cxx:578
 TProofMgr.cxx:579
 TProofMgr.cxx:580
 TProofMgr.cxx:581
 TProofMgr.cxx:582
 TProofMgr.cxx:583
 TProofMgr.cxx:584
 TProofMgr.cxx:585
 TProofMgr.cxx:586
 TProofMgr.cxx:587
 TProofMgr.cxx:588
 TProofMgr.cxx:589
 TProofMgr.cxx:590
 TProofMgr.cxx:591
 TProofMgr.cxx:592
 TProofMgr.cxx:593
 TProofMgr.cxx:594
 TProofMgr.cxx:595
 TProofMgr.cxx:596
 TProofMgr.cxx:597
 TProofMgr.cxx:598
 TProofMgr.cxx:599
 TProofMgr.cxx:600
 TProofMgr.cxx:601
 TProofMgr.cxx:602
 TProofMgr.cxx:603
 TProofMgr.cxx:604
 TProofMgr.cxx:605
 TProofMgr.cxx:606
 TProofMgr.cxx:607
 TProofMgr.cxx:608
 TProofMgr.cxx:609
 TProofMgr.cxx:610
 TProofMgr.cxx:611
 TProofMgr.cxx:612
 TProofMgr.cxx:613
 TProofMgr.cxx:614
 TProofMgr.cxx:615
 TProofMgr.cxx:616
 TProofMgr.cxx:617
 TProofMgr.cxx:618
 TProofMgr.cxx:619
 TProofMgr.cxx:620
 TProofMgr.cxx:621
 TProofMgr.cxx:622
 TProofMgr.cxx:623
 TProofMgr.cxx:624