JobCPathModule.cxx

Go to the documentation of this file.

// $Id: JobCPathModule.cxx,v 1.28 2006/04/07 18:29:53 boehm Exp $
//
// messier@huhepl.harvard.edu
#include "JobControl/JobCPathModule.h"
#include <cstring> // strcmp
#include "MessageService/MsgService.h"
#include "JobControl/JobCPath.h"
#include "JobControl/JobCommand.h"
#include "JobControl/JobCPathRegistry.h"
#include "JobControl/JobCModuleRegistry.h" // JOBMODULE macro

#include <cassert>

CVSID("$Id: JobCPathModule.cxx,v 1.28 2006/04/07 18:29:53 boehm Exp $");
JOBMODULE(JobCPathModule,
          "Path",
          "Job control module for creating and managing job paths");

ClassImp(JobCPathModule)

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

static void sorry(const char* method)
{
  MSG("JobC",Msg::kWarning) << 
    "Sorry, method " << method << " not implemented\n";
}

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

JobCPathModule::JobCPathModule() : 
  fMom(0), 
  fInput(0),
  fPathRegistry(0), 
  fDummyPath(0) 
{ }

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

JobCPathModule::JobCPathModule(MomNavigator* mom, 
                               JobCInputModule* input) : 
  fMom(mom),
  fInput(input),
  fPathRegistry(0), 
  fDummyPath(0) 
{ }

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

void JobCPathModule::SetPathRegistry(JobCPathRegistry* pr) 
{
  assert(pr);
  fPathRegistry = pr; 
}

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

JobCPathModule::~JobCPathModule() 
{
//======================================================================
//Purpose: Delete the Path modules -- delete the paths owned by the
//         module
//======================================================================
  if (fDummyPath) { delete fDummyPath; fDummyPath = 0; }
}

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

void JobCPathModule::Add(const char* pathName, const char* nodes, int n)
{
//======================================================================
// Purpose: Add a module::method pair to a path. The expected order of
// options is: <path_name> <module>::<method> <module>::<method> ...
//
// Inputs: cmd - the job command
//======================================================================
  JobCPath* p = fPathRegistry->LookUpPath(pathName);
  if (p) {
    int inode = 0;
    vector<string> nodelist;
    JobCommand::StringTok(nodelist, nodes, " ");
    vector<string>::iterator itr(nodelist.begin());
    vector<string>::iterator itrEnd(nodelist.end());
    for (; itr!=itrEnd; ++itr) {
      std::string module;
      std::string method;
      JobCommand::SplitLine((*itr).c_str(), ':', module, method);
      if (n>=0) {
        p->AddAt(module.c_str(),method.c_str(),n+inode);        
      }
      else {
        p->PushBack(module.c_str(), method.c_str());
      }
      ++inode;
    }
    MSG("JobC", Msg::kDebug) << "\n" << (*p) << endl;
  }
  else {
    MSG("JobC",Msg::kWarning) << "Can not find path '" << pathName << "'\n";
    return;
  }
}

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

JobCPath& JobCPathModule::Create(const char* pathName, 
                                 const char* nodeList)
{
//======================================================================
// Purpose: Given a command line create a job path
//
// Inputs: cmd - The job command
//======================================================================
  JobCPath *path;

  // Create the path and add it to the list ** Remember this module
  // owns the paths and has the responsibility to delete them! **
  path = fPathRegistry->MakePath(pathName,fMom,fInput);
  if (path == 0) {
    MSG("JobC",Msg::kWarning) << 
      "Failed to make path '" << pathName << "'. May already exist!\n";
    static JobCPath dummy;
    return dummy;
  }
    
  // Loop over remaining options and add nodes to the path
  vector<string> nodes;
  JobCommand::StringTok(nodes, nodeList, " ");
  vector<string>::iterator itr(nodes.begin());
  vector<string>::iterator itrEnd(nodes.end());
  for (; itr!=itrEnd; ++itr) {
    int len = strlen((*itr).c_str())+1;
    if (len>4) { // Need at least 4 char's to create a node name: 'a:b\0'
      // Valid node name
      std::string module;
      std::string method;
      JobCommand::SplitLine((*itr).c_str(), ':', module, method);
      path->PushBack(module.c_str(), method.c_str());
    }
    else {
      // Invalid node name
      MSG("JobC",Msg::kWarning) << 
        "'" << (*itr) << "' is not a valid module::method pair.\n";
      MSG("JobC",Msg::kWarning) << 
        "Attempt to create unnamed module::method pair ignored.\n";
    }
  }
#ifdef SITE_HAS_SIGC
  this->SigNewPath(path);
#endif
  MSG("JobC", Msg::kDebug) << "\n" << (*path) << endl; 
  return *path;
}

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

void JobCPathModule::Delete(const char* path)
{ 
//======================================================================
// Delete a path from the registry
//======================================================================
  fPathRegistry->DeletePath(path);
}

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

void JobCPathModule::HandleCommand(JobCommand *cmd) 
{
//======================================================================
// Purpose: Switchyard for commands
// 
// Input: cmd - the job command
//======================================================================
  string c = cmd->PopCmd();
  if (c=="Create") {
    string path  = cmd->PopOpt();
    string nodes;
    while (cmd->HaveOpt()) {
      nodes += cmd->PopOpt();
      nodes += " ";
    }
    this->Create(path.c_str(), nodes.c_str());
    return;
  }
  if (c=="Delete") {
    const char* path = cmd->PopOpt();
    this->Delete(path);
    return;
  }
  if (c=="Add") {
    const char* path = cmd->PopOpt();
    string nodes;
    while (cmd->HaveOpt()) {
      nodes += cmd->PopOpt();
      nodes += " ";
    }
    this->Add(path, nodes.c_str());
    return;
  }
  if (c=="Remove") {
    this->Remove();
    return;
  }
  if (c=="Attach") {
    const char* upStreamPath = cmd->PopOpt();
    const char* dnStreamPath = cmd->PopOpt();
    this->Attach(upStreamPath, dnStreamPath);
    return;
  }
  if (c=="Detach") {
    const char* path1 = cmd->PopOpt();
    const char* path2 = cmd->PopOpt();
    this->Detach(path1, path2);
    return;
  }
  // Fall through to here if nothing has handled the command
  MSG("JobC",Msg::kWarning) << 
    "Module " << this->GetName() << 
    " does not implement command " << c << "." << endl;
}

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

void JobCPathModule::Help() 
{
//======================================================================
// Purpose: Print help for this job module
//======================================================================
  static const char* help =
    "Help for 'Path' module:\n"
    "\n"
    " Path is a module for creating and holding the job paths and\n"
    " job modules used by your job. Possible commands are:\n"
    "\n"
    " /Path/Add <path> <module>::<method>\n"
    " /Path/Add <path> <module>::<method> <position>\n"
    "\n"
    "  Add module's '<module>' '<method>' to the path 'path' at\n"
    "  the <position> (1,2,3...). <position> is optional.\n"
    "\n"
    " /Path/Create <path>\n"
    " /Path/Create <path> <mod1>::<meth1> <mod2>::<meth2> ...\n"
    "\n"
    "  Create a path named 'path' and add nodes specified by the module \n"
    "  and method pairs <mod>::<meth> to it.\n"
    "\n"
    " /Path/Delete <path>\n"
    "\n"
    "  Delete the path named '<path>'\n"
    "\n"
    " /Path/Remove <module>\n"
    " /Path/Remove <module>::<method>\n"
    "\n"
    "  Remove the node <module>::<method> from a path\n"
    "  If <method> is not specified all nodes using <module> are removed.\n"
    "\n"
    " /Path/Attach <path1> <path2>\n"
    " /Path/Detach <path1> <path2>\n"
    "\n"
    "  Attach/Detach <path2> to/from <path1>\n";
  MSG("JobC", Msg::kInfo) << help << endl;
}

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

void JobCPathModule::Remove() 
{ 
  sorry("JobCPathModule::Remove");
}

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

void JobCPathModule::Attach(const char* n1, const char* n2)
{
//======================================================================
// Purpose: Handle the "Attach" command which links one path to another
//======================================================================
  if (n1==0 || n2==0) {
    MSG("JobC",Msg::kError) << 
      "Attach requires two path names as arguments.\n" <<
      "Example: '" << 
      this->GetName() << "/Attach path1 path2' will attach path2 to path1\n";
    return;
  }
  JobCPath *p1 = fPathRegistry->LookUpPath(n1);
  if (p1==0) {
    MSG("JobC",Msg::kError) << "Path '" << n1 << "' not found.\n";
    return;
  }
  JobCPath *p2 = fPathRegistry->LookUpPath(n2);
  if (p2==0) {
    MSG("JobC",Msg::kError) << "Path '" << n2 << "' not found.\n";
    return;
  }
  // Stick p2 onto p1
  p1->Attach(p2);
}

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

void JobCPathModule::Detach(const char* pathA, const char* pathB)
{ 
  MSG("JobC",Msg::kWarning) << 
    "Detach(" << pathA << "," << pathB <<") \n";
  sorry("JobCPathModule::Detach");
}

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

void JobCPathModule::Report() 
{
//======================================================================
// Print report for all active paths
//======================================================================
  JobCPathRegistry::PathIterator itr(fPathRegistry->GetPathBegin());
  JobCPathRegistry::PathIterator itrEnd(fPathRegistry->GetPathEnd());
  bool ifirst = true;
  if (itr==itrEnd) {
    MSG("JobCReport",Msg::kInfo) << 
      "...................................." <<
      "....................................\n" <<
      "<no active paths>\n" <<
      "...................................." <<
      "....................................\n";
    return;
  }
  for (; itr!=itrEnd; ++itr) {
    if (ifirst) {
      MSG("JobCReport",Msg::kInfo) << 
        "...................................." <<
        "....................................\n";
      ifirst = false;
    }
    MSG("JobCReport",Msg::kInfo) << 
      (*(*itr)) << // Whoa, pointer to pointer...
      "...................................." <<
      "....................................\n";
  }
}

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

void JobCPathModule::Reset() { fPathRegistry->Reset(); }

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

JobCPath& JobCPathModule::operator()(const char* path)
{
//======================================================================
// Return a path by name
//=======================================================================
  JobCPath* p = fPathRegistry->LookUpPath(path);
  if (p!=0) return (*p);
  
  MSG("JobC",Msg::kWarning) << "Failed to find path '" << path << "'.\n";
  if (fDummyPath == 0) fDummyPath = new JobCPath;
  return (*fDummyPath);
}

---