]> SALOME platform Git repositories - tools/libbatch.git/blob - src/Core/Batch_CommunicationProtocolRSH.cxx
Salome HOME
99f28ba721781eccdc54a93d3b9eba23a83a463f
[tools/libbatch.git] / src / Core / Batch_CommunicationProtocolRSH.cxx
1 //  Copyright (C) 2007-2012  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  *  Batch_CommunicationProtocolRSH.cxx :
24  *
25  *  Created on: 14 sept. 2009
26  *  Author : Renaud BARATE - EDF R&D
27  */
28
29 #ifdef WIN32
30 #include <direct.h>
31 #include <iostream>
32
33 #include <Batch_RunTimeException.hxx>
34 #endif
35
36 #include <Batch_config.h>
37
38 #include "Batch_CommunicationProtocolRSH.hxx"
39
40 using namespace std;
41
42 namespace Batch {
43
44   vector<string> CommunicationProtocolRSH::getExecCommandArgs(const string & subCommand,
45                                                               const string & host,
46                                                               const string & user) const
47   {
48     vector<string> cmd;
49
50     cmd.push_back(RSH_COMMAND);
51     cmd.push_back(host);
52
53     if (user.size() > 0) {
54       cmd.push_back("-l");
55       cmd.push_back(user);
56     }
57
58 #ifdef WIN32
59     cmd.push_back("-n");
60 #endif
61
62     cmd.push_back(subCommand);
63
64     return cmd;
65   }
66
67   vector<string> CommunicationProtocolRSH::getCopyCommandArgs(const string & sourcePath,
68                                                               const string & sourceHost,
69                                                               const string & sourceUser,
70                                                               const string & destinationPath,
71                                                               const string & destinationHost,
72                                                               const string & destinationUser) const
73   {
74     vector<string> cmd;
75
76     string fullSource;
77     if (sourceHost.size() != 0) {
78       if (sourceUser.size() != 0) {
79 #ifdef WIN32
80         fullSource += sourceHost + "." + sourceUser + ":";
81 #else
82         fullSource += sourceUser + "@" + sourceHost + ":";
83 #endif
84       } else {
85         fullSource += sourceHost + ":";
86       }
87     }
88     fullSource += sourcePath;
89
90     string fullDestination;
91     if (destinationHost.size() != 0) {
92       if (destinationUser.size() != 0) {
93 #ifdef WIN32
94         fullDestination += destinationHost + "." + destinationUser + ":";
95 #else
96         fullDestination += destinationUser + "@" + destinationHost + ":";
97 #endif
98       } else {
99         fullDestination += destinationHost + ":";
100       }
101     }
102     fullDestination += destinationPath;
103
104     cmd.push_back(RCP_COMMAND);
105     cmd.push_back("-r");
106     cmd.push_back(fullSource);
107     cmd.push_back(fullDestination);
108
109     return cmd;
110   }
111
112 #ifdef WIN32
113   int CommunicationProtocolRSH::copyFile(const std::string & sourcePath,
114                                          const std::string & sourceHost,
115                                          const std::string & sourceUser,
116                                          const std::string & destinationPath,
117                                          const std::string & destinationHost,
118                                          const std::string & destinationUser) const
119   {
120     // On Windows, we can't use drive letters in the paths of rcp command because they
121     // are confused with host names. So we must first change the working directory and
122     // then copy the file using its path without the drive letter.
123
124     // Extract the drive letter from the source path
125     string sourcePathWithoutDrive;
126     char sourceDriveLetter = getDriveLetter(sourcePath, &sourcePathWithoutDrive);
127     // Error if we have a drive letter and it is a remote path
128     if (sourceDriveLetter != '\0' && sourceHost.size() != 0)
129       throw RunTimeException(string("Invalid path: ") + sourcePath + " for host " + sourceHost);
130
131     // Extract the drive letter from the destination path
132     string destinationPathWithoutDrive;
133     char destinationDriveLetter = getDriveLetter(destinationPath, &destinationPathWithoutDrive);
134     // Error if we have a drive letter and it is a remote path
135     if (destinationDriveLetter != '\0' && destinationHost.size() != 0)
136       throw RunTimeException(string("Invalid path: ") + destinationPath + " for host " + destinationHost);
137
138     // Error if we have two drive letters and they are different
139     if (sourceDriveLetter != '\0' && destinationDriveLetter != '\0' &&
140         sourceDriveLetter != destinationDriveLetter)
141       throw RunTimeException(string("Can't use RCP to copy files between different drives: ") +
142                              sourcePath + (", ") + destinationPath);
143
144     // Now get the drive letter to use if there is one
145     char driveLetter = (sourceDriveLetter != '\0') ? sourceDriveLetter : destinationDriveLetter;
146
147     // Get the drive of the current working directory
148     char cwd[_MAX_PATH];
149     _getcwd(cwd, _MAX_PATH);
150     char currentDrive = getDriveLetter(cwd);
151
152     // Change working directory if necessary
153     if (driveLetter != '\0' && driveLetter != currentDrive) {
154       char newdir[3];
155       newdir[0] = driveLetter;
156       newdir[1] = ':';
157       newdir[2] = '\0';
158       cout << "Changing directory: " << newdir << endl;
159       _chdir(newdir);
160     }
161
162     int status = CommunicationProtocol::copyFile(sourcePathWithoutDrive, sourceHost, sourceUser,
163                                                  destinationPathWithoutDrive, destinationHost, destinationUser);
164
165     // Go back to previous directory if necessary
166     if (driveLetter != '\0' && driveLetter != currentDrive) {
167       cout << "Changing directory: " << cwd << endl;
168       _chdir(cwd);
169     }
170
171     return status;
172   }
173
174   char CommunicationProtocolRSH::getDriveLetter(const string & path, string * pathWithoutDrive) const
175   {
176     if (path.find(':') != string::npos) {
177       // Error if the colon is not the second character
178       if (path.size() < 2 || path[1] != ':')
179         throw RunTimeException(string("Invalid path: ") + path);
180       else {
181         if (pathWithoutDrive != NULL) *pathWithoutDrive = path.substr(2);
182         return path[0];
183       }
184     } else {
185       if (pathWithoutDrive != NULL) *pathWithoutDrive = path;
186       return '\0';
187     }
188   }
189
190 #endif
191
192 }