if not self.localhost:
# Build destination as <user>@<server>:<path>
dst = "%s@%s:%s" % (self.get("username"), self.get("hostname"), dst)
-
result = self.copy(src, dst)
# clean up temp file
def run_and_wait(self, command, home,
shfile = "cmd.sh",
+ env = None,
pidfile = "pidfile",
ecodefile = "exitcode",
stdin = None,
since in the remote host the command can continue to run detached
even if network disconnections occur
"""
- self.upload_command(command, home, shfile, ecodefile)
+ self.upload_command(command, home,
+ shfile = shfile,
+ ecodefile = ecodefile,
+ env = env)
command = "bash ./%s" % shfile
# run command in background in remote host
self.error(msg, out, err)
if raise_on_error:
raise RuntimeError, msg
-
# Wait for pid file to be generated
pid, ppid = self.wait_pid(
home = home,
(out, err), proc = self.check_errors(home, ecodefile, stderr)
# Out is what was written in the stderr file
- if out or err:
+ if err:
msg = " Failed to run command '%s' " % command
self.error(msg, out, err)
shfile = "cmd.sh",
ecodefile = "exitcode",
env = None):
-
- command = " ( %(command)s ) ; echo $? > %(ecodefile)s " % {
+ """ Saves the command as a bash script file in the remote host, and
+ forces to save the exit code of the command execution to the ecodefile
+ """
+
+ # The exit code of the command will be stored in ecodefile
+ command = " %(command)s ; echo $? > %(ecodefile)s ;" % {
'command': command,
'ecodefile': ecodefile,
}
# Export environment
- environ = ""
- if env:
- for var in env.split(" "):
- environ += 'export %s\n' % var
+ environ = self.format_environment(env)
+ # Add environ to command
command = environ + command
dst = os.path.join(home, shfile)
return self.upload(command, dst, text = True)
+ def format_environment(self, env, inline = False):
+ """Format environmental variables for command to be executed either
+ as an inline command (i.e. PYTHONPATH=src/.. python script.py) or
+ as a bash script (i.e. export PYTHONPATH=src/.. \n export LALA=.. \n)
+ """
+ sep = " " if inline else "\n"
+ export = " " if inline else "export"
+ return sep.join(map(lambda e: "%s %s" % (export, e), env.split(" "))) \
+ + sep if env else ""
+
def check_errors(self, home,
ecodefile = "exitcode",
- stderr = "stderr"):
+ stderr = "stderr",
+ stdout = "stdout"):
"""
Checks whether errors occurred while running a command.
It first checks the exit code for the command, and only if the
exit code is an error one it returns the error output.
+
"""
out = err = ""
proc = None
- # get Exit code
+ # get exit code saved in the 'exitcode' file
ecode = self.exitcode(home, ecodefile)
if ecode in [ ExitCode.CORRUPTFILE, ExitCode.ERROR ]:
elif ecode > 0 or ecode == ExitCode.FILENOTFOUND:
# The process returned an error code or didn't exist.
# Check standard error.
- (out, err), proc = self.check_output(home, stderr)
-
- # If the stderr file was not found, assume nothing happened.
- # We just ignore the error.
+ (err, eerr), proc = self.check_output(home, stderr)
+
+ # Alsow retrive standard output for information
+ (out, oerr), oproc = self.check_output(home, stdout)
+
+ # If the stderr file was not found, assume nothing bad happened,
+ # and just ignore the error.
# (cat returns 1 for error "No such file or directory")
if ecode == ExitCode.FILENOTFOUND and proc.poll() == 1:
- out = err = ""
+ err = ""
return (out, err), proc
connect_timeout = 30,
strict_host_checking = False,
persistent = True,
+ blocking = True,
with_lock = False
):
""" Notice that this invocation will block until the
err_on_timeout = err_on_timeout,
connect_timeout = connect_timeout,
persistent = persistent,
+ blocking = blocking,
strict_host_checking = strict_host_checking
)
else:
retry = retry,
err_on_timeout = err_on_timeout,
connect_timeout = connect_timeout,
- persistent = persistent
+ persistent = persistent,
+ blocking = blocking,
+ strict_host_checking = strict_host_checking
)
return (out, err), proc