src/Core/Batch_BatchManager_eClient.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_eLSF.cxx : emulation of LSF client
  24 *
  25 * Auteur : Bernard SECHER - CEA DEN
  26 * Mail   : mailto:bernard.secher@cea.fr
  27 * Date   : Thu Apr 24 10:17:22 2008
  28 * Projet : PAL Salome
  29 *
  30 */
  31
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include <ctime>
  36 #include <iostream>
  37 #include <fstream>
  38 #include <sstream>
  39
  40 #include <stdlib.h>
  41
  42 #ifdef WIN32
  43 #include <direct.h>
  44 #include <io.h>
  45 #endif
  46
  47 #include <Batch_config.h>
  48
  49 #include "Batch_BatchManager_eClient.hxx"
  50 #include "Batch_RunTimeException.hxx"
  51
  52 #ifdef MSVC
  53 #define EXISTS(path) _access_s(path, 0) == 0
  54 #else
  55 #define EXISTS(path) access(path, F_OK) == 0
  56 #endif
  57
  58 using namespace std;
  59
  60
  61 namespace Batch {
  62
  63   BatchManager_eClient::BatchManager_eClient(const Batch::FactBatchManager * parent, const char* host,
  64                                              CommunicationProtocolType protocolType, const char* mpiImpl)
  65     : BatchManager(parent, host), _protocol(CommunicationProtocol::getInstance(protocolType)), _username("")
  66   {
  67     // instanciation of mpi implementation needed to launch executable in batch script
  68     _mpiImpl = FactoryMpiImpl(mpiImpl);
  69   }
  70
  71   // Destructeur
  72   BatchManager_eClient::~BatchManager_eClient()
  73   {
  74     if (_mpiImpl)
  75       delete _mpiImpl;
  76   }
  77
  78   void BatchManager_eClient::exportInputFiles(const Job& job)
  79   {
  80     int status;
  81     Parametre params = job.getParametre();
  82     Versatile V = params[INFILE];
  83     Versatile::iterator Vit;
  84     _username = string(params[USER]);
  85
  86     status = _protocol.makeDirectory(string(params[TMPDIR]) + "/logs", _hostname, _username);
  87     if(status) {
  88       std::ostringstream oss;
  89       oss << status;
  90       std::string ex_mess("Error of connection on remote host ! status = ");
  91       ex_mess += oss.str();
  92       throw EmulationException(ex_mess.c_str());
  93     }
  94
  95     // Second step : copy fileToExecute into
  96     // batch tmp files directory
  97     string executeFile = params[EXECUTABLE];
  98     if (executeFile.size() != 0) {
  99       status = _protocol.copyFile(executeFile, "", "",
 100                                   params[TMPDIR], _hostname, _username);
 101       if(status) {
 102         std::ostringstream oss;
 103         oss << status;
 104         std::string ex_mess("Error of connection on remote host ! status = ");
 105         ex_mess += oss.str();
 106         throw EmulationException(ex_mess.c_str());
 107       }
 108
 109 #ifdef WIN32
 110       // On Windows, we make the remote file executable afterward because
 111       // pscp does not preserve access permissions on files
 112       string subCommand = string("chmod u+x ") + string(params[TMPDIR]) + "/" +
 113                           string(params[EXECUTABLE]);
 114       string command = _protocol.getExecCommand(subCommand, _hostname, _username);
 115       cerr << command.c_str() << endl;
 116       status = system(command.c_str());
 117       if(status) {
 118         std::ostringstream oss;
 119         oss << status;
 120         std::string ex_mess("Error of connection on remote host ! status = ");
 121         ex_mess += oss.str();
 122         throw EmulationException(ex_mess.c_str());
 123       }
 124 #endif
 125     }
 126
 127     // Third step : copy filesToExportList into
 128     // batch tmp files directory
 129     for(Vit=V.begin(); Vit!=V.end(); Vit++) {
 130       CoupleType cpt  = *static_cast< CoupleType * >(*Vit);
 131       Couple inputFile = cpt;
 132       status = _protocol.copyFile(inputFile.getLocal(), "", "",
 133                                   inputFile.getRemote(), _hostname, _username);
 134       if(status) {
 135         std::ostringstream oss;
 136         oss << status;
 137         std::string ex_mess("Error of connection on remote host ! status = ");
 138         ex_mess += oss.str();
 139         throw EmulationException(ex_mess.c_str());
 140       }
 141     }
 142
 143   }
 144
 145   void BatchManager_eClient::importOutputFiles( const Job & job, const string directory ) throw(EmulationException)
 146   {
 147     Parametre params = job.getParametre();
 148     Versatile V = params[OUTFILE];
 149     Versatile::iterator Vit;
 150     _username = string(params[USER]);
 151
 152     // Create local result directory
 153     int status = CommunicationProtocol::getInstance(SH).makeDirectory(directory, "", "");
 154     if (status) {
 155       string mess("Directory creation failed. Status is :");
 156       ostringstream status_str;
 157       status_str << status;
 158       mess += status_str.str();
 159       cerr << mess << endl;
 160     }
 161
 162     for(Vit=V.begin(); Vit!=V.end(); Vit++) {
 163       CoupleType cpt  = *static_cast< CoupleType * >(*Vit);
 164       Couple outputFile = cpt;
 165       status = _protocol.copyFile(outputFile.getRemote(), _hostname, _username,
 166                                   directory, "", "");
 167       if (status) {
 168         // Try to get what we can (logs files)
 169         // throw BatchException("Error of connection on remote host");
 170         std::string mess("Copy command failed ! status is :");
 171         ostringstream status_str;
 172         status_str << status;
 173         mess += status_str.str();
 174         cerr << mess << endl;
 175       }
 176     }
 177
 178     // Copy logs
 179     status = _protocol.copyFile(string(params[TMPDIR]) + string("/logs"), _hostname, _username,
 180                                 directory, "", "");
 181     if (status) {
 182       std::string mess("Copy logs directory failed ! status is :");
 183       ostringstream status_str;
 184       status_str << status;
 185       mess += status_str.str();
 186       cerr << mess << endl;
 187     }
 188
 189   }
 190
 191   MpiImpl *BatchManager_eClient::FactoryMpiImpl(string mpiImpl) throw(EmulationException)
 192   {
 193     if(mpiImpl == "lam")
 194       return new MpiImpl_LAM();
 195     else if(mpiImpl == "mpich1")
 196       return new MpiImpl_MPICH1();
 197     else if(mpiImpl == "mpich2")
 198       return new MpiImpl_MPICH2();
 199     else if(mpiImpl == "openmpi")
 200       return new MpiImpl_OPENMPI();
 201     else if(mpiImpl == "slurm")
 202       return new MpiImpl_SLURM();
 203     else if(mpiImpl == "prun")
 204       return new MpiImpl_PRUN();
 205     else if(mpiImpl == "nompi")
 206       return NULL;
 207     else{
 208       ostringstream oss;
 209       oss << mpiImpl << " : not yet implemented";
 210       throw EmulationException(oss.str().c_str());
 211     }
 212   }
 213
 214   /**
 215    * This method generates a temporary file name with the pattern "<tmpdir>/<prefix>-XXXXXX" where
 216    * <tmpdir> is the directory for temporary files (see BatchManager_eClient::getTmpDir()) and the
 217    * X's are replaced by random characters. Note that this method is less secure than
 218    * BatchManager_eClient::createAndOpenTemporaryFile, so use the latter whenever possible.
 219    * \param prefix the prefix to use for the temporary file.
 220    * \return a name usable for a temporary file.
 221    */
 222   string BatchManager_eClient::generateTemporaryFileName(const string & prefix)
 223   {
 224     string fileName = getTmpDir() + "/" + prefix + "-XXXXXX";
 225     char randstr[7];
 226
 227     do {
 228       sprintf(randstr, "%06d", rand() % 1000000);
 229       fileName.replace(fileName.size()-6, 6, randstr);
 230     } while (EXISTS(fileName.c_str()));
 231
 232     return fileName;
 233   }
 234
 235   /**
 236    * This method creates a temporary file and opens an output stream to write into this file.
 237    * The file is created with the pattern "<tmpdir>/<prefix>-XXXXXX" where <tmpdir> is the directory
 238    * for temporary files (see BatchManager_eClient::getTmpDir()) and the X's are replaced by random
 239    * characters. The caller is responsible for closing and deleting the file when it is no more used.
 240    * \param prefix the prefix to use for the temporary file.
 241    * \param outputStream an output stream that will be opened for writing in the temporary file. If
 242    * the stream is already open, it will be closed first.
 243    * \return the name of the created file.
 244    */
 245   string BatchManager_eClient::createAndOpenTemporaryFile(const string & prefix, ofstream & outputStream)
 246   {
 247     if (outputStream.is_open())
 248       outputStream.close();
 249
 250 #ifdef WIN32
 251
 252     string fileName = generateTemporaryFileName(prefix);
 253     outputStream.open(fileName.c_str());
 254
 255 #else
 256
 257     string fileName = getTmpDir() + "/" + prefix + "-XXXXXX";
 258     char * buf = new char[fileName.size()+1];
 259     fileName.copy(buf, fileName.size());
 260     buf[fileName.size()] = '\0';
 261
 262     int fd = mkstemp(buf);
 263     if (fd == -1) {
 264       delete[] buf;
 265       throw RunTimeException(string("Can't create temporary file ") + fileName);
 266     }
 267     fileName = buf;
 268     delete[] buf;
 269
 270     outputStream.open(fileName.c_str());
 271     close(fd);  // Close the file descriptor so that the file is not opened twice
 272
 273 #endif
 274
 275     if (outputStream.fail())
 276       throw RunTimeException(string("Can't open temporary file ") + fileName);
 277
 278     return fileName;
 279   }
 280
 281   /**
 282    * This method finds the name of the directory to use for temporary files in libBatch. This name
 283    * is <tempdir>/libBatch-<username>-XXXXXX. <tempdir> is found by looking for environment
 284    * variables TEMP, TMP, TEMPDIR, TMPDIR, and defaults to "/tmp" if none of them is defined.
 285    * <username> is found by looking for environment variables USER and USERNAME, and defaults to
 286    * "unknown". XXXXXX represents random characters. The directory name is generated only once for
 287    * each BatchManager_eClient instance, and the directory is created at this moment. Subsequent
 288    * calls will always return the same path and the existence of the directory will not be
 289    * rechecked.
 290    * \return the name of the directory to use for temporary files.
 291    */
 292   const std::string & BatchManager_eClient::getTmpDir()
 293   {
 294     if (tmpDirName.empty()) {
 295       const char * baseDir = getenv("TEMP");
 296       if (baseDir == NULL) baseDir = getenv("TMP");
 297       if (baseDir == NULL) baseDir = getenv("TEMPDIR");
 298       if (baseDir == NULL) baseDir = getenv("TMPDIR");
 299       if (baseDir == NULL) baseDir = "/tmp";
 300
 301       const char * userName = getenv("USER");
 302       if (userName == NULL) userName = getenv("USERNAME");
 303       if (userName == NULL) userName = "unknown";
 304
 305       string baseName = string(baseDir) + "/libBatch-" + userName + "-XXXXXX";
 306       srand(time(NULL));
 307
 308 #ifdef WIN32
 309
 310       char randstr[7];
 311       do {
 312         sprintf(randstr, "%06d", rand() % 1000000);
 313         baseName.replace(baseName.size()-6, 6, randstr);
 314       } while (EXISTS(baseName.c_str()));
 315       if (_mkdir(baseName.c_str()) != 0)
 316         throw RunTimeException(string("Can't create temporary directory ") + baseName);
 317       tmpDirName = baseName;
 318
 319 #else
 320
 321       char * buf = new char[baseName.size() + 1];
 322       baseName.copy(buf, baseName.size());
 323       buf[baseName.size()] = '\0';
 324       if (mkdtemp(buf) == NULL) {
 325         delete[] buf;
 326         throw RunTimeException(string("Can't create temporary directory ") + baseName);
 327       }
 328       tmpDirName = buf;
 329       delete[] buf;
 330
 331 #endif
 332
 333     }
 334
 335     return tmpDirName;
 336   }
 337
 338 }