src/PBS/Batch_BatchManager_PBS.cxx

   1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 /*
  23  * BatchManager_PBS.cxx :
  24  *
  25  * Auteur : Ivan DUTKA-MALEN - EDF R&D
  26  * Mail   : mailto:ivan.dutka-malen@der.edf.fr
  27  * Date   : Thu Nov  6 10:17:22 2003
  28  * Projet : Salome 2
  29  *
  30  */
  31
  32 extern "C" {
  33 #include <pbs_error.h>
  34 #include <pbs_ifl.h>
  35 }
  36 #include <iostream>
  37 #include <fstream>
  38 #include <sstream>
  39 //#include "MEDMEM_STRING.hxx"
  40 #include "Batch_BatchManager_PBS.hxx"
  41 using namespace std;
  42
  43 namespace Batch {
  44
  45   // Recupere le nom du serveur par defaut
  46 //   string BatchManager_PBS::getDefaultServer() {
  47 //     string server_name = "localhost";
  48
  49 //     const char * server_name_path = "@openpbsspooldir@/server_name";
  50 //     ifstream server_name_file(server_name_path);
  51 //     if (server_name_file) {
  52 //       server_name_file >> server_name;
  53 //       server_name_file.close();
  54 //     }
  55
  56 //     return server_name;
  57 //   }
  58
  59   // Constructeur
  60 //   BatchManager_PBS::BatchManager_PBS() throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(BatchManager_PBS::getDefaultServer())
  61 //   {
  62 //     // On se connecte au serveur PBS
  63 //     _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
  64 //     if (_connect < 0) { // si erreur
  65 //       char * errmsg = pbs_geterrmsg(_connect);
  66 //       string msg = "PBS Server on host \"";
  67 //       msg += _hostname;
  68 //       msg += "\" : ";
  69 //       msg += errmsg ? errmsg : "Reason unknown";
  70 //       throw ConnexionFailureException(msg.c_str());
  71 //     }
  72 //   }
  73
  74   // Constructeur
  75 //   BatchManager_PBS::BatchManager_PBS(string host) throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(host)
  76 //   {
  77 //     // On se connecte au serveur PBS
  78 //     _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
  79 //     if (_connect < 0) { // si erreur
  80 //       char * errmsg = pbs_geterrmsg(_connect);
  81 //       string msg = "PBS Server on host \"";
  82 //       msg += _hostname;
  83 //       msg += "\" : ";
  84 //       msg += errmsg ? errmsg : "Reason unknown";
  85 //       throw ConnexionFailureException(msg.c_str());
  86 //     }
  87 //   }
  88   BatchManager_PBS::BatchManager_PBS(const FactBatchManager * parent, const char * host) throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(parent, host)
  89   {
  90     // On se connecte au serveur PBS
  91     _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
  92     if (_connect < 0) { // si erreur
  93       throw ConnexionFailureException(getErrorMessage("connect").c_str());
  94     }
  95   }
  96
  97   // Destructeur
  98   BatchManager_PBS::~BatchManager_PBS()
  99   {
 100     // On se deconnecte du serveur PBS
 101     int rc = pbs_disconnect(_connect);
 102     if (rc < 0) { // si erreur
 103       throw ConnexionFailureException(getErrorMessage("disconnect").c_str());
 104     }
 105   }
 106
 107   string BatchManager_PBS::getErrorMessage(const char * operation) const
 108   {
 109     char * msg = pbs_geterrmsg(_connect);
 110     stringstream sstr;
 111     sstr << "PBS " << operation << " error (host \"" << _hostname << "\"): ";
 112     if (msg != NULL) {
 113       sstr << msg;
 114     } else {
 115       sstr << "code = " << pbs_errno << " (" << pbse_to_txt(pbs_errno) << ")";
 116     }
 117     return sstr.str();
 118   }
 119
 120   // Methode pour le controle des jobs : soumet un job au gestionnaire
 121   const JobId BatchManager_PBS::submitJob(const Job & job)
 122   {
 123     Job_PBS jobpbs = job;
 124     char * ref = pbs_submit(_connect,
 125                             jobpbs.getAttributesOP(),
 126                             jobpbs.getScript(),
 127                             jobpbs.getDestination(),
 128                             NULL);
 129     if (!ref) { // si erreur
 130       throw APIInternalFailureException(getErrorMessage("submit").c_str());
 131     }
 132
 133     JobId id(this, string(ref));
 134     free(ref);
 135     return id;
 136   }
 137
 138   // Methode pour le controle des jobs : retire un job du gestionnaire
 139   void BatchManager_PBS::deleteJob(const JobId & jobid)
 140   {
 141     char * ref = const_cast< char * >(jobid.getReference().c_str());
 142     int rc = pbs_deljob(_connect, ref, 0);
 143     if (rc) { // si erreur
 144       throw APIInternalFailureException(getErrorMessage("deljob").c_str());
 145     }
 146   }
 147
 148   // Methode pour le controle des jobs : suspend un job en file d'attente
 149   void BatchManager_PBS::holdJob(const JobId & jobid)
 150   {
 151     char * ref = const_cast< char * >(jobid.getReference().c_str());
 152     int rc = pbs_holdjob(_connect, ref, USER_HOLD, 0);
 153     if (rc) { // si erreur
 154       throw APIInternalFailureException(getErrorMessage("holdjob").c_str());
 155     }
 156   }
 157
 158   // Methode pour le controle des jobs : relache un job suspendu
 159   void BatchManager_PBS::releaseJob(const JobId & jobid)
 160   {
 161     char * ref = const_cast< char * >(jobid.getReference().c_str());
 162     int rc = pbs_rlsjob(_connect, ref, USER_HOLD, 0);
 163     if (rc) { // si erreur
 164       throw APIInternalFailureException(getErrorMessage("rlsjob").c_str());
 165     }
 166   }
 167
 168
 169   // Methode pour le controle des jobs : modifie un job en file d'attente
 170   void BatchManager_PBS::alterJob(const JobId & jobid, const Parametre & param, const Environnement & env)
 171   {
 172     Job job(param, env);
 173     Job_PBS jobpbs(job);
 174
 175     char * ref = const_cast< char * >(jobid.getReference().c_str());
 176     int rc = pbs_alterjob(_connect,
 177                           ref,
 178                           jobpbs.getAttributes(),
 179                           NULL);
 180     if (rc) { // si erreur
 181       throw APIInternalFailureException(getErrorMessage("alterjob").c_str());
 182     }
 183
 184   }
 185
 186   // Methode pour le controle des jobs : modifie un job en file d'attente
 187   void BatchManager_PBS::alterJob(const JobId & jobid, const Parametre & param)
 188   {
 189     alterJob(jobid, param, Environnement());
 190   }
 191
 192   // Methode pour le controle des jobs : modifie un job en file d'attente
 193   void BatchManager_PBS::alterJob(const JobId & jobid, const Environnement & env)
 194   {
 195     alterJob(jobid, Parametre(), env);
 196   }
 197
 198
 199
 200   // Methode pour le controle des jobs : renvoie l'etat du job
 201   JobInfo BatchManager_PBS::queryJob(const JobId & jobid)
 202   {
 203     char * id = const_cast< char * >(jobid.getReference().c_str());
 204     JobInfo_PBS ji = JobInfo_PBS(pbs_statjob(_connect, id, 0, 0), true);
 205     return ji;
 206   }
 207
 208
 209
 210 }