def run_command(cmd, env=None, **kwargs):
"""Run the given command in killable process."""
killable_kwargs = {'stdout':stdout ,'stderr':stderr, 'stdin':stdin}
killable_kwargs.update(kwargs)
if sys.platform != "win32":
return killableprocess.Popen(cmd, preexec_fn=lambda : os.setpgid(0, 0),
env=env, **killable_kwargs)
else:
return killableprocess.Popen(cmd, env=env, **killable_kwargs)
def _execute_with_timeout(self, cmd, max_attempts=3, max_timeout=120):
logging.debug("$> %s # with timeout %ds", ' '.join(cmd), max_timeout)
attempt = 0
while attempt < max_attempts:
attempt = attempt + 1
out = tempfile.NamedTemporaryFile(delete=False)
err = tempfile.NamedTemporaryFile(delete=False)
p = killableprocess.Popen(cmd, stdout=out, stderr=err)
p.wait(max_timeout)
out.flush()
out.close()
err.flush()
err.close()
# -9 and 127 are returned by killableprocess when a timeout happens
if p.returncode == -9 or p.returncode == 127:
logging.warn("Executing %s failed executing in less then %d seconds and was killed, attempt number %d of %d" % (
' '.join(cmd), max_timeout, attempt, max_attempts))
continue
try:
outfile = open(out.name, 'r')
errfile = open(err.name, 'r')
return p.returncode, outfile.read(), errfile.read()
finally:
outfile.close()
os.unlink(out.name)
errfile.close()
os.unlink(errfile.name)
def __init__(self,
encoding,
external_id=None,
cmd_postfix="\n",
suppress_echo=False,
cmd=None,
env=None,
cwd=None,
extend_env=None,
soft_quit=""):
super(SubprocessRepl, self).__init__(encoding, external_id,
cmd_postfix, suppress_echo)
settings = load_settings('SublimeREPL.sublime-settings')
env = self.env(env, extend_env, settings)
self._cmd = self.cmd(cmd, env)
self._soft_quit = soft_quit
self.popen = killableprocess.Popen(
self._cmd,
startupinfo=self.startupinfo(settings),
creationflags=self.creationflags(settings),
bufsize=1,
cwd=self.cwd(cwd, settings),
env=env,
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
def git(command, *args):
command_line = ["git", command] + list(args)
sys.stderr.write("Running command %s\n" % " ".join(command_line))
proc = killableprocess.Popen(command_line,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
return proc
def runVrPrepare(project, logfile):
# run
log = open(logfile, "w")
process = killableprocess.Popen([VR_PREPARE, project],
stdout=log,
stderr=log)
ret = process.wait(TIMEOUT * 60, True)
log.close()
return (ret != -9) # -9 means timeout
def main(argv=None):
if argv is None:
argv = sys.argv[1:] # don't include the script name
ADB_TIMEOUT = os.getenv('ADB_TIMEOUT', 300)
ADB_MAX_ATTEMPTS = os.getenv('ADB_MAX_ATTEMPTS', 2)
attempt = 0
args = ""
for arg in argv:
args += " %s" % arg
cmd = "adb %s" % (args)
#print "cmd: %s" % cmd
while attempt < ADB_MAX_ATTEMPTS:
attempt = attempt + 1
# Need to call the subprocess using a file object for stdout. There have been
# problems with the OS blocking when large amounts of data is being returned
# in stdout when making the call to adb. Poth processes must be buffering and
# causing the process to become blocked.
f = tempfile.NamedTemporaryFile(delete=False)
p = killableprocess.Popen(cmd,
shell=True,
stdout=f,
stderr=subprocess.PIPE)
try:
p.wait(ADB_TIMEOUT)
except OSError:
'''
We have seen the following error happen in the build system, so guard against
this error and just treat like a timeout and retry the call
"killableprocess.py", line 177, in kill
os.killpg(self.pid, signal.SIGKILL)
OSError: [Errno 3] No such process
'''
p.returncode = 127
f.flush()
f.close()
# -9 and 127 are returned by killableprocess when a timeout happens
if p.returncode == -9 or p.returncode == 127:
failure = file('/tmp/adb_failures', 'a')
failure.write('%s, %s, %s\n' %
(datetime.datetime.now(), attempt, cmd))
failure.flush()
failure.close()
continue
stdout = ""
outfile = open(f.name, 'r')
for line in outfile:
stdout += line
outfile.close()
os.unlink(f.name)
return stdout
def _execute(process_arguments, workaround=False):
"""underlying execution method to call filebot as subprocess
Handles the actual execution and output capture
Args:
process_arguments: list of the arguments to be passed to filebotCLI
workaround: implements a work around for capturing unicode
characters on windows systems. should always be true except in
special circumstances.
Returns:
tuple in format '(exit_code, stdout, stderr)'
"""
# open and close a temp file so filebot can use it as a log file.
# this is a workaround for malfunctioning UTF-8 chars in Windows.
file_temp = tempfile.NamedTemporaryFile(delete=False)
file_temp.close()
if workaround:
process_arguments = (
[FILEBOT_EXE, "--log-file", file_temp.name] + process_arguments)
else:
process_arguments = ([FILEBOT_EXE] + process_arguments)
if os.name == "nt": # used to hide cmd window popup
startupinfo = killableprocess.winprocess.STARTUPINFO()
startupinfo.dwFlags |= killableprocess.winprocess.STARTF_USESHOWWINDOW
else:
startupinfo = None
try:
process = killableprocess.Popen(
process_arguments,
stdout=killableprocess.subprocess.PIPE,
stderr=killableprocess.subprocess.PIPE,
stdin=killableprocess.subprocess.PIPE,
startupinfo=startupinfo)
except OSError as e:
raise FilebotFatalError("Error running Filebot! {0}".format(str(e)))
stdout, error = process.communicate()
exit_code = process.returncode
if workaround:
with open(file_temp.name, 'rU') as log:
data = log.read() # read and cleanup temp/logfile
log.close()
else:
data = stdout
os.remove(file_temp.name)
return exit_code, data, error
def run_command(cmd, env=None):
"""Run the given command in killable process."""
if hasattr(sys.stdout, "fileno"):
kwargs = {
'stdout': sys.stdout,
'stderr': sys.stderr,
'stdin': sys.stdin
}
else:
kwargs = {
'stdout': sys.__stdout__,
'stderr': sys.__stderr__,
'stdin': sys.stdin
}
if sys.platform != "win32":
return killableprocess.Popen(cmd,
preexec_fn=lambda: os.setpgid(0, 0),
env=env,
**kwargs)
else:
return killableprocess.Popen(cmd, **kwargs)
def __init__(self,
encoding,
external_id=None,
cmd_postfix="\n",
suppress_echo=False,
cmd=None,
env=None,
cwd=None,
extend_env=None,
soft_quit="",
autocomplete_server=False):
super(SubprocessRepl, self).__init__(encoding, external_id,
cmd_postfix, suppress_echo)
settings = load_settings('SublimeREPL.sublime-settings')
if cmd[0] == "[unsupported]":
raise Unsupported(cmd[1:])
self._autocomplete_server = None
if autocomplete_server:
self._autocomplete_server = AutocompleteServer(
self, settings.get("autocomplete_server_ip"))
self._autocomplete_server.start()
env = self.env(env, extend_env, settings)
env["SUBLIMEREPL_AC_PORT"] = str(self.autocomplete_server_port())
env["SUBLIMEREPL_AC_IP"] = settings.get("autocomplete_server_ip")
self._cmd = self.cmd(cmd, env)
self._soft_quit = soft_quit
self._killed = False
self.popen = killableprocess.Popen(
self._cmd,
startupinfo=self.startupinfo(settings),
creationflags=self.creationflags(settings),
bufsize=1,
cwd=self.cwd(cwd, settings),
env=env,
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
def start(self):
"""Start IE"""
self.set_proxy()
# allow_reg = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
# "Software\\Microsoft\\Internet Explorer\\New Windows\\Allow", 0, wreg.KEY_ALL_ACCESS)
#
# wreg.SetValueEx(allow_reg, urlparse(windmill.settings['TEST_URL']).hostname,
# 0, wreg.REG_BINARY, None)
#Workaround for but in nose
if hasattr(sys.stdout, 'fileno'):
kwargs = {
'stdout': sys.stdout,
'stderr': sys.stderr,
'stdin': sys.stdin
}
else:
kwargs = {
'stdout': sys.__stdout__,
'stderr': sys.__stderr__,
'stdin': sys.stdin
}
self.p_handle = killableprocess.Popen(self.cmd, **kwargs)
def runCommand(cmd, env=None, timeout=-1, logger=log, ignorepreexec=False):
"""
Execute the given command and log all output
Success and failure codes:
>>> runCommand(['true'])
0
>>> runCommand(['false'])
1
Interleaved stdout and stderr messages:
>>> runCommand(['python', '-c', r'print 1;import sys;sys.stdout.flush();print >>sys.stderr, 2;print 3'])
1
2
3
0
Now with timeout:
>>> runCommand(['python', '-c', r'print 1;import sys;sys.stdout.flush();print >>sys.stderr, 2;print 3'], timeout=5)
1
2
3
0
Setting environment variable:
>>> runCommand(['python', '-c', 'import os;print os.getenv("ENVTEST")'], env={'ENVTEST': '42'})
42
0
Timeout:
>>> runCommand(['sleep', '60'], timeout=5)
-9
"""
redirect = True
if logger == log and _logFile is None:
redirect = False
else:
if timeout == -1:
output = subprocess.PIPE
else:
output = tempfile.TemporaryFile()
if ignorepreexec:
preexec_fn = None
else:
preexec_fn = setpgid_preexec_fn
if redirect:
p = killableprocess.Popen(cmd,
env=env,
stdin=subprocess.PIPE,
stdout=output,
stderr=subprocess.STDOUT,
preexec_fn=preexec_fn)
else:
p = killableprocess.Popen(cmd,
env=env,
stdin=subprocess.PIPE,
preexec_fn=preexec_fn)
try:
if timeout == -1 and redirect:
for line in p.stdout:
logger(line[:-1])
p.wait(timeout=timeout, group=True)
except KeyboardInterrupt:
try:
p.kill(group=True)
except OSError:
p.wait(30)
if timeout != -1 and redirect:
output.seek(0)
for line in output:
logger(line[:-1])
return p.returncode
"""
raise NotImplementedError
def runCommand(self, filenames, async=False, timeout=10, *args):
"""Run the shell loading the files in filename and passing any extra
arguments in args. Returns a tuple of (success, stdout)"""
commandline = self.getCommand(filenames, *args)
if self.verbose:
print " ".join(
map(
lambda s: (' ' in s or '\n' in s) and '"' + re.sub(
"\\s+", " ", s) + '"' or s, commandline))
try:
proc = killableprocess.Popen(commandline,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=os.environ,
bufsize=-1)
except:
raise
sys.stderr.write(
"Command %s failed\n Did you specify the correct path the the jsshell?\n"
% " ".join(commandline))
sys.exit(1)
if async:
return proc
else:
res = proc.wait(timeout)
return res, proc.stdout.read()
"--error-exitcode=102"
] + commandline # 102 is fairly random
if use_temp_file:
stdout = tempfile.TemporaryFile()
else:
stdout = subprocess.PIPE
if self.verbose:
print " ".join(
map(
lambda s: (' ' in s or '\n' in s) and '"' + re.sub(
"\\s+", " ", s) + '"' or s, commandline))
try:
proc = killableprocess.Popen(commandline,
stdout=stdout,
stderr=subprocess.STDOUT,
env=os.environ)
if use_temp_file:
proc.stdout = stdout
except:
raise
sys.stderr.write(
"Command %s failed\n Did you specify the correct path the the jsshell?\n"
% " ".join(commandline))
sys.exit(1)
if async:
return proc
else:
res = proc.wait(timeout)
return res == 0, proc.stdout.read()
