src/Core/CommunicationProtocol.cxx

   1 // Copyright (C) 2007-2015  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, or (at your option) any later version.
  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  *  CommunicationProtocol.cxx :
  24  *
  25  *  Created on: 14 sept. 2009
  26  *  Author : Renaud BARATE - EDF R&D
  27  */
  28
  29 #include <stdlib.h>
  30
  31 #include <libbatch_config.h>
  32
  33 #include "CommunicationProtocol.hxx"
  34 #ifdef HAS_RSH
  35  #include "CommunicationProtocolRSH.hxx"
  36 #endif
  37 #ifdef HAS_SH
  38  #include "CommunicationProtocolSH.hxx"
  39 #endif
  40 #ifdef HAS_SSH
  41  #include "CommunicationProtocolSSH.hxx"
  42 #endif
  43 #include "APIInternalFailureException.hxx"
  44 #include "RunTimeException.hxx"
  45 #include "Log.hxx"
  46
  47 using namespace std;
  48
  49 namespace Batch {
  50
  51   CommunicationProtocol::CommunicationProtocol(CommunicationProtocolType type)
  52   : _type(type)
  53   {
  54   }
  55
  56   CommunicationProtocol::~CommunicationProtocol()
  57   {
  58   }
  59
  60   const CommunicationProtocol & CommunicationProtocol::getInstance(CommunicationProtocolType protocolType)
  61   {
  62     if (protocolType == SH) {
  63 #ifdef HAS_SH
  64       static CommunicationProtocolSH instanceSH;
  65       return instanceSH;
  66 #else
  67       throw RunTimeException("Can't use SH protocol (SH tools were "
  68                              "not found on the system at compile time).");
  69 #endif
  70     } else if (protocolType == RSH) {
  71 #ifdef HAS_RSH
  72       static CommunicationProtocolRSH instanceRSH;
  73       return instanceRSH;
  74 #else
  75       throw RunTimeException("Can't use RSH protocol (RSH tools were "
  76                              "not found on the system at compile time).");
  77 #endif
  78     } else if (protocolType == SSH) {
  79 #ifdef HAS_SSH
  80       static CommunicationProtocolSSH instanceSSH;
  81       return instanceSSH;
  82 #else
  83       throw RunTimeException("Can't use SSH protocol (SSH tools were "
  84                              "not found on the system at compile time).");
  85 #endif
  86     } else
  87       throw APIInternalFailureException("Unknown communication protocol.");
  88   }
  89
  90   string CommunicationProtocol::getExecCommand(const string & subCommand,
  91                                                const string & host,
  92                                                const string & user) const
  93   {
  94     return commandStringFromArgs(getExecCommandArgs(subCommand, host, user));
  95   }
  96
  97   int CommunicationProtocol::copyFile(const std::string & sourcePath,
  98                                       const std::string & sourceHost,
  99                                       const std::string & sourceUser,
 100                                       const std::string & destinationPath,
 101                                       const std::string & destinationHost,
 102                                       const std::string & destinationUser) const
 103   {
 104     string command = commandStringFromArgs(getCopyCommandArgs(sourcePath, sourceHost, sourceUser,
 105                                                               destinationPath, destinationHost,
 106                                                               destinationUser));
 107     LOG(command);
 108     int status = system(command.c_str());
 109     return status;
 110   }
 111
 112   string CommunicationProtocol::getRemoveSubCommand(const string & path) const
 113   {
 114     return string("rm ") + path;
 115   }
 116
 117   string CommunicationProtocol::getRemoveDirectorySubCommand(const string & path) const
 118   {
 119     return string("rm -fR ") + path;
 120   }
 121
 122   string CommunicationProtocol::getMakeDirectorySubCommand(const string & path) const
 123   {
 124     return string("mkdir -p ") + path;
 125   }
 126
 127   int CommunicationProtocol::removeFile(const std::string & path,
 128                                         const std::string & host,
 129                                         const std::string & user) const
 130   {
 131     string command = getExecCommand(getRemoveSubCommand(path), host, user);
 132     LOG(command);
 133     int status = system(command.c_str());
 134     return status;
 135   }
 136
 137   int CommunicationProtocol::removeDirectory(const std::string & path,
 138                                         const std::string & host,
 139                                         const std::string & user) const
 140   {
 141     string command = getExecCommand(getRemoveDirectorySubCommand(path), host, user);
 142     LOG(command);
 143     int status = system(command.c_str());
 144     return status;
 145   }
 146
 147   int CommunicationProtocol::makeDirectory(const std::string & path,
 148                                            const std::string & host,
 149                                            const std::string & user) const
 150   {
 151     string command = getExecCommand(getMakeDirectorySubCommand(path), host, user);
 152     LOG(command);
 153     int status = system(command.c_str());
 154     return status;
 155   }
 156
 157   string CommunicationProtocol::commandStringFromArgs(const vector<string> & commandArgs) const
 158   {
 159     string commandStr;
 160
 161     // On Windows we surround the whole command with quotes to avoid problems when
 162     // we have several quoted arguments.
 163 #ifdef WIN32
 164     commandStr += "\"";
 165 #endif
 166
 167     for (unsigned int i=0 ; i<commandArgs.size() ; i++) {
 168       if (i != 0) commandStr += " ";
 169
 170       // if the argument contains spaces, we surround it with simple quotes (Linux)
 171       // or double quotes (Windows)
 172       if (commandArgs[i].find(' ') != string::npos) {
 173         commandStr += string("\"") + commandArgs[i] + "\"";
 174       } else {
 175         commandStr += commandArgs[i];
 176       }
 177     }
 178
 179 #ifdef WIN32
 180     commandStr += "\"";
 181 #endif
 182
 183     return commandStr;
 184   }
 185
 186   CommunicationProtocolType CommunicationProtocol::getType() const
 187   {
 188     return _type;
 189   }
 190
 191 }