Salome HOME
ba84a3a81413a717858e471895dd93d521d839a8
[tools/libbatch.git] / 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 }