JobController.cxx

Go to the documentation of this file.

// $Id: JobController.cxx,v 1.29 2003/08/26 23:04:23 messier Exp $
//
// Initialize and run a reconstruction job
//
// messier@huhepl.harvard.edu
#include "JobControl/JobController.h"
#include <fstream>
#include "MessageService/MsgService.h"
#include "JobControl/JobCommand.h"
#include "JobControl/JobCInterpreter.h"
#include "JobControl/JobCEnv.h"
#include "JobControl/JobCPath.h"
#include "JobControl/JobCPathHandler.h"
#include "JobControl/JobCPathRegistry.h"
#include "JobControl/JobCNode.h"
#include "JobControl/JobCModule.h"
#include "JobControl/JobCModuleProxy.h"
#include "JobControl/JobCModuleRegistry.h"
#include "JobControl/JobCPathModule.h"

#include <cassert>

CVSID("$Id: JobController.cxx,v 1.29 2003/08/26 23:04:23 messier Exp $");

// The first job controller instantiated
JobController* JobController::fMotherController = 0;

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

JobController::JobController() :
  fPathRegistry(new JobCPathRegistry()),
  fInterp(new JobCInterpreter())
{
//======================================================================
// Purpose: Create a default job controller
//======================================================================
  
  // Do a little work to set the initial state
  this->Init();
}

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

JobController::JobController(int argc, char** argv) :
  fPathRegistry(new JobCPathRegistry()),
  fInterp(new JobCInterpreter())
{
//======================================================================
// Purpose: Create the job controller
//
// Inputs: argc      - Number of command line arguments
//         argv      - The array of command line arguments
//======================================================================
  JobCEnv::Instance(argc, argv);

  // Perform some initializations
  this->Init();
}

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

JobController::~JobController() 
{
  MSG("JobC",Msg::kVerbose) << 
    "Shutting down JobController @ " << this << "\n";
  // Delete in order created
  if (fInterp)       {delete fInterp;       fInterp       = 0; }
  if (fPathRegistry) {delete fPathRegistry; fPathRegistry = 0; }

  if (this == fMotherController) fMotherController = 0;
}

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

JobCEnv* JobController::GetJobEnv() const 
{
  JobCEnv& env = JobCEnv::Instance();
  return &env;
}

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

MomNavigator* JobController::GetMom()
{
  return &fMom;
}

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

JobCPathRegistry* JobController::GetPathRegistry() const { 
  return fPathRegistry; 
}

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

JobController* JobController::GetMotherController()
{ 
//======================================================================
// Purpose: Return a pointer to the "mother controller", the first of
// a sequence of controllers instantiated in a job.
//
// Note: Use of this method only makes sense for interactive jobs
// where it makes sense to assume that the user is talking to a single
// job controller (ie. the mother controller). Batch jobs could in
// general have multiple controllers so any code that you expect to
// work in a batch system *should not* rely on this call.
//======================================================================
  if (fMotherController) {
    return fMotherController;
  }
  else {
    // Don't have one -- so make one. This will only get allocated if
    // this block gets executed
    static JobController motherController;
    
    // Assert that the instantiation set the fMotherController variable
    // and return it
    assert(fMotherController);
    return fMotherController;
  }
  return 0; // keeps compilers quiet.
}

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

void JobController::operator()(const char *c) { (*this) << c << "\n"; }

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

JobController& JobController::operator<<(const char* cmd) 
{
//======================================================================
// Purpose: Allow commands to be fed into the JobController
//======================================================================
  // Feed the command to the interpreter
  (*fInterp) << cmd;

  // If we're in interactive mode act on the commands right away
  if (JobCEnv::Instance().IsBatch()==false) this->ProcessCommands();

  return *this;
}

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

bool JobController::ControllerCommand(JobCommand *cmd)
{
//======================================================================
// Purpose: Handle commands intrinsic to the job controller
//======================================================================
  string c1 = cmd->PopCmd();
  if (c1 == "echo" || c1 == "Echo" || c1 == "ECHO") {
    // Command "echo"
    if (cmd->HaveOpt()) {
      string c2 = cmd->PopOpt();
      if (c2 == "on" || c2 == "On" || c2 == "ON") {
        fInterp->EchoOn();
        return true;
      }
      if (c2 == "off" || c2 == "Off" || c2 == "OFF") {
        fInterp->EchoOff();
        return true;
      }
    }
    else {
      // No options -- default is to turn echoing on
      fInterp->EchoOn();
      return true;
    }
  }
  if (c1 == "help" || c1 == "Help" || c1 == "HELP") {
    // Command "help"
    this->Help(cmd);
    return true;
  }
  if (c1 == "Exec" || c1 == "exec" || c1 == "EXEC") {
    if (cmd->HaveOpt()) {
      string macrofile = cmd->PopOpt();
      this->ReadMacroFile(macrofile.c_str());
      return true;
    }
    else {
      MSG("JobC",Msg::kWarning) << "Need JobControl macro file.\n";
      return false;
    }
  }

  // Failed to handle this command -- push the command line back up
  cmd->PushCmd();
  return false;
}

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

void JobController::HandleCommand(JobCommand *cmd)
{
//======================================================================
// Purpose: Allow commands to be fed into the JobController
//
//  Assumes that commands have the following format:
//  /[path]/[module]/... 
//  and then pass the rest on to the job module to handle
//======================================================================
  const char *c1;
  JobCPath   *path  =0;
  JobCModule *module=0;

  // Commands are handled in the following way until a unique
  // destination for the command is found:
  //
  // 1) Check if this job controller knows how to process the command 
  //     yes -> done, no -> 2)
  // 2) Check if the command references an existing path
  //     yes->3, no->5
  // 3) Check if the command references a module in the path
  //     yes->done, no->4)
  // 4) Send the command to the path itself
  // 5) See if the command references a module in any path uniquely
  //    yes->done no->warning

  // 1) See if the command is an "instrinsic" JobController command
  if (this->ControllerCommand(cmd)) return;

  // 2) Check if this matches an existing path
  c1 = cmd->PopCmd();
  path = fPathRegistry->LookUpPath(c1);
  if (path) {
    // Matches an existing path
    const char *c2;
    c2 = cmd->PopCmd();
    // 3) Found the path, see if the next thing is a module in the path
    if (c2) {
      module = path->GetModule(c2);
      if (module == 0) {
        // 4) No module, send the back the command up and send it to the path
        cmd->PushCmd();
        JobCPathHandler ph(path);
        ph.HandleCommand(cmd);
        return;
      }
    }
  }
  else {
    // 5) See if the command references a module uniquely
    module = fPathRegistry->LookUpModule(c1);
    if ( module == 0 ) {
      // Failed to find unique module
      MSG("JobC",Msg::kWarning) 
        << "Failed to find '" << c1 << "'.\n";
      return;
    }
  }

  // To get here we must have uniquely identified a job module to
  // which to send the command
  module->HandleCommand(cmd);
}

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

void JobController::Help(JobCommand *cmd) 
{
  if (cmd->HaveOpt()) {
    while (cmd->HaveOpt()) {
      // Figure out what module the user wants help for
      const char *opt = cmd->PopOpt();
      JobCModuleProxy* mp = JobCModuleRegistry::Instance().LookUp(opt);
      if (mp) {
        mp->Help();
      }
      else {
        MSG("JobC", Msg::kWarning) << "Can not find module " << opt << endl;
      }
    }
  }
  else {
    MSG("JobC",Msg::kInfo) <<
      "===================================="
      "====================================\n" << 
      "                             JOBCONTROL HELP\n" <<
      "\n" <<
      " In general job control commands are of the format:\n" << 
      " /[path]/[module]/[command] [option1] [option2] ...\n" <<
      "\n" <<
      "  where [path]    is a name of a job path\n" <<
      "        [module]  is a name of a job module\n" <<
      "        [command] is the name of a command to send to the module\n" <<
      "        [option]  is a possible option for the command\n" <<
      "\n" << 
      " Commands are in general case sensitive.\n" <<
      "\n" << 
      " For help with a specific job module try:\n" <<
      "  Help [module1] [module2] ...\n" <<
      "\n" <<
      " The following is a list of " <<
      JobCModuleRegistry::Instance() <<
      "===================================="
      "====================================" << endl;
  }
}

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

void JobController::Init(void) 
{
//======================================================================
// Purpose: Set the initial state of the JobController
//======================================================================
  // If the user requested help from the command line handle that
  if (JobCEnv::Instance().GetModuleHelpList()) {
    (*this) << "Help " << JobCEnv::Instance().GetModuleHelpList() << "\n";
    this->Run();
    exit(1);
  }
  
  // If this is the first controller, set it to be the mother controller
  if (fMotherController == 0) fMotherController = this;

  // Build the system path
  this->BuildSystemPath();
  
  // Process any macro files that have been loaded
  const char *macrofile;
  for (unsigned int i=0; 
       (macrofile=JobCEnv::Instance().GetMacroFile(i))!=0; 
       ++i) {
    this->ReadMacroFile(macrofile);
  }
}

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

void JobController::BuildSystemPath() 
{
//======================================================================
// Purpose: Build the "system path" - the list of modules which are
// provided by the framework to configure, querry, etc. the system.
//======================================================================
  // Make the system path
  JobCPath* syspath = fPathRegistry->MakePath(".jobcontroller",&fMom,0);
  assert(syspath);

  // Add the framework modules to the system path
  JobCNode* dn = syspath->PushBack("Display","Void");
  JobCNode* mn = syspath->PushBack("Msg",    "Void");
  JobCNode* pn = syspath->PushBack("Path",   "Void");
  JobCNode* rn = syspath->PushBack("Root",   "Void");
  
  // Configure these nodes
  JobCPathModule* pm = static_cast<JobCPathModule*>(pn->GetModule());
  assert(pm);
  pm->SetPathRegistry(fPathRegistry);
  pm->SetMom(&fMom);

  dn->GetModule()->BeginJob();
  mn->GetModule()->BeginJob();
  pn->GetModule()->BeginJob();
  rn->GetModule()->BeginJob();
}

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

void JobController::ProcessCommands()
{
//======================================================================
// Purpose: Process any commands in the interpreter's stack
//======================================================================
  while (JobCommand* jc = fInterp->PopJobCommand()) {
    this->HandleCommand(jc);
  }
}

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

void JobController::ReadMacroFile(const char *filename) 
{
//======================================================================
// Purpose: Read job control commands from a macro file
//======================================================================
  ifstream ifs(filename);
  
  if (ifs.bad()) {
    MSG("JobC",Msg::kWarning) << 
      "Macro file '" << filename << "' does not exist.\n";
    return;
  }
  else {
    const unsigned int bufs = 2048;
    char c[bufs];
    string s;
    while (ifs.good()) {
      ifs.getline(c,bufs,'\n');
      s = c;
      s += '\n'; // Add the return character back on
      (*this) << s.c_str();
    }
  }
}

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

int JobController::Run() 
{
//======================================================================
// Purpose: Run the job
//======================================================================
  this->ProcessCommands();
  JobCEnv::Instance().RunRootApp();
  return 1;
}

---