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 <cstdlib>
  37 #include <iostream>
  38 #include <fstream>
  39 #include <sstream>
  40 //#include "MEDMEM_STRING.hxx"
  41 #include "Batch_BatchManager_PBS.hxx"
  42 using namespace std;
  43
  44 namespace Batch {
  45
  46   // Recupere le nom du serveur par defaut
  47 //   string BatchManager_PBS::getDefaultServer() {
  48 //     string server_name = "localhost";
  49
  50 //     const char * server_name_path = "@openpbsspooldir@/server_name";
  51 //     ifstream server_name_file(server_name_path);
  52 //     if (server_name_file) {
  53 //       server_name_file >> server_name;
  54 //       server_name_file.close();
  55 //     }
  56
  57 //     return server_name;
  58 //   }
  59
  60   // Constructeur
  61 //   BatchManager_PBS::BatchManager_PBS() throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(BatchManager_PBS::getDefaultServer())
  62 //   {
  63 //     // On se connecte au serveur PBS
  64 //     _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
  65 //     if (_connect < 0) { // si erreur
  66 //       char * errmsg = pbs_geterrmsg(_connect);
  67 //       string msg = "PBS Server on host \"";
  68 //       msg += _hostname;
  69 //       msg += "\" : ";
  70 //       msg += errmsg ? errmsg : "Reason unknown";
  71 //       throw ConnexionFailureException(msg.c_str());
  72 //     }
  73 //   }
  74
  75   // Constructeur
  76 //   BatchManager_PBS::BatchManager_PBS(string host) throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(host)
  77 //   {
  78 //     // On se connecte au serveur PBS
  79 //     _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
  80 //     if (_connect < 0) { // si erreur
  81 //       char * errmsg = pbs_geterrmsg(_connect);
  82 //       string msg = "PBS Server on host \"";
  83 //       msg += _hostname;
  84 //       msg += "\" : ";
  85 //       msg += errmsg ? errmsg : "Reason unknown";
  86 //       throw ConnexionFailureException(msg.c_str());
  87 //     }
  88 //   }
  89   BatchManager_PBS::BatchManager_PBS(const FactBatchManager * parent, const char * host) throw(InvalidArgumentException,ConnexionFailureException) : BatchManager(parent, host)
  90   {
  91     // On se connecte au serveur PBS
  92     _connect = pbs_connect(const_cast< char * >(_hostname.c_str()));
  93     if (_connect < 0) { // si erreur
  94       throw ConnexionFailureException(getErrorMessage("connect").c_str());
  95     }
  96   }
  97
  98   // Destructeur
  99   BatchManager_PBS::~BatchManager_PBS()
 100   {
 101     // On se deconnecte du serveur PBS
 102     int rc = pbs_disconnect(_connect);
 103     if (rc < 0) { // si erreur
 104       throw ConnexionFailureException(getErrorMessage("disconnect").c_str());
 105     }
 106   }
 107
 108   string BatchManager_PBS::getErrorMessage(const char * operation) const
 109   {
 110     char * msg = pbs_geterrmsg(_connect);
 111     stringstream sstr;
 112     sstr << "PBS " << operation << " error (host \"" << _hostname << "\"): ";
 113     if (msg != NULL) {
 114       sstr << msg;
 115     } else {
 116       sstr << "code = " << pbs_errno << " (" << pbse_to_txt(pbs_errno) << ")";
 117     }
 118     return sstr.str();
 119   }
 120
 121   // Methode pour le controle des jobs : soumet un job au gestionnaire
 122   const JobId BatchManager_PBS::submitJob(const Job & job)
 123   {
 124     Job_PBS jobpbs = job;
 125     char * ref = pbs_submit(_connect,
 126                             jobpbs.getAttributesOP(),
 127                             jobpbs.getScript(),
 128                             jobpbs.getDestination(),
 129                             NULL);
 130     if (!ref) { // si erreur
 131       throw APIInternalFailureException(getErrorMessage("submit").c_str());
 132     }
 133
 134     JobId id(this, string(ref));
 135     free(ref);
 136     return id;
 137   }
 138
 139   // Methode pour le controle des jobs : retire un job du gestionnaire
 140   void BatchManager_PBS::deleteJob(const JobId & jobid)
 141   {
 142     char * ref = const_cast< char * >(jobid.getReference().c_str());
 143     int rc = pbs_deljob(_connect, ref, 0);
 144     if (rc) { // si erreur
 145       throw APIInternalFailureException(getErrorMessage("deljob").c_str());
 146     }
 147   }
 148
 149   // Methode pour le controle des jobs : suspend un job en file d'attente
 150   void BatchManager_PBS::holdJob(const JobId & jobid)
 151   {
 152     char * ref = const_cast< char * >(jobid.getReference().c_str());
 153     int rc = pbs_holdjob(_connect, ref, USER_HOLD, 0);
 154     if (rc) { // si erreur
 155       throw APIInternalFailureException(getErrorMessage("holdjob").c_str());
 156     }
 157   }
 158
 159   // Methode pour le controle des jobs : relache un job suspendu
 160   void BatchManager_PBS::releaseJob(const JobId & jobid)
 161   {
 162     char * ref = const_cast< char * >(jobid.getReference().c_str());
 163     int rc = pbs_rlsjob(_connect, ref, USER_HOLD, 0);
 164     if (rc) { // si erreur
 165       throw APIInternalFailureException(getErrorMessage("rlsjob").c_str());
 166     }
 167   }
 168
 169
 170   // Methode pour le controle des jobs : modifie un job en file d'attente
 171   void BatchManager_PBS::alterJob(const JobId & jobid, const Parametre & param, const Environnement & env)
 172   {
 173     Job job(param, env);
 174     Job_PBS jobpbs(job);
 175
 176     char * ref = const_cast< char * >(jobid.getReference().c_str());
 177     int rc = pbs_alterjob(_connect,
 178                           ref,
 179                           jobpbs.getAttributes(),
 180                           NULL);
 181     if (rc) { // si erreur
 182       throw APIInternalFailureException(getErrorMessage("alterjob").c_str());
 183     }
 184
 185   }
 186
 187   // Methode pour le controle des jobs : modifie un job en file d'attente
 188   void BatchManager_PBS::alterJob(const JobId & jobid, const Parametre & param)
 189   {
 190     alterJob(jobid, param, Environnement());
 191   }
 192
 193   // Methode pour le controle des jobs : modifie un job en file d'attente
 194   void BatchManager_PBS::alterJob(const JobId & jobid, const Environnement & env)
 195   {
 196     alterJob(jobid, Parametre(), env);
 197   }
 198
 199
 200
 201   // Methode pour le controle des jobs : renvoie l'etat du job
 202   JobInfo BatchManager_PBS::queryJob(const JobId & jobid)
 203   {
 204     char * id = const_cast< char * >(jobid.getReference().c_str());
 205     JobInfo_PBS ji = JobInfo_PBS(pbs_statjob(_connect, id, 0, 0), true);
 206     return ji;
 207   }
 208
 209
 210
 211 }