src/engine/BL_SALOMEServices.cxx

   1 //  Copyright (C) 2009 CEA/DEN, EDF R&D
   2 //
   3 //  This library is free software; you can redistribute it and/or
   4 //  modify it under the terms of the GNU Lesser General Public
   5 //  License as published by the Free Software Foundation; either
   6 //  version 2.1 of the License.
   7 //
   8 //  This library is distributed in the hope that it will be useful,
   9 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 //  Lesser General Public License for more details.
  12 //
  13 //  You should have received a copy of the GNU Lesser General Public
  14 //  License along with this library; if not, write to the Free Software
  15 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "BL_SALOMEServices.hxx"
  21
  22 BL::SALOMEServices::SALOMEServices()
  23 {
  24   int nbargs = 0; char **args = 0;
  25   _orb = CORBA::ORB_init (nbargs, args);
  26   _salome_naming_service = NULL;
  27   _lcc = NULL;
  28   _state = false;
  29 }
  30
  31 BL::SALOMEServices::~SALOMEServices()
  32 {
  33   if (_salome_naming_service)
  34     delete _salome_naming_service;
  35   if (_lcc)
  36     delete _lcc;
  37 }
  38
  39 bool
  40 BL::SALOMEServices::initNS()
  41 {
  42   bool return_value = true;
  43   _salome_naming_service = new SALOME_NamingService(_orb);
  44   _lcc = new SALOME_LifeCycleCORBA(_salome_naming_service);
  45   CORBA::Object_var obj = _salome_naming_service->Resolve("/SalomeLauncher");
  46   _salome_launcher = Engines::SalomeLauncher::_narrow(obj);
  47
  48   if (CORBA::is_nil(_salome_launcher))
  49   {
  50     DEBTRACE("SALOME Launcher is not reachable!")
  51     return_value = false;
  52   }
  53
  54   obj = _salome_naming_service->Resolve("/ResourcesManager");
  55   _resources_manager = Engines::ResourcesManager::_narrow(obj);
  56   if (CORBA::is_nil(_resources_manager))
  57   {
  58     DEBTRACE("SALOME Resource Manager is not reachable !");
  59     return_value = false;
  60   }
  61
  62   _state = return_value;
  63   return return_value;
  64 }
  65
  66 std::list<std::string>
  67 BL::SALOMEServices::getMachineList()
  68 {
  69   std::list<std::string> machine_list;
  70
  71   if (_state)
  72   {
  73     Engines::MachineParameters params;
  74     _lcc->preSet(params);
  75     Engines::MachineList * machineList = _resources_manager->GetFittingResources(params);
  76     for (int i = 0; i < machineList->length(); i++)
  77     {
  78       const char* aMachine = (*machineList)[i];
  79       machine_list.push_back(aMachine);
  80     }
  81   }
  82
  83   return machine_list;
  84 }
  85
  86 std::string
  87 BL::SALOMEServices::start_job(BL::Job * job)
  88 {
  89   return start_yacs_job(job);
  90 }
  91
  92 std::string
  93 BL::SALOMEServices::start_yacs_job(BL::Job * job)
  94 {
  95   std::string ret = "";
  96   // Prepare Arguments
  97   const char * fileToExecute = job->getYACSFile().c_str();
  98
  99   BL::Job::FilesParam files = job->getFilesParameters();
 100   Engines::FilesList_var filesToExport = new Engines::FilesList;
 101   filesToExport->length(files.input_files_list.size());
 102   std::list<std::string>::iterator it;
 103   int i = 0;
 104   for (it=files.input_files_list.begin() ; it != files.input_files_list.end(); it++)
 105   {
 106     filesToExport[i] = CORBA::string_dup((*it).c_str());
 107     i++;
 108   }
 109   Engines::FilesList_var filesToImport = new Engines::FilesList;
 110   filesToImport->length(files.output_files_list.size());
 111   i = 0;
 112   for (it=files.output_files_list.begin() ; it != files.output_files_list.end(); it++)
 113   {
 114     filesToImport[i] = CORBA::string_dup((*it).c_str());
 115     i++;
 116   }
 117
 118   BL::Job::BatchParam cpp_batch_params =  job->getBatchParameters();
 119   Engines::BatchParameters_var batch_params = new Engines::BatchParameters;
 120   batch_params->batch_directory = CORBA::string_dup(cpp_batch_params.batch_directory.c_str());
 121   batch_params->expected_during_time = CORBA::string_dup(cpp_batch_params.expected_during_time.c_str());
 122   batch_params->mem = CORBA::string_dup(cpp_batch_params.expected_memory.c_str());
 123   batch_params->nb_proc = cpp_batch_params.nb_proc;
 124
 125   Engines::MachineParameters_var machine = new Engines::MachineParameters;
 126   machine->hostname = CORBA::string_dup(job->getMachine().c_str());
 127
 128   // Start Job !
 129   try
 130   {
 131     int job_id = _salome_launcher->submitSalomeJob(fileToExecute, filesToExport,
 132                                                    filesToImport, batch_params, machine);
 133     job->setSalomeLauncherId(job_id);
 134   }
 135   catch (const SALOME::SALOME_Exception & ex)
 136   {
 137     DEBTRACE("SALOME Exception in submitSalomeJob !");
 138     ret = ex.details.text.in();
 139   }
 140   return ret;
 141 }
 142
 143 std::string
 144 BL::SALOMEServices::refresh_job(BL::Job * job)
 145 {
 146   std::string ret = "";
 147
 148   Engines::MachineParameters_var machine = new Engines::MachineParameters;
 149   machine->hostname = CORBA::string_dup(job->getMachine().c_str());
 150
 151   // Refresh Job !
 152   try
 153   {
 154     CORBA::String_var result = _salome_launcher->queryJob(job->getSalomeLauncherId(), machine);
 155     std::string res = result.in();
 156     if (res == "Running")
 157       return "RUNNING";
 158     else if (res == "Done")
 159       return "FINISHED";
 160     else
 161       return result.in();
 162   }
 163   catch (const SALOME::SALOME_Exception & ex)
 164   {
 165     DEBTRACE("SALOME Exception in refresh_job !");
 166     ret = ex.details.text.in();
 167   }
 168   return ret;
 169 }
 170
 171 std::string
 172 BL::SALOMEServices::delete_job(BL::Job * job)
 173 {
 174   std::string ret = "";
 175
 176   Engines::MachineParameters_var machine = new Engines::MachineParameters;
 177   machine->hostname = CORBA::string_dup(job->getMachine().c_str());
 178
 179   // Delete Job !
 180   try
 181   {
 182     _salome_launcher->deleteJob(job->getSalomeLauncherId(), machine);
 183   }
 184   catch (const SALOME::SALOME_Exception & ex)
 185   {
 186     DEBTRACE("SALOME Exception in refresh_job !");
 187     ret = ex.details.text.in();
 188   }
 189   return ret;
 190 }
 191
 192 std::string
 193 BL::SALOMEServices::get_results_job(BL::Job * job)
 194 {
 195   std::string ret = "";
 196
 197   Engines::MachineParameters_var machine = new Engines::MachineParameters;
 198   machine->hostname = CORBA::string_dup(job->getMachine().c_str());
 199
 200   BL::Job::FilesParam files = job->getFilesParameters();
 201   CORBA::String_var directory = CORBA::string_dup(files.result_directory.c_str());
 202
 203   // get job results !
 204   try
 205   {
 206     _salome_launcher->getResultsJob(directory, job->getSalomeLauncherId(), machine);
 207   }
 208   catch (const SALOME::SALOME_Exception & ex)
 209   {
 210     DEBTRACE("SALOME Exception in refresh_job !");
 211     ret = ex.details.text.in();
 212   }
 213   return ret;
 214 }