// @(#)root/proofx:$Id$
// Author: Gerardo Ganis Apr 2008

/*************************************************************************
 * 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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofMgrLite                                                        //
//                                                                      //
// Basic functionality implementtaion in the case of Lite sessions      //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <errno.h>
#ifdef WIN32
#include <io.h>
#endif

#include "TProofMgrLite.h"

#include "Riostream.h"
#include "TEnv.h"
#include "TError.h"
#include "TObjString.h"
#include "TProofLite.h"
#include "TProofLog.h"
#include "TROOT.h"
#include "TRegexp.h"
#include "TSortedList.h"

ClassImp(TProofMgrLite)

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

   // Set the correct servert type
   fServType = kProofLite;
}

//______________________________________________________________________________
TProof *TProofMgrLite::CreateSession(const char *cfg,
                                     const char *, Int_t loglevel)
{
   // Create a new session

   TString c(fUrl.GetOptions());
   if (!c.Contains("workers=") && cfg && strstr(cfg, "workers=")) c = cfg;
   Int_t nwrk = TProofLite::GetNumberOfWorkers(c);
   if (nwrk == 0) return (TProof *)0;

   // Check if we have already a running session
   if (gProof && gProof->IsLite()) {
      if (gProof->IsValid()) {
         if (nwrk > 0 && gProof->GetParallel() != nwrk) {
            delete gProof;
            gProof = 0;
         } else {
            // We have already a running session
            return gProof;
         }
      } else {
         // Remove existing instance
         delete gProof;
         gProof = 0;
      }
   }

   // Create the instance
   TString u("lite");
   if (strlen(fUrl.GetOptions()) > 0) u.Form("lite/?%s", fUrl.GetOptions());
   TProof *p = new TProofLite(u, cfg, 0, 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
      Error("CreateSession", "creating PROOF session");
      SafeDelete(p);
   }

   // We are done
   return p;
}

//_____________________________________________________________________________
TProofLog *TProofMgrLite::GetSessionLogs(Int_t isess, const char *stag,
                                         const char *pattern, Bool_t)
{
   // 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".
   // Returns a TProofLog object (to be deleted by the caller) on success,
   // 0 if something wrong happened.

   TProofLog *pl = 0;

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

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

   // The working dir
   TString sandbox(gSystem->WorkingDirectory());
   sandbox.ReplaceAll(gSystem->HomeDirectory(),"");
   sandbox.ReplaceAll("/","-");
   sandbox.Replace(0,1,"/",1);
   if (strlen(gEnv->GetValue("ProofLite.Sandbox", "")) > 0) {
      sandbox.Insert(0, gEnv->GetValue("ProofLite.Sandbox", ""));
   } else if (strlen(gEnv->GetValue("Proof.Sandbox", "")) > 0) {
      sandbox.Insert(0, gEnv->GetValue("Proof.Sandbox", ""));
   } else {
      TString sb;
      sb.Form("~/%s", kPROOF_WorkDir);
      sandbox.Insert(0, sb.Data());
   }
   gSystem->ExpandPathName(sandbox);

   TString sessiondir;
   if (tag.Length() > 0) {
      sessiondir.Form("%s/session-%s", sandbox.Data(), tag.Data());
      if (gSystem->AccessPathName(sessiondir, kReadPermission)) {
         Error("GetSessionLogs", "information for session '%s' not available", tag.Data());
         return (TProofLog *)0;
      }
   } else {
      // Get the list of available dirs
      TSortedList *olddirs = new TSortedList(kFALSE);
      void *dirp = gSystem->OpenDirectory(sandbox);
      if (dirp) {
         const char *e = 0;
         while ((e = gSystem->GetDirEntry(dirp))) {
            if (!strncmp(e, "session-", 8)) {
               TString d(e);
               Int_t i = d.Last('-');
               if (i != kNPOS) d.Remove(i);
               i = d.Last('-');
               if (i != kNPOS) d.Remove(0,i+1);
               TString path = Form("%s/%s", sandbox.Data(), e);
               olddirs->Add(new TNamed(d, path));
            }
         }
         gSystem->FreeDirectory(dirp);
      }

      // Check isess
      if (isess > olddirs->GetSize() - 1) {
         Warning("GetSessionLogs",
                 "session index out of range (%d): take oldest available session", isess);
         isess = olddirs->GetSize() - 1;
      }

      // Locate the session dir
      Int_t isx = isess;
      TNamed *n = (TNamed *) olddirs->First();
      while (isx-- > 0) {
         olddirs->Remove(n);
         delete n;
         n = (TNamed *) olddirs->First();
      }
      if (!n) {
         Error("GetSessionLogs", "cannot locate session dir for index '%d' under '%s':"
                                 " cannot continue!", isess, sandbox.Data());
         return (TProofLog *)0;
      }
      sessiondir = n->GetTitle();
      tag = gSystem->BaseName(sessiondir);
      tag.ReplaceAll("session-", "");

      // Cleanup
      olddirs->SetOwner();
      delete olddirs;
   }
   Info("GetSessionLogs", "analysing session dir %s", sessiondir.Data());

   // Create the instance now
   pl = new TProofLog(tag, "", this);

   void *dirp = gSystem->OpenDirectory(sessiondir);
   if (dirp) {
      TSortedList *logs = new TSortedList;
      const char *e = 0;
      while ((e = gSystem->GetDirEntry(dirp))) {
         TString fn(e);
         if (fn.EndsWith(".log") && fn.CountChar('-') > 0) {
            TString ord, url;
            if (fn.BeginsWith("session-")) {
               ord = "-1";
            } else if (fn.BeginsWith("worker-")) {
               ord = fn;
               ord.ReplaceAll("worker-", "");
               Int_t id = ord.First('-');
               if (id != kNPOS) {
                  ord.Remove(id);
               } else if (ord.Contains(".valgrind")) {
                  // Add to the list (special tag for valgrind outputs)
                  ord.ReplaceAll(".valgrind.log","-valgrind");
               } else {
                  // Not a good path
                  ord = "";
               }
               if (!ord.IsNull()) ord.ReplaceAll("0.", "");
            }
            if (!ord.IsNull()) {
               url = Form("%s/%s", sessiondir.Data(), e);
               // Add to the list
               logs->Add(new TNamed(ord, url));
               // Notify
               if (gDebug > 1)
                  Info("GetSessionLogs", "ord: %s, url: %s", ord.Data(), url.Data());
            }
         }
      }
      gSystem->FreeDirectory(dirp);

      TIter nxl(logs);
      TNamed *n = 0;
      while ((n = (TNamed *) nxl())) {
         TString ord = Form("0.%s", n->GetName());
         if (ord == "0.-1") ord = "0";
         // Add to the list
         pl->Add(ord, n->GetTitle());
      }

      // Cleanup
      logs->SetOwner();
      delete logs;
   }

   // Retrieve the default part
   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 *TProofMgrLite::ReadBuffer(const char *fin, Long64_t ofs, Int_t len)
{
   // Read 'len' bytes from offset 'ofs' of the local file 'fin'.
   // Returns a TObjString with the content or 0, in case of failure

   if (!fin || strlen(fin) <= 0) {
      Error("ReadBuffer", "undefined path!");
      return (TObjString *)0;
   }

   // Open the file
   TString fn = TUrl(fin).GetFile();
   Int_t fd = open(fn.Data(), O_RDONLY);
   if (fd < 0) {
      Error("ReadBuffer", "problems opening file %s", fn.Data());
      return (TObjString *)0;
   }

   // Total size
   off_t start = 0, end = lseek(fd, (off_t) 0, SEEK_END);

   // Set the offset
   if (ofs > 0 && ofs < end) {
      start = lseek(fd, (off_t) ofs, SEEK_SET);
   } else {
      start = lseek(fd, (off_t) 0, SEEK_SET);
   }
   if (len > (end - start + 1) || len <= 0)
      len = end - start + 1;

   TString outbuf;
   const Int_t kMAXBUF = 32768;
   char buf[kMAXBUF];
   Int_t left = len;
   Int_t wanted = (left > kMAXBUF - 1) ? kMAXBUF - 1 : left;
   do {
      while ((len = read(fd, buf, wanted)) < 0 && TSystem::GetErrno() == EINTR)
         TSystem::ResetErrno();

      if (len < 0) {
         Error("ReadBuffer", "error reading file %s", fn.Data());
         close(fd);
         return (TObjString *)0;
      } else if (len > 0) {
         if (len == wanted)
            buf[len-1] = '\n';
         buf[len] = '\0';
         outbuf += buf;
      }

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

   } while (len > 0 && left > 0);

   // Close file
   close(fd);

   // Done
   return new TObjString(outbuf.Data());
}

//______________________________________________________________________________
TObjString *TProofMgrLite::ReadBuffer(const char *fin, const char *pattern)
{
   // Read lines containing 'pattern' in 'file'.
   // Returns a TObjString with the content or 0, in case of failure

   // If no pattern, read everything
   if (!pattern || strlen(pattern) <= 0)
      return (TObjString *)0;

   if (!fin || strlen(fin) <= 0) {
      Error("ReadBuffer", "undefined path!");
      return (TObjString *)0;
   }
   TString fn = TUrl(fin).GetFile();

   TString pat(pattern);
   // Check if "-v"
   Bool_t excl = kFALSE;
   if (pat.Contains("-v ")) {
      pat.ReplaceAll("-v ", "");
      excl = kTRUE;
   }
   pat = pat.Strip(TString::kLeading, ' ');
   pat = pat.Strip(TString::kTrailing, ' ');
   pat = pat.Strip(TString::kLeading, '\"');
   pat = pat.Strip(TString::kTrailing, '\"');

   // Use a regular expression
   TRegexp re(pat);

   // Open file with file info
   std::ifstream in;
   in.open(fn.Data());

   TString outbuf;

   // Read the input list of files and add them to the chain
   TString line;
   while(in.good()) {

      // Read next line
      line.ReadLine(in);

      // Keep only lines with pattern
      if ((excl && line.Index(re) != kNPOS) ||
          (!excl && line.Index(re) == kNPOS)) continue;

      // Remove trailing '\n', if any
      if (!line.EndsWith("\n")) line.Append('\n');

      // Add to output
      outbuf += line;
   }
   in.close();

   // Done
   return new TObjString(outbuf.Data());
}
 TProofMgrLite.cxx:1
 TProofMgrLite.cxx:2
 TProofMgrLite.cxx:3
 TProofMgrLite.cxx:4
 TProofMgrLite.cxx:5
 TProofMgrLite.cxx:6
 TProofMgrLite.cxx:7
 TProofMgrLite.cxx:8
 TProofMgrLite.cxx:9
 TProofMgrLite.cxx:10
 TProofMgrLite.cxx:11
 TProofMgrLite.cxx:12
 TProofMgrLite.cxx:13
 TProofMgrLite.cxx:14
 TProofMgrLite.cxx:15
 TProofMgrLite.cxx:16
 TProofMgrLite.cxx:17
 TProofMgrLite.cxx:18
 TProofMgrLite.cxx:19
 TProofMgrLite.cxx:20
 TProofMgrLite.cxx:21
 TProofMgrLite.cxx:22
 TProofMgrLite.cxx:23
 TProofMgrLite.cxx:24
 TProofMgrLite.cxx:25
 TProofMgrLite.cxx:26
 TProofMgrLite.cxx:27
 TProofMgrLite.cxx:28
 TProofMgrLite.cxx:29
 TProofMgrLite.cxx:30
 TProofMgrLite.cxx:31
 TProofMgrLite.cxx:32
 TProofMgrLite.cxx:33
 TProofMgrLite.cxx:34
 TProofMgrLite.cxx:35
 TProofMgrLite.cxx:36
 TProofMgrLite.cxx:37
 TProofMgrLite.cxx:38
 TProofMgrLite.cxx:39
 TProofMgrLite.cxx:40
 TProofMgrLite.cxx:41
 TProofMgrLite.cxx:42
 TProofMgrLite.cxx:43
 TProofMgrLite.cxx:44
 TProofMgrLite.cxx:45
 TProofMgrLite.cxx:46
 TProofMgrLite.cxx:47
 TProofMgrLite.cxx:48
 TProofMgrLite.cxx:49
 TProofMgrLite.cxx:50
 TProofMgrLite.cxx:51
 TProofMgrLite.cxx:52
 TProofMgrLite.cxx:53
 TProofMgrLite.cxx:54
 TProofMgrLite.cxx:55
 TProofMgrLite.cxx:56
 TProofMgrLite.cxx:57
 TProofMgrLite.cxx:58
 TProofMgrLite.cxx:59
 TProofMgrLite.cxx:60
 TProofMgrLite.cxx:61
 TProofMgrLite.cxx:62
 TProofMgrLite.cxx:63
 TProofMgrLite.cxx:64
 TProofMgrLite.cxx:65
 TProofMgrLite.cxx:66
 TProofMgrLite.cxx:67
 TProofMgrLite.cxx:68
 TProofMgrLite.cxx:69
 TProofMgrLite.cxx:70
 TProofMgrLite.cxx:71
 TProofMgrLite.cxx:72
 TProofMgrLite.cxx:73
 TProofMgrLite.cxx:74
 TProofMgrLite.cxx:75
 TProofMgrLite.cxx:76
 TProofMgrLite.cxx:77
 TProofMgrLite.cxx:78
 TProofMgrLite.cxx:79
 TProofMgrLite.cxx:80
 TProofMgrLite.cxx:81
 TProofMgrLite.cxx:82
 TProofMgrLite.cxx:83
 TProofMgrLite.cxx:84
 TProofMgrLite.cxx:85
 TProofMgrLite.cxx:86
 TProofMgrLite.cxx:87
 TProofMgrLite.cxx:88
 TProofMgrLite.cxx:89
 TProofMgrLite.cxx:90
 TProofMgrLite.cxx:91
 TProofMgrLite.cxx:92
 TProofMgrLite.cxx:93
 TProofMgrLite.cxx:94
 TProofMgrLite.cxx:95
 TProofMgrLite.cxx:96
 TProofMgrLite.cxx:97
 TProofMgrLite.cxx:98
 TProofMgrLite.cxx:99
 TProofMgrLite.cxx:100
 TProofMgrLite.cxx:101
 TProofMgrLite.cxx:102
 TProofMgrLite.cxx:103
 TProofMgrLite.cxx:104
 TProofMgrLite.cxx:105
 TProofMgrLite.cxx:106
 TProofMgrLite.cxx:107
 TProofMgrLite.cxx:108
 TProofMgrLite.cxx:109
 TProofMgrLite.cxx:110
 TProofMgrLite.cxx:111
 TProofMgrLite.cxx:112
 TProofMgrLite.cxx:113
 TProofMgrLite.cxx:114
 TProofMgrLite.cxx:115
 TProofMgrLite.cxx:116
 TProofMgrLite.cxx:117
 TProofMgrLite.cxx:118
 TProofMgrLite.cxx:119
 TProofMgrLite.cxx:120
 TProofMgrLite.cxx:121
 TProofMgrLite.cxx:122
 TProofMgrLite.cxx:123
 TProofMgrLite.cxx:124
 TProofMgrLite.cxx:125
 TProofMgrLite.cxx:126
 TProofMgrLite.cxx:127
 TProofMgrLite.cxx:128
 TProofMgrLite.cxx:129
 TProofMgrLite.cxx:130
 TProofMgrLite.cxx:131
 TProofMgrLite.cxx:132
 TProofMgrLite.cxx:133
 TProofMgrLite.cxx:134
 TProofMgrLite.cxx:135
 TProofMgrLite.cxx:136
 TProofMgrLite.cxx:137
 TProofMgrLite.cxx:138
 TProofMgrLite.cxx:139
 TProofMgrLite.cxx:140
 TProofMgrLite.cxx:141
 TProofMgrLite.cxx:142
 TProofMgrLite.cxx:143
 TProofMgrLite.cxx:144
 TProofMgrLite.cxx:145
 TProofMgrLite.cxx:146
 TProofMgrLite.cxx:147
 TProofMgrLite.cxx:148
 TProofMgrLite.cxx:149
 TProofMgrLite.cxx:150
 TProofMgrLite.cxx:151
 TProofMgrLite.cxx:152
 TProofMgrLite.cxx:153
 TProofMgrLite.cxx:154
 TProofMgrLite.cxx:155
 TProofMgrLite.cxx:156
 TProofMgrLite.cxx:157
 TProofMgrLite.cxx:158
 TProofMgrLite.cxx:159
 TProofMgrLite.cxx:160
 TProofMgrLite.cxx:161
 TProofMgrLite.cxx:162
 TProofMgrLite.cxx:163
 TProofMgrLite.cxx:164
 TProofMgrLite.cxx:165
 TProofMgrLite.cxx:166
 TProofMgrLite.cxx:167
 TProofMgrLite.cxx:168
 TProofMgrLite.cxx:169
 TProofMgrLite.cxx:170
 TProofMgrLite.cxx:171
 TProofMgrLite.cxx:172
 TProofMgrLite.cxx:173
 TProofMgrLite.cxx:174
 TProofMgrLite.cxx:175
 TProofMgrLite.cxx:176
 TProofMgrLite.cxx:177
 TProofMgrLite.cxx:178
 TProofMgrLite.cxx:179
 TProofMgrLite.cxx:180
 TProofMgrLite.cxx:181
 TProofMgrLite.cxx:182
 TProofMgrLite.cxx:183
 TProofMgrLite.cxx:184
 TProofMgrLite.cxx:185
 TProofMgrLite.cxx:186
 TProofMgrLite.cxx:187
 TProofMgrLite.cxx:188
 TProofMgrLite.cxx:189
 TProofMgrLite.cxx:190
 TProofMgrLite.cxx:191
 TProofMgrLite.cxx:192
 TProofMgrLite.cxx:193
 TProofMgrLite.cxx:194
 TProofMgrLite.cxx:195
 TProofMgrLite.cxx:196
 TProofMgrLite.cxx:197
 TProofMgrLite.cxx:198
 TProofMgrLite.cxx:199
 TProofMgrLite.cxx:200
 TProofMgrLite.cxx:201
 TProofMgrLite.cxx:202
 TProofMgrLite.cxx:203
 TProofMgrLite.cxx:204
 TProofMgrLite.cxx:205
 TProofMgrLite.cxx:206
 TProofMgrLite.cxx:207
 TProofMgrLite.cxx:208
 TProofMgrLite.cxx:209
 TProofMgrLite.cxx:210
 TProofMgrLite.cxx:211
 TProofMgrLite.cxx:212
 TProofMgrLite.cxx:213
 TProofMgrLite.cxx:214
 TProofMgrLite.cxx:215
 TProofMgrLite.cxx:216
 TProofMgrLite.cxx:217
 TProofMgrLite.cxx:218
 TProofMgrLite.cxx:219
 TProofMgrLite.cxx:220
 TProofMgrLite.cxx:221
 TProofMgrLite.cxx:222
 TProofMgrLite.cxx:223
 TProofMgrLite.cxx:224
 TProofMgrLite.cxx:225
 TProofMgrLite.cxx:226
 TProofMgrLite.cxx:227
 TProofMgrLite.cxx:228
 TProofMgrLite.cxx:229
 TProofMgrLite.cxx:230
 TProofMgrLite.cxx:231
 TProofMgrLite.cxx:232
 TProofMgrLite.cxx:233
 TProofMgrLite.cxx:234
 TProofMgrLite.cxx:235
 TProofMgrLite.cxx:236
 TProofMgrLite.cxx:237
 TProofMgrLite.cxx:238
 TProofMgrLite.cxx:239
 TProofMgrLite.cxx:240
 TProofMgrLite.cxx:241
 TProofMgrLite.cxx:242
 TProofMgrLite.cxx:243
 TProofMgrLite.cxx:244
 TProofMgrLite.cxx:245
 TProofMgrLite.cxx:246
 TProofMgrLite.cxx:247
 TProofMgrLite.cxx:248
 TProofMgrLite.cxx:249
 TProofMgrLite.cxx:250
 TProofMgrLite.cxx:251
 TProofMgrLite.cxx:252
 TProofMgrLite.cxx:253
 TProofMgrLite.cxx:254
 TProofMgrLite.cxx:255
 TProofMgrLite.cxx:256
 TProofMgrLite.cxx:257
 TProofMgrLite.cxx:258
 TProofMgrLite.cxx:259
 TProofMgrLite.cxx:260
 TProofMgrLite.cxx:261
 TProofMgrLite.cxx:262
 TProofMgrLite.cxx:263
 TProofMgrLite.cxx:264
 TProofMgrLite.cxx:265
 TProofMgrLite.cxx:266
 TProofMgrLite.cxx:267
 TProofMgrLite.cxx:268
 TProofMgrLite.cxx:269
 TProofMgrLite.cxx:270
 TProofMgrLite.cxx:271
 TProofMgrLite.cxx:272
 TProofMgrLite.cxx:273
 TProofMgrLite.cxx:274
 TProofMgrLite.cxx:275
 TProofMgrLite.cxx:276
 TProofMgrLite.cxx:277
 TProofMgrLite.cxx:278
 TProofMgrLite.cxx:279
 TProofMgrLite.cxx:280
 TProofMgrLite.cxx:281
 TProofMgrLite.cxx:282
 TProofMgrLite.cxx:283
 TProofMgrLite.cxx:284
 TProofMgrLite.cxx:285
 TProofMgrLite.cxx:286
 TProofMgrLite.cxx:287
 TProofMgrLite.cxx:288
 TProofMgrLite.cxx:289
 TProofMgrLite.cxx:290
 TProofMgrLite.cxx:291
 TProofMgrLite.cxx:292
 TProofMgrLite.cxx:293
 TProofMgrLite.cxx:294
 TProofMgrLite.cxx:295
 TProofMgrLite.cxx:296
 TProofMgrLite.cxx:297
 TProofMgrLite.cxx:298
 TProofMgrLite.cxx:299
 TProofMgrLite.cxx:300
 TProofMgrLite.cxx:301
 TProofMgrLite.cxx:302
 TProofMgrLite.cxx:303
 TProofMgrLite.cxx:304
 TProofMgrLite.cxx:305
 TProofMgrLite.cxx:306
 TProofMgrLite.cxx:307
 TProofMgrLite.cxx:308
 TProofMgrLite.cxx:309
 TProofMgrLite.cxx:310
 TProofMgrLite.cxx:311
 TProofMgrLite.cxx:312
 TProofMgrLite.cxx:313
 TProofMgrLite.cxx:314
 TProofMgrLite.cxx:315
 TProofMgrLite.cxx:316
 TProofMgrLite.cxx:317
 TProofMgrLite.cxx:318
 TProofMgrLite.cxx:319
 TProofMgrLite.cxx:320
 TProofMgrLite.cxx:321
 TProofMgrLite.cxx:322
 TProofMgrLite.cxx:323
 TProofMgrLite.cxx:324
 TProofMgrLite.cxx:325
 TProofMgrLite.cxx:326
 TProofMgrLite.cxx:327
 TProofMgrLite.cxx:328
 TProofMgrLite.cxx:329
 TProofMgrLite.cxx:330
 TProofMgrLite.cxx:331
 TProofMgrLite.cxx:332
 TProofMgrLite.cxx:333
 TProofMgrLite.cxx:334
 TProofMgrLite.cxx:335
 TProofMgrLite.cxx:336
 TProofMgrLite.cxx:337
 TProofMgrLite.cxx:338
 TProofMgrLite.cxx:339
 TProofMgrLite.cxx:340
 TProofMgrLite.cxx:341
 TProofMgrLite.cxx:342
 TProofMgrLite.cxx:343
 TProofMgrLite.cxx:344
 TProofMgrLite.cxx:345
 TProofMgrLite.cxx:346
 TProofMgrLite.cxx:347
 TProofMgrLite.cxx:348
 TProofMgrLite.cxx:349
 TProofMgrLite.cxx:350
 TProofMgrLite.cxx:351
 TProofMgrLite.cxx:352
 TProofMgrLite.cxx:353
 TProofMgrLite.cxx:354
 TProofMgrLite.cxx:355
 TProofMgrLite.cxx:356
 TProofMgrLite.cxx:357
 TProofMgrLite.cxx:358
 TProofMgrLite.cxx:359
 TProofMgrLite.cxx:360
 TProofMgrLite.cxx:361
 TProofMgrLite.cxx:362
 TProofMgrLite.cxx:363
 TProofMgrLite.cxx:364
 TProofMgrLite.cxx:365
 TProofMgrLite.cxx:366
 TProofMgrLite.cxx:367
 TProofMgrLite.cxx:368
 TProofMgrLite.cxx:369
 TProofMgrLite.cxx:370
 TProofMgrLite.cxx:371
 TProofMgrLite.cxx:372
 TProofMgrLite.cxx:373
 TProofMgrLite.cxx:374
 TProofMgrLite.cxx:375
 TProofMgrLite.cxx:376
 TProofMgrLite.cxx:377
 TProofMgrLite.cxx:378
 TProofMgrLite.cxx:379
 TProofMgrLite.cxx:380
 TProofMgrLite.cxx:381
 TProofMgrLite.cxx:382
 TProofMgrLite.cxx:383
 TProofMgrLite.cxx:384
 TProofMgrLite.cxx:385
 TProofMgrLite.cxx:386
 TProofMgrLite.cxx:387
 TProofMgrLite.cxx:388
 TProofMgrLite.cxx:389
 TProofMgrLite.cxx:390
 TProofMgrLite.cxx:391
 TProofMgrLite.cxx:392
 TProofMgrLite.cxx:393
 TProofMgrLite.cxx:394
 TProofMgrLite.cxx:395
 TProofMgrLite.cxx:396
 TProofMgrLite.cxx:397
 TProofMgrLite.cxx:398
 TProofMgrLite.cxx:399
 TProofMgrLite.cxx:400
 TProofMgrLite.cxx:401
 TProofMgrLite.cxx:402
 TProofMgrLite.cxx:403
 TProofMgrLite.cxx:404
 TProofMgrLite.cxx:405
 TProofMgrLite.cxx:406
 TProofMgrLite.cxx:407
 TProofMgrLite.cxx:408