JobCEnv.cxx

Go to the documentation of this file.

// $Id: JobCEnv.cxx,v 1.42 2007/08/17 01:31:02 rhatcher Exp $
//
// A collection of data from the job environment - global options and
// resources.
//
// messier@huhepl.harvard.edu
#include "JobControl/JobCEnv.h"
extern "C" {
#ifdef MACOSX
  #include <unistd.h>
#else
  #include <getopt.h>
#endif
#ifndef GETOPTDONE // Some getopt.h's have this, some don't...
#define GETOPTDONE (-1)
#endif
#include <sys/types.h> // opendir, closedir
#include <dirent.h>    // opendir, closedir
}
#include <cstdlib>
#include <cassert>
#include <cstring>
#include <csignal>
#include "TEnv.h"
#include "TROOT.h"
#include "TSystem.h"
#include "JobControl/JobCRootEnv.h"
#include "JobControl/JobCleaner.h"
#include "JobControl/JobCFloatXImp.h"
#include "JobControl/IsArgMacroFile.h"
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"

CVSID("$Id: JobCEnv.cxx,v 1.42 2007/08/17 01:31:02 rhatcher Exp $");

JobCEnv* JobCEnv::fInstance = 0;
bool     gsSIGHUP = false; // Have we recieved a SIGHUP signal?
bool     gsSIGUSR1 = false; // Have we recieved a SIGUSR1 signal?

//......................................................................

static void gsSIGHUPhandler(int /* s */) { gsSIGHUP = true; }
static void gsSIGUSR1handler(int /* s */) { gsSIGUSR1 = true; }

int JobCEnvSetenv(const char *name, const char *value) {
  // A transportable "setenv" that works on both Linux and IRIX
  //    int setenv(const char *name, const char *value, int overwrite);  
  // found in Linux's <stdlib.h> is NOT POSIX standard
  // This is just like TUnixSystem::Setenv, but avoids
  // entanglement with ROOT at this stage

  char *s = new char [strlen(name)+strlen(value)+2];  // space for = & \0
  sprintf(s,"%s=%s",name,value);
  int success = ::putenv(s); // putenv is more standard than setenv
  // passed string becomes part of the environment, so altering
  // the string changes the environment -- DON'T delete 's'
  return success;
}

//......................................................................

JobCEnv::JobCEnv() :
  fArgc(0),
  fArgv(0), 
  fModuleHelpList(0),
  fDfltOutFile(""),
  fTimeStart(time(0)),
  fTimeLimit(-1.0),
  fRecordLimit(-1),
  fIsBatch(false), 
  fRootEnv(0)
{
//========================================================================
// Purpose: Create the default job environment 
//========================================================================
}

//......................................................................

JobCEnv::JobCEnv(int argc, char** argv) :
  fArgc(argc), 
  fArgv(argv), 
  fModuleHelpList(0),
  fDfltOutFile(""),
  fTimeStart(time(0)),
  fTimeLimit(-1.0),
  fRecordLimit(-1),
  fIsBatch(false),
  fRootEnv(0)
{ 
//========================================================================
// Purpose: Create the job environment given command line options
//========================================================================
  this->ProcessCommandLine(argc,argv);

  // Only set up the root environment after command line has been parsed
  // Don't forget delete in d'tor
  fRootEnv = new JobCRootEnv(argc,argv);
  assert(fRootEnv);

  // Set the system signal handlers
  this->SetSignalHandlers();
}

//......................................................................

JobCEnv::~JobCEnv() 
{ 
//======================================================================
// Purpose: Clean up after JobCEnv...
//======================================================================
  if (fRootEnv) {
    delete fRootEnv; fRootEnv = 0;
  }
}

//......................................................................

const char* JobCEnv::GetModuleHelpList() const 
{
  return fModuleHelpList;
}

//......................................................................

int JobCEnv::GetArgc() const { return fArgc; }

//......................................................................

char* const* JobCEnv::GetArgv() const { return fArgv; }

//......................................................................

const char* JobCEnv::GetArgv(int i) const 
{ 
//======================================================================
// Purpose: Return the ith command line argument
//======================================================================
  assert(i>=0 && i<fArgc);
  return fArgv[i]; 
}

//......................................................................

const char* JobCEnv::GetMacroFile(unsigned int i) const
{
//======================================================================
// Purpose: Return the ith macro file specified on the command line
//======================================================================
  //always true: assert(i>=0);
  if (i<this->fMacroFileList.size()) return fMacroFileList[i].c_str();
  else                               return 0;
}

//......................................................................

const char* JobCEnv::GetFileName(int i) const 
{
//======================================================================
// Purpose: Return the ith data file name listed on the command line
//======================================================================
  // Compute index into argv array
  assert(i>=0 && i<this->GetNfile());
  return fDataFileList[i].c_str();
}

//......................................................................

int JobCEnv::GetNfile() const 
{
//======================================================================
// Purpose: Return the number of data file names specified on the 
//          command line
//======================================================================
  return fDataFileList.size();
}

//......................................................................

const char* JobCEnv::GetDefaultOutputFileName() const 
{
//======================================================================
// Return the name of the default output file. Value set from command
// line.
//======================================================================
  return fDfltOutFile.c_str();
}

//......................................................................

bool JobCEnv::HaveInaccessibleFile() const
{
    if (!fRootEnv) return false;
    return fRootEnv->HaveInaccessibleFile();
}

//......................................................................

void JobCEnv::SetTimeLimit(const char* s) 
{
//======================================================================
// Set the time limit for the job. Expected format is <float> <unit>
// for example:
//   '10.5 minutes'
//   '2.5 hours'
//   '90 seconds'
//======================================================================
  int i;                  // Loop variable
  float t;                // Numerical value of time limit
  char unit[256];         // Units that the time is given in
  double fac;             // Factor to apply to t to convert to seconds
  // My best guess all all the possible units people could use...
  const char* second[] = {"s","second","seconds","sec", "secs", 0};
  const char* minute[] = {"m","minute","minutes","min", "mins", 0};
  const char* hour[]   = {"h","hour","hours","hr","hrs",        0};
  const char* day[]    = {"d","day","days",                     0};
  const char* week[]   = {"w","week","weeks","wk","wks",        0};
  const char* year[]   = {"y","year","years","yr","yrs",        0};

  // Read the value and unit of the time limit string
  sscanf(s,"%f %s",&t,unit);

  // Sort which units the time limit is given in
  fac = 0.0;
  for (i=0; second[i]!=0; ++i) {
    if (strcasecmp(unit,second[i])==0) fac = 1.0;
  }
  for (i=0; minute[i]!=0; ++i) {
    if (strcasecmp(unit,minute[i])==0) fac = 60.0;
  }
  for (i=0; hour[i]!=0; ++i) {
    if (strcasecmp(unit,hour[i])==0)   fac = 60.0*60.0;
  }
  for (i=0; day[i]!=0; ++i) {
    if (strcasecmp(unit,day[i])==0)    fac = 60.0*60.0*24.0;
  }
  for (i=0; week[i]!=0; ++i) {
    if (strcasecmp(unit,week[i])==0)   fac = 60.0*60.0*24.0*7.0;
  }
  for (i=0; year[i]!=0; ++i) {
    if (strcasecmp(unit,year[i])==0)   fac=60.0*60.0*24.0*365.25;
  }
  if (fac==0.0 && strlen(unit)>0) {
    MSG("JobC",Msg::kWarning) <<
      "Time unit '"<<unit<<"' is not recognized.\n" <<
      "Try 's', 'm', 'h', 'd', 'w', or 'y'\n" <<
      "Assuming unit given is seconds.\n";
    fac = 1.0;
  }
  
  // Set the time limit
  fTimeLimit = t*fac;
}

//......................................................................

void JobCEnv::SetSignalHandlers()
{
//======================================================================
// Set signal handlers.
//======================================================================
  signal(SIGHUP,gsSIGHUPhandler);    // End job "gracefully"
  signal(SIGUSR1,gsSIGUSR1handler);    // Emit status msg on signal

  bool activateFPE = true;

  if(gEnv) {
    if(strcasecmp(gEnv->GetValue("Loon.fpe","on"),"off")==0) activateFPE=false;
  } 
  static JobCFloatXImp floatX(activateFPE); // Trap floating point exceptions

}

//......................................................................

bool JobCEnv::CheckRecordLimit(int n) const
{
//======================================================================
// Check if the number of records n is within the set limit. Return
// true if the limit has been exceeded. False if it has not.
//======================================================================
  if (fRecordLimit<0)  return false; // No limit set
  if (n>=fRecordLimit) return true;
  return false;
}

bool JobCEnv::CheckTimeLimit(int* tsec) const
{
//======================================================================
// Check if the time limit for the job has been exceeded. Return true
// if the limit for the job has been exceeded. False if it has not.
//======================================================================
  if (fTimeLimit<0.0) return false; // No limit set

  time_t t = time(0);
  *tsec = t; // Return time used in seconds
  if (difftime(t,fTimeStart) >= fTimeLimit) return true;
  
  return false;
}

//......................................................................

bool JobCEnv::ContinueRun(int n) const
{
//======================================================================
// Check if there is any information from the environment that signals
// whether a run should stop. 
//
// Inputs: n = number of records processed
// Returns: true=keep running, false=stop run
//======================================================================
  int t;
  if (this->CheckRecordLimit(n) == true) {
    MSG("JobC",Msg::kWarning) << 
      "Record limit exceeded at "<<n<<" records." << endl;
    return false;
  }
  if (this->CheckTimeLimit(&t) == true) {
    MSG("JobC",Msg::kWarning) << 
      "Time limit exceeded at "<<t<<" seconds." << endl;
    return false;
  }
  if (gsSIGHUP) {
    MSG("JobC",Msg::kWarning) << 
      "Process received SIGHUP.\n" << endl;
    return false;
  }
  if (gsSIGUSR1) {
    int run, snarl;
    MsgService::Instance()->GetCurrentRunSnarl(run,snarl);
    cout << flush;  // just so things don't get intermixed
    cerr << "JobCEnv: Process " << gSystem->GetPid() 
         << " received SIGUSR1 after "
         << n << " record sets," 
         << endl
         <<"  last processed run " << run << " snarl " << snarl 
         << flush << endl;
    ProcInfo_t pi;
    gSystem->GetProcInfo(&pi);
    cerr << "  CPU: user " << pi.fCpuUser << "s, sys " 
         << pi.fCpuSys << "s, "
         << " Mem: res " << pi.fMemResident 
         << "k, virtual " << pi.fMemVirtual << "k "
         << flush << endl;

    gsSIGUSR1 = false;  // we've emitted the msg, clear signal
  }
  return true; // Keep going...
}

//......................................................................

bool JobCEnv::IsBatch() const { return fIsBatch; }

//......................................................................

JobCEnv& JobCEnv::Instance() 
{
  if (fInstance) return *fInstance;
  return JobCEnv::Instance(0,0);
}

//......................................................................

JobCEnv& JobCEnv::Instance(int argc, char** argv)
{
  if (fInstance) return *fInstance;

  // Helper class to handle delete
  static JobCEnv::Cleaner c;
  c.ClassIsUsed();

  fInstance = new JobCEnv(argc, argv);
  return *fInstance;
}

//......................................................................

int JobCEnv::RunRootApp() 
{
//======================================================================
// Purpose: Transfer control to the ROOT application
//======================================================================
  if (fRootEnv) {
    int r = fRootEnv->RunTheApp();
    // Ensure that JobC objects get deleted. Root is sloopy about this...
    JobCleaner::Instance().Reap();
    return r;
  }
  return 0;
}

//......................................................................

void JobCEnv::ProcessCommandLine(int argc, char *const *argv)
{
//======================================================================
// Purpose: Parse command line options
// Inputs: Standard "argc" and "argv" from main()
//======================================================================
  int c;
  
#ifndef MACOSX
  optind = 0; // getopt.h: Reset getopt to start of arguments
#else
  optind = 1; // skip 0th argument ("loon") for MACOSX
#endif

#ifdef IRIX6
  getoptreset(); // needed by IRIX to reset getopt
#endif
  while ((c = getopt(argc, argv, "bs:nqlt:r:x:hH:d:u:p:o:v:")) != GETOPTDONE) {
    MSG("JobC",Msg::kDebug) << "Processing job command-line option argument: " << c << endl;
    switch (c) {
    case 'b': break; // ROOT batch option
    case 's': break; // ROOT's hidden -splash option...
    case 'q': break; // ROOT quit option
    case 'n': break; // ROOT logon/logoff macro option
    case 'l': break; // ROOT no splash option
    case 't': this->SetTimeLimit(optarg);  break; // Set time limit
    case 'r': fRecordLimit = atoi(optarg); break; // Set record limit
    case 'x': // x is to "execute" a JobControl macro
      this->AddMacroFile(optarg); // optarg from getopt.h
      break;
    case 'h':
      MSG("JobC",Msg::kInfo) 
        << " usage: " << argv[0] 
        << " -bnq -H<modules> -x<file>"
        << " -d<url> -u<user> -p<passwd> -t'<time>' -r[n]"
        << " -o<filename> <filenames...>\n"
        << "  -b: Run in batch mode without graphics.\n"
        << "  -n: Do not execute logon and logoff macros.\n"
        << "  -q: Exit after processing command line macro files.\n"
        << "  -h: Print this friendly help message.\n"
        << "  -H: Print help for modules in list.\n"
        << "  -x: Specifies a Job Control Macro to load.\n"
        << "      Multiple instances of '-x' are allowed.\n"
        << "  -d: Supply database URL (replaces ENV_TSQL_URL)\n"
        << "  -u: Supply database user (replaces ENV_TSQL_USER)\n"
        << "  -p: Supply database password (replaces ENV_TSQL_PSWD)\n" 
        << "  -t: Specify job time limit. Eg. -t'10 minutes'\n"
        << "  -r: Specify limit on number of records to process.\n"
        << "  -o: Set the name of the default output file.\n"
        << "  -v: Set JobC message verbosity [V,D,I,W,E,F].\n";
      exit(1);
    case 'H': fModuleHelpList = optarg; break;
    case 'd': if (optarg) JobCEnvSetenv("ENV_TSQL_URL", optarg); break;
    case 'u': if (optarg) JobCEnvSetenv("ENV_TSQL_USER",optarg); break;
    case 'p': if (optarg) JobCEnvSetenv("ENV_TSQL_PSWD",optarg); break;
    case 'o': fDfltOutFile = optarg; break;
    case 'v': // set the MsgService level for JobControl
      {
        Msg::LogLevel_t lvl = Msg::kInfo;
        switch (optarg[0]) {
        case 'V': case 'v': lvl = Msg::kVerbose; break;
        case 'D': case 'd': lvl = Msg::kDebug;   break;
        case 'I': case 'i': lvl = Msg::kInfo;    break;
        case 'W': case 'w': lvl = Msg::kWarning; break;
        case 'E': case 'e': lvl = Msg::kError;   break;
        case 'F': case 'f': lvl = Msg::kFatal;   break;
        default:
          MSG("JobC",Msg::kWarning)
            << "Can not interpret -v level '" << optarg << "'." << endl;
        }
        MsgStream *s = MsgService::Instance()->GetStream("JobC");
        if (s) s->SetLogLevel(lvl);
        else
          MSG("JobC",Msg::kWarning)
            << "Can not find JobC message stream." << endl;
        break;
      }
    default: // Do nothing just pass them along...
      MSG("JobC",Msg::kInfo)
        << " getopt returned unexpected character code " << c << "." << endl;
      break;
    }
  }

  // Check if the remaining stuff on the command line is:
  //   a data file      (.root)
  //   a macro script   (.C,.c,.cc,.cxx)
  //   a directory name
  // If not warn the user in case it's just a simple typo.
  for (int i=optind; i<argc; ++i) {
    int len = strlen(argv[i]);
    if (strcmp(argv[i]+len-5,".root")==0) {
      this->AddDataFile(argv[i]);
      MSG("JobC",Msg::kDebug)
        << "JobCEnv::ProcessCommandLine() added data file: "
        << argv[i] << endl;
    }
    else if ( IsArgMacroFile(argv[i]) != "" ) {
      MSG("JobC",Msg::kDebug)
        << "JobCEnv::ProcessCommandLine() saw macro script: "
        << argv[i] << endl;
    }
    else {
      DIR* d = opendir(argv[i]);
      if (d) {
        // if ROOT is given a directory it will cd to it before executing
        closedir(d);
        MSG("JobC",Msg::kDebug)
          << "JobCEnv::ProcessCommandLine() saw directory: "
          << argv[i] << endl;
      }
      else {
        MSG("JobC",Msg::kInfo)
          << "JobCEnv::ProcessCommandLine() unrecognizable arg: "
          << argv[i] << endl;
      }
    }
  } // loop over optind

}

//......................................................................

void JobCEnv::AddDataFile(const char *filename)
{
//======================================================================
// Purpose: Add a data file to the list of files on the command line
//======================================================================
  assert(filename);
  string s(filename);
  fDataFileList.push_back(s);
}

//......................................................................

void JobCEnv::AddMacroFile(const char *filelist) 
{
//======================================================================
// Inputs: filelist - list of files in format 'file1 file2 fil3'...
//======================================================================
  const char *p;
  for (p=filelist; *p!='\0';) {
    for (; *p==' ' && *p!='\0'; ++p);
    if (*p!='\0') {
      string s;
      s = "";
      for (; *p!=' ' && *p!='\0'; ++p) s += *p;
      if (s.length()>0) fMacroFileList.push_back(s);
    }
  }
}

---