def check_output(*popenargs, **kwargs):
r"""Run command with arguments and return its output as a byte string.
If the exit code was non-zero it raises a CalledProcessError. The
CalledProcessError object will have the return code in the returncode
attribute and output in the output attribute.
The arguments are the same as for the Popen constructor. Example:
>>> check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
The stdout argument is not allowed as it is used internally.
To capture standard error in the result, use stderr=STDOUT.
>>> check_output(["/bin/sh", "-c",
... "ls -l non_existent_file ; exit 0"],
... stderr=STDOUT)
'ls: non_existent_file: No such file or directory\n'
"""
from subprocess import PIPE, CalledProcessError, Popen
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
err = CalledProcessError(retcode, cmd)
err.output = output
raise err
return output
def out_and_err(command, input=None, shell=False, env=None):
"""Run a shell command, and return stderr and stdout as string.
If the command returns nonzero, raise CalledProcessError.
:arg command: A list of commandline args
:arg input: Data to pipe to stdin. Omit for none.
Remaining args have the same meaning as for Popen.
"""
process = Popen(command,
stdout=PIPE,
stdin=PIPE,
stderr=PIPE,
shell=shell,
env=env)
out, err = process.communicate(input=input)
status = process.poll(
) # same as in check_output(), though wait() sounds better
if status:
error = CalledProcessError(status, command)
error.output = out
print('stdout output was:')
print(out)
print('stderr output was:')
print(err)
raise error
return out, err
def check_media_file(self, filename):
valid_media_msg = '%s => OK' % filename
invalid_media_msg = '%s => INVALID' % filename
try:
# cmd = self.validate_cmd.format(filename)
cmd = self.validate_cmd
log.debug('cmd: %s %s', cmd, filename)
log.info('verifying {0}'.format(filename))
# capturing stderr to stdout because ffprobe prints to stderr in all cases
# Python 2.7+
#subprocess.check_output(cmd.split() + [filename], stderr=subprocess.STDOUT)
proc = subprocess.Popen(cmd.split() + [filename], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
(stdout, _) = proc.communicate()
returncode = proc.wait()
if returncode != 0 or (stdout is not None and 'Error' in stdout):
_ = CalledProcessError(returncode, cmd)
_.output = stdout
raise _
print(valid_media_msg)
except CalledProcessError as _:
if self.verbose > 2:
print(_.output)
if self.skip_errors:
print(invalid_media_msg)
self.failed = True
return False
die(invalid_media_msg)
def __run(self, *args, **kwargs):
_args = [i for i in args if i is not None]
argsLog = [self.__hidePassw(i) for i in args if i is not None ]
logger.debug("Shell _run CMD: " + " ". join(argsLog))
process = Popen(
_args, stdout = PIPE, stderr = PIPE, close_fds = True, **kwargs)
_stdout, _stderr = process.communicate()
retCode = process.returncode
logger.debug("Shell _run retCode: %d", retCode)
stdout = str(_stdout).replace("\\n", "\n").strip('\n\' ')
stdout = _stdout.decode("utf-8")
if stdout.startswith("b'\n") or stdout.startswith('b"\n'):
stdout = stdout[4:-1]
logger.debug(" stdout:'%s'", stdout)
stderr = _stderr.decode("utf-8").replace("\\n", "\n").lstrip('\n').lstrip("'")
logger.debug(" stderr:'%s'", stderr)
if retCode or ((len(stderr) > 0) and ('Error' in stderr)) or ((retCode == 4) and ('<Exception>' in stdout)):
exception = CalledProcessError(process.returncode, repr(args))
err_msg = "retCode: "+str(retCode)+"\n'"+str(''.join([str(_f) for _f in [stderr] if _f]))
if (retCode == 4) and ('<Exception>' in stdout):
err_msg += str(''.join([_f for _f in [stdout] if _f]))
exception.output = err_msg +"'"
logger.debug("exception.output:'%s'", err_msg)
#raise Error('1001', err=str(err_msg)) # Unnecessary noise. The problem will be reported later in the test case result.
return stdout, stderr
def check_output(*popenargs, **kwargs):
r"""Run command with arguments and return its output as a byte string.
If the exit code was non-zero it raises a CalledProcessError. The
CalledProcessError object will have the return code in the returncode
attribute and output in the output attribute.
The arguments are the same as for the Popen constructor. Example:
>>> check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
The stdout argument is not allowed as it is used internally.
To capture standard error in the result, use stderr=STDOUT.
>>> check_output(["/bin/sh", "-c",
... "ls -l non_existent_file ; exit 0"],
... stderr=STDOUT)
'ls: non_existent_file: No such file or directory\n'
"""
from subprocess import PIPE, CalledProcessError, Popen
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
err = CalledProcessError(retcode, cmd)
err.output = output
raise err
return output
def __run(self, *args, **kwargs):
_args = [i for i in args if i is not None]
argsLog = [self.__hidePassw(i) for i in args if i is not None]
logging.debug("Shell _run CMD: " + " ".join(argsLog))
process = Popen(_args,
stdout=PIPE,
stderr=PIPE,
close_fds=True,
**kwargs)
stdout, stderr = process.communicate()
retCode = process.returncode
logging.debug("Shell _run retCode: %d", retCode)
logging.debug(" stdout:'%s'", stdout)
logging.debug(" stderr:'%s'", stderr)
if retCode or ((len(stderr) > 0) and
('Error' in stderr)) or ((retCode == 4) and
('<Exception>' in stdout)):
exception = CalledProcessError(process.returncode, repr(args))
err_msg = "retCode: " + str(retCode) + "\n'" + str(''.join(
filter(None, [stderr])))
if (retCode == 4) and ('<Exception>' in stdout):
err_msg += str(''.join(filter(None, [stdout])))
exception.output = err_msg + "'"
logging.debug("exception.output:'%s'", err_msg)
raise Error('1001', err=str(err_msg))
return stdout, stderr
def check_media_file(self, filename):
valid_media_msg = '%s => OK' % filename
invalid_media_msg = '%s => INVALID' % filename
cmd = self.validate_cmd
log.debug('cmd: %s %s', cmd, filename)
log.info('verifying {0}'.format(filename))
# cmd = self.validate_cmd.format(filename)
try:
# capturing stderr to stdout because ffprobe prints to stderr in all cases
# Python 2.7+
#subprocess.check_output(cmd.split() + [filename], stderr=subprocess.STDOUT)
proc = subprocess.Popen(cmd.split() + [filename],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
(stdout, _) = proc.communicate()
returncode = proc.wait()
if returncode != 0 or (stdout is not None and 'Error' in stdout):
_ = CalledProcessError(returncode, cmd)
_.output = stdout
raise _
print(valid_media_msg)
except CalledProcessError as _:
if self.verbose > 2:
print(_.output)
if self.skip_errors:
print(invalid_media_msg)
self.failed = True
return False
die(invalid_media_msg)
except OSError as _:
die("OSError: '{0}' when running '{1} {2}'", _, cmd, filename)
def test_execute_error_quiet(self, check_output, mocker):
error = CalledProcessError(1, "cmd")
error.output = "some output"
check_output.side_effect = error
with pytest.raises(BumprError):
mocker.patch("builtins.print")
execute("some failed command")
def test_execute_error_quiet(self, check_call, check_output):
error = CalledProcessError(1, 'cmd')
error.output = 'some output'
check_output.side_effect = error
with pytest.raises(BumprError):
to_patch = '{0}.print'.format('builtins' if IS_PY3 else '__builtin__')
with patch(to_patch):
execute('some failed command')
def test_execute_error_quiet(self, check_output, mocker):
error = CalledProcessError(1, 'cmd')
error.output = 'some output'
check_output.side_effect = error
with pytest.raises(BumprError):
to_patch = '{0}.print'.format(
'builtins' if IS_PY3 else '__builtin__')
mocker.patch(to_patch)
execute('some failed command')
def log_check_call(*args, **kwargs):
kwargs['record_output'] = True
retcode, output = log_call(*args, **kwargs)
if retcode != 0:
cmd = kwargs.get('args')
if cmd is None:
cmd = args[0]
e = CalledProcessError(retcode, cmd)
e.output = output
raise e
return 0
def check_output(*args, **kwds):
process = Popen(stdout=PIPE, *args, **kwds)
output, _ = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwds.get("args")
if cmd is None:
cmd = args[0]
error = CalledProcessError(retcode, cmd)
error.output = output
raise error
return output
def check_installed(arguments, stdin=None, stderr=None, shell=False):
ps = Popen(arguments, shell=shell, stdin=None, stdout=PIPE, stderr=STDOUT)
cmd_output = ps.communicate()[0]
returncode = ps.returncode
if returncode != 0:
error_cmd = CalledProcessError(returncode, arguments[0])
error_cmd.output = cmd_output
raise error_cmd
else:
return cmd_output
def check_output(*args, **kwds):
process = Popen(stdout=PIPE, *args, **kwds)
output, _ = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwds.get("args")
if cmd is None:
cmd = args[0]
error = CalledProcessError(retcode, cmd)
error.output = output
raise error
return output
def mockreturn(*args, **kwargs):
if args == (['task', 'stats'],):
output = b"""
Category Data
-------- ----
Pending 0
Waiting 0"""
return output
elif args == (['task', 'overdue'],):
output = b'No matches.'
e = CalledProcessError(1, 'task')
e.output = output
raise e
def check_output(*popenargs, **kwargs):
"""Run command with arguments and return its output as a byte string."""
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
error = CalledProcessError(retcode, cmd)
error.output = output
raise error
return output
def call_for_stderr(command, *args, **kwargs):
kwargs["stderr"] = _subprocess.PIPE
proc = start_process(command, *args, **kwargs)
output = proc.communicate()[1].decode("utf-8")
exit_code = proc.poll()
if exit_code != 0:
error = CalledProcessError(exit_code, proc.command_string)
error.output = output
raise error
return output
def call_for_stderr(command, *args, **kwargs):
kwargs["stderr"] = _subprocess.PIPE
proc = start_process(command, *args, **kwargs)
output = proc.communicate()[1].decode("utf-8")
exit_code = proc.poll()
if exit_code != 0:
error = CalledProcessError(exit_code, proc.command_string)
error.output = output
raise error
return output
def check_output(command, **kargs):
kargs['stdout'] = out = io.BytesIO()
kargs['stderr'] = err = io.BytesIO()
ps = SubProcess(command, **kargs)
ps.wait()
if ps.returncode:
ex = CalledProcessError(ps.returncode, str.join(' ', ps.command))
ex.output = out.getvalue()
ex.err = err.getvalue()
raise ex
return out.getvalue()
def spawn(*args, **kwargs):
"""Runs a program, waits for its termination and returns its stdout
This function is similar to python 2.7's subprocess.check_output,
but is favored due to python 2.6 compatibility.
The arguments may be:
spawn(string)
spawn(command, arg1, arg2...)
spawn([command, arg1, arg2])
The string will be run through a shell, otherwise the command is executed
directly.
The keyword argument "decode" determines if the output shall be decoded
with the encoding '%s'.
Further keyword arguments are passed to Popen.
""" % (ENCODING, )
if len(args) == 1:
popen_arguments = args[0]
shell = isinstance(popen_arguments, str)
else:
popen_arguments = args
shell = False
if 'decode' in kwargs:
do_decode = kwargs['decode']
del kwargs['decode']
else:
do_decode = True
if 'stdout' not in kwargs:
kwargs['stdout'] = PIPE
if 'shell' not in kwargs:
kwargs['shell'] = shell
process = Popen(popen_arguments, **kwargs)
stdout, stderr = process.communicate()
return_value = process.poll()
if return_value:
error = CalledProcessError(return_value, popen_arguments[0])
error.output = stdout
raise error
if do_decode:
return stdout.decode(ENCODING)
else:
return stdout
def __run(self, *args, **kwargs):
args = [i for i in args if i is not None]
logging.debug("CMD: " + " ".join(args))
process = Popen(args,
stdout=kwargs.pop('stdout', PIPE),
stderr=kwargs.pop('stderr', PIPE),
close_fds=kwargs.pop('close_fds', True),
**kwargs)
stdout, stderr = process.communicate()
if process.returncode:
exception = CalledProcessError(process.returncode, repr(args))
exception.output = ''.join(filter(None, [stdout, stderr]))
raise Error('1001', err=exception.output)
return stdout
def __run(self, *args, **kwargs):
_args = [i for i in args if i is not None]
argsLog = [self.__hidePassw(i) for i in args if i is not None ]
logging.debug("CMD: " + " ". join(argsLog))
process = Popen(
_args, stdout=kwargs.pop('stdout', PIPE),
stderr=kwargs.pop('stderr', PIPE),
close_fds=kwargs.pop('close_fds', True), **kwargs)
stdout, stderr = process.communicate()
if process.returncode:
exception = CalledProcessError(
process.returncode, repr(args))
exception.output = ''.join(filter(None, [stdout, stderr]))
raise Error('1001', err=exception.output)
return stdout
def check_output(arguments, stdin=None, stderr=None, shell=False):
temp_f = mkstemp()
returncode = call(arguments, stdin=stdin, stdout=temp_f[0], stderr=stderr, shell=shell)
close(temp_f[0])
file_o = open(temp_f[1], 'r')
cmd_output = file_o.read()
file_o.close()
remove(temp_f[1])
if returncode != 0:
error_cmd = CalledProcessError(returncode, arguments[0])
error_cmd.output = cmd_output
raise error_cmd
else:
return cmd_output
def check_output(arguments, stdin=None, stderr=None, shell=False):
temp_f = mkstemp()
returncode = call(arguments, stdin=stdin, stdout=temp_f[0], stderr=stderr, shell=shell)
close(temp_f[0])
file_o = open(temp_f[1], 'r')
cmd_output = file_o.read()
file_o.close()
remove(temp_f[1])
if returncode != 0:
error_cmd = CalledProcessError(returncode, arguments[0])
error_cmd.output = cmd_output
raise error_cmd
else:
return cmd_output
def __run(self, *args, **kwargs):
_args = [i for i in args if i is not None]
argsLog = [self.__hidePassw(i) for i in args if i is not None]
logging.debug("Shell _run CMD: " + " ".join(argsLog))
process = Popen(_args, stdout=PIPE, stderr=PIPE, close_fds=True, **kwargs)
stdout, stderr = process.communicate()
retCode = process.returncode
logging.debug("Shell _run retCode: %d", retCode)
logging.debug(" stdout:'%s'", stdout)
logging.debug(" stderr:'%s'", stderr)
if retCode or ((len(stderr) > 0) and ("Error" in stderr)):
exception = CalledProcessError(process.returncode, repr(args))
exception.output = "".join(filter(None, [stdout, stderr]))
logging.debug("exception.output:'%s'", exception.output)
raise Error("1001", err=repr(exception.output))
return stdout
def check_output(*args, **kwargs):
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
process = subprocess.Popen(stdout=subprocess.PIPE, *args, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = args[0]
error = CalledProcessError(retcode, cmd)
error.output = output
raise error
return output
def call_for_output(command, *args, **kwargs):
kwargs["stdout"] = _subprocess.PIPE
proc = start_process(command, *args, **kwargs)
output = proc.communicate()[0]
exit_code = proc.poll()
if exit_code not in (None, 0):
command_string = _command_string(command)
command_string = command_string.format(*args)
error = CalledProcessError(exit_code, command_string)
error.output = output
raise error
return output
def call_for_output(command, *args, **kwargs):
kwargs["stdout"] = _subprocess.PIPE
proc = start_process(command, *args, **kwargs)
output = proc.communicate()[0]
exit_code = proc.poll()
if exit_code not in (None, 0):
command_string = _command_string(command)
command_string = command_string.format(*args)
error = CalledProcessError(exit_code, command_string)
error.output = output
raise error
return output
def call_for_output(command, *args, **kwargs):
kwargs["stdout"] = _subprocess.PIPE
proc = start_process(command, *args, **kwargs)
output = proc.communicate()[0]
exit_code = proc.poll()
# XXX I don't know if None is possible here
assert exit_code is not None
if exit_code not in (None, 0):
error = CalledProcessError(exit_code, proc.command_string)
error.output = output
raise error
return output
def __run(self, *args, **kwargs):
_args = [i for i in args if i is not None]
argsLog = [self.__hidePassw(i) for i in args if i is not None]
logging.debug("Shell _run CMD: " + " ".join(argsLog))
process = Popen(_args,
stdout=kwargs.pop('stdout', PIPE),
stderr=kwargs.pop('stderr', PIPE),
close_fds=kwargs.pop('close_fds', True),
**kwargs)
stdout, stderr = process.communicate()
retCode = process.returncode
if retCode:
logging.debug("Shell _run retCode:: %d, stdout:'%s', stderr:'%s'",
retCode, stdout, stderr)
exception = CalledProcessError(process.returncode, repr(args))
exception.output = ''.join(filter(None, [stdout, stderr]))
raise Error('1001', err=repr(exception.output))
return stdout
def _check_output(*popenargs, **kwargs):
# Copyright (c) 2003-2005 by Peter Astrand <*****@*****.**>
#
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/2.4/license for licensing details.
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, _ = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
e = CalledProcessError(retcode, cmd)
e.output = output
raise e
return output
def execute_php_export(command, articleid):
print "PHP Exporting article {0}:\n\t`$ {1}\n`".format(articleid, command)
args = command.split()
process = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
pout, perr = process.communicate()
code = process.poll()
if code or pout or perr:
output = pout + perr
try:
raise CalledProcessError(
code, command, output=output
)
except Exception:
error = CalledProcessError(code, command)
error.output = output
raise error
print "PHP export of article {0} complete\n".format(articleid)
return code
def _check_output(*popenargs, **kwargs):
# Copyright (c) 2003-2005 by Peter Astrand <*****@*****.**>
#
# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/2.4/license for licensing details.
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, _ = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
e = CalledProcessError(retcode, cmd)
e.output = output
raise e
return output
def log_check_call(*args, **kwargs):
log = kwargs.pop('log', logging.debug)
kwargs['stdout'] = PIPE
kwargs['stderr'] = STDOUT
kwargs['env'] = env = kwargs.get('env', os.environ.copy())
env['PYTHONUNBUFFERED'] = '1'
p = Popen(*args, **kwargs)
output = []
for line in iter(p.stdout.readline, ''):
log(line.rstrip())
output.append(line)
retcode = p.wait()
if retcode != 0:
cmd = kwargs.get('args') or args[0]
e = CalledProcessError(retcode, cmd)
e.output = ''.join(output)
raise e
return 0
def check_output(*popenargs, **kwargs):
r"""Run command with arguments and return its output as a byte string.
Backported from Python 2.7 as it's implemented as pure python on stdlib.
>>> check_output(['/usr/bin/python', '--version'])
Python 2.6.2
"""
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, _ = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
error = CalledProcessError(retcode, cmd)
error.output = output
raise error
return output
def check_output(*popenargs, **kwargs):
"""
Run command with arguments and return its output as a byte string.
Backported from Python 2.7 as it's implemented as pure python on stdlib.
>>> check_output(['/usr/bin/python', '--version'])
Python 2.6.2
"""
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
error = CalledProcessError(retcode, cmd)
error.output = output
raise error
return output
def check_output(command,
cwd=None,
shell=False,
env=None,
stdin=__sentinel__,
stderr=__sentinel__,
preexec_fn=None,
use_texpath=True,
show_window=False):
'''
Takes a command to be passed to subprocess.Popen.
Returns the output if the command was successful.
By default stderr is redirected to stdout, so this will return any output
to either stream. This can be changed by calling execute_command with
stderr set to subprocess.PIPE or any other valid value.
Raises CalledProcessError if the command returned a non-zero value
Raises OSError if the executable is not found
This is pretty much identical to subprocess.check_output(), but
implemented here since it is unavailable in Python 2.6's library.
'''
returncode, stdout, stderr = execute_command(command,
cwd=cwd,
shell=shell,
env=env,
stdin=stdin,
stderr=stderr,
preexec_fn=preexec_fn,
use_texpath=use_texpath,
show_window=show_window)
if returncode:
e = CalledProcessError(returncode, command)
e.output = stdout
e.stderr = stderr
raise e
return stdout
def check_output(command, cwd=None, shell=False, env=None,
stdin=__sentinel__, stderr=__sentinel__,
preexec_fn=None, use_texpath=True,
show_window=False):
'''
Takes a command to be passed to subprocess.Popen.
Returns the output if the command was successful.
By default stderr is redirected to stdout, so this will return any output
to either stream. This can be changed by calling execute_command with
stderr set to subprocess.PIPE or any other valid value.
Raises CalledProcessError if the command returned a non-zero value
Raises OSError if the executable is not found
This is pretty much identical to subprocess.check_output(), but
implemented here since it is unavailable in Python 2.6's library.
'''
returncode, stdout, stderr = execute_command(
command,
cwd=cwd,
shell=shell,
env=env,
stdin=stdin,
stderr=stderr,
preexec_fn=preexec_fn,
use_texpath=use_texpath,
show_window=show_window
)
if returncode:
e = CalledProcessError(
returncode,
command
)
e.output = stdout
e.stderr = stderr
raise e
return stdout
def __run(self, *args, **kwargs):
_args = [i for i in args if i is not None]
argsLog = [self.__hidePassw(i) for i in args if i is not None ]
logging.debug("Shell _run CMD: " + " ". join(argsLog))
process = Popen(
_args, stdout = PIPE, stderr = PIPE, close_fds = True, **kwargs)
stdout, stderr = process.communicate()
retCode = process.returncode
logging.debug("Shell _run retCode: %d", retCode)
logging.debug(" stdout:'%s'", stdout)
logging.debug(" stderr:'%s'", stderr)
if retCode or ((len(stderr) > 0) and ('Error' in stderr)) or ((retCode == 4) and ('<Exception>' in stdout)):
exception = CalledProcessError(process.returncode, repr(args))
err_msg = "retCode: "+str(retCode)+"\n'"+str(''.join(filter(None, [stderr])))
if (retCode == 4) and ('<Exception>' in stdout):
err_msg += str(''.join(filter(None, [stdout])))
exception.output = err_msg +"'"
logging.debug("exception.output:'%s'", err_msg)
raise Error('1001', err=str(err_msg))
return stdout, stderr
def call_for_stderr(command, *args, **kwargs):
if "quiet" in kwargs or "output" in kwargs or "stdout" in kwargs:
raise PlanoException("Illegal output options")
kwargs["stderr"] = _subprocess.PIPE
proc = start_process(command, *args, **kwargs)
output = proc.communicate()[1]
if output is None:
output = b""
output = output.decode("utf-8")
exit_code = proc.poll()
if exit_code != 0:
error = CalledProcessError(exit_code, proc.command_string)
error.output = output
raise error
return output
def out_and_err(command, input=None, shell=False, env=None):
"""Run a shell command, and return stderr and stdout as string.
If the command returns nonzero, raise CalledProcessError.
:arg command: A list of commandline args
:arg input: Data to pipe to stdin. Omit for none.
Remaining args have the same meaning as for Popen.
"""
process = Popen(command,
stdout=PIPE,
stdin=PIPE,
stderr=PIPE,
shell=shell,
env=env)
out, err = process.communicate(input=input)
status = process.poll() # same as in check_output(), though wait() sounds better
if status:
error = CalledProcessError(status, command)
error.output = out
raise error
return out, err
def check_output(popenargs, **kwargs):
"""Runs a program, waits for its termination and returns its output
This function is functionally identical to python 2.7's subprocess.check_output,
but is favored due to python 2.6 compatibility.
Will be run through a shell if `popenargs` is a string, otherwise the command
is executed directly.
The keyword argument `decode` determines if the output shall be decoded
with the encoding UTF-8.
Further keyword arguments are passed to Popen.
"""
do_decode = kwargs.pop('decode', True)
kwargs.setdefault('stdout', PIPE)
kwargs.setdefault('shell', isinstance(popenargs, str))
if 'stderr' in kwargs:
with Popen23(popenargs, **kwargs) as process:
stdout, _ = process.communicate()
else:
with open(devnull, mode='w', encoding="utf-8") as fd_devnull:
with Popen23(popenargs, stderr=fd_devnull, **kwargs) as process:
stdout, _ = process.communicate()
if process.returncode != 0:
error = CalledProcessError(process.returncode, popenargs)
error.output = stdout
raise error
if do_decode and stdout is not None:
stdout = stdout.decode(ENCODING)
return stdout
def check_output(popenargs, **kwargs):
"""Runs a program, waits for its termination and returns its output
This function is functionally identical to python 2.7's subprocess.check_output,
but is favored due to python 2.6 compatibility.
Will be run through a shell if `popenargs` is a string, otherwise the command
is executed directly.
The keyword argument `decode` determines if the output shall be decoded
with the encoding UTF-8.
Further keyword arguments are passed to Popen.
"""
do_decode = kwargs.pop('decode', True)
kwargs.setdefault('stdout', PIPE)
kwargs.setdefault('shell', isinstance(popenargs, str))
if 'stderr' in kwargs:
process = Popen(popenargs, **kwargs)
stdout, _ = process.communicate()
else:
with open(devnull, mode='w') as fd_devnull:
process = Popen(popenargs, stderr=fd_devnull, **kwargs)
stdout, _ = process.communicate()
if process.returncode != 0:
error = CalledProcessError(process.returncode, popenargs)
error.output = stdout
raise error
if do_decode and stdout is not None:
stdout = stdout.decode(ENCODING)
return stdout
def oscap(profile=None):
# If FIFO exists, delete it
try:
unlink(FIFO_PATH)
except OSError:
pass
# Create an unique FIFO file
mkfifo(FIFO_PATH, 0666)
try:
cmd = [OSCAP_BIN, arg_module, 'eval', '--results', FIFO_PATH]
if profile:
cmd.extend(["--profile", profile])
if arg_xccdfid:
for arg_id in arg_xccdfid:
cmd.extend(["--xccdf-id", arg_id])
if arg_ovalid:
for arg_id in arg_ovalid:
cmd.extend(["--oval-id", arg_id])
if arg_dsid:
for arg_id in arg_dsid:
cmd.extend(["--datastream-id", arg_id])
if arg_cpe:
cmd.extend(["--cpe", arg_cpe])
cmd.append(arg_file)
if debug:
print("\nCMD: '{0}'".format(' '.join(cmd)))
DEVNULL = open(devnull, 'wb')
ps = Popen(cmd, shell=False, stdout=DEVNULL, stderr=None)
except CalledProcessError as error:
# return code 2 means that some checks failed
if error.returncode != 2:
# output = error.output
print(
"{0} Executing profile \"{1}\" of file \"{2}\": Return Code: \"{3}\" Error: \"{4}\"."
.format(OSCAP_LOG_ERROR, profile, arg_file, error.returncode,
error.output.replace('\r', '').split("\n")[0]))
unlink(FIFO_PATH)
return
try:
content_filename = arg_file.split('/')[-1]
# Generate scan ID: agent_id + epoch
try:
if isdir('ruleset'):
agent_id = '000'
else:
with open('etc/client.keys', 'r') as f:
first_line = f.readline()
agent_id = first_line.split(' ')[0]
except:
agent_id = randrange(1, 9999)
scan_id = "{0}{1}".format(agent_id, int(time()))
if arg_module == 'xccdf':
ps_xsltproc = Popen([XSLT_BIN, TEMPLATE_XCCDF, FIFO_PATH],
stdin=None,
stdout=PIPE,
stderr=STDOUT)
ps.wait()
output = ps_xsltproc.communicate()[0]
ps_xsltproc.wait()
returncode = ps_xsltproc.returncode
if returncode != 0:
error_cmd = CalledProcessError(
returncode, [XSLT_BIN, TEMPLATE_XCCDF, FIFO_PATH])
error_cmd.output = output
raise error_cmd
else:
if version_info[0] >= 3:
output = output.decode('utf-8', 'backslashreplace')
for line in output.split("\n"):
if not line:
continue
# Adding file
if 'msg: "xccdf-overview"' in line:
new_line = line.replace(
'oscap: msg: "xccdf-overview",',
'oscap: msg: "xccdf-overview", scan-id: "{0}", content: "{1}",'
.format(scan_id, content_filename))
else:
new_line = line.replace(
'oscap: msg: "xccdf-result",',
'oscap: msg: "xccdf-result", scan-id: "{0}", content: "{1}",'
.format(scan_id, content_filename))
print(new_line)
else:
ps_xsltproc = Popen([XSLT_BIN, TEMPLATE_OVAL, FIFO_PATH],
stdin=None,
stdout=PIPE,
stderr=STDOUT)
ps.wait()
output = ps_xsltproc.communicate()[0]
ps_xsltproc.wait()
returncode = ps_xsltproc.returncode
if version_info[0] >= 3:
output = output.decode('utf-8', 'backslashreplace')
total = 0
total_KO = 0
for line in output.split("\n"):
if not line:
continue
total += 1
# Adding file
new_line = line.replace(
'oscap: msg: "oval-result"',
'oscap: msg: "oval-result", scan-id: "{0}", content: "{1}"'
.format(scan_id, content_filename))
class1 = ['class: "compliance"', 'class: "inventory"']
class2 = ['class: "vulnerability"', 'class: "patch"']
if any(x in line for x in class1):
if 'result: "false"' in line:
total_KO += 1
new_line = new_line.replace('result: "false"',
'result: "fail"')
elif 'result: "true"' in line:
new_line = new_line.replace('result: "true"',
'result: "pass"')
elif any(x in line for x in class2):
if 'result: "true"' in line:
total_KO += 1
new_line = new_line.replace('result: "true"',
'result: "fail"')
elif 'result: "false"' in line:
new_line = new_line.replace('result: "false"',
'result: "pass"')
new_line = new_line.replace('", class: "',
'", profile-title: "')
print(new_line)
score = (float((total - total_KO)) / float(total)) * 100
# summary
print(
'oscap: msg: "oval-overview", scan-id: "{0}", content: "{1}", score: "{2:.2f}".'
.format(scan_id, content_filename, score))
except CalledProcessError as error:
print(
"{0} Formatting data for profile \"{1}\" of file \"{2}\": Return Code: \"{3}\" Error: \"{4}\"."
.format(OSCAP_LOG_ERROR, profile, arg_file, error.returncode,
error.output.replace('\r', '').split("\n")[0]))
unlink(FIFO_PATH)
def check_output(*popenargs, **kwargs):
r"""Run command with arguments and return its output as a byte string.
If the exit code was non-zero it raises a CalledProcessError. The
CalledProcessError object will have the return code in the returncode
attribute and output in the output attribute.
The arguments are the same as for the Popen constructor. Example:
>>> check_output(["ls", "-l", "/dev/null"]) #doctest: +ELLIPSIS
'crw-rw-rw- 1 root wheel 3...
The stdout argument is not allowed as it is used internally.
To capture standard error in the result, use stderr=STDOUT.
>>> check_output(["/bin/sh", "-c",
... "ls -l non_existent_file ; exit 0"],
... stderr=STDOUT)
'ls: non_existent_file: No such file or directory\n'
Calling check_output without the ignore_404 keyword argument
will raise a CalledProcessError if wkhtmltopdf exits with a non-zero code
>>> check_output(['wkhtmltopdf', #doctest: +ELLIPSIS
... '--quiet',
... '--encoding', 'utf8',
... os.getenv('WKHTML_IN'), os.getenv('WKHTML_OUT')])
Traceback (most recent call last):
...
CalledProcessError...
Calling check_output WITH the ignore_404 keyword will not raise
the CalledProcessError, but only if the error == ContentNotFoundError
>>> check_output(['/usr/local/bin/wkhtmltopdf',
... '--quiet',
... '--encoding', 'utf8',
... os.getenv('WKHTML_IN'), os.getenv('WKHTML_OUT')],
... env={'ignore_404': True})
''
Calling check_output WITH the ignore_404 keyword should still
raise a CalledProcessError if the error != ContentNotFoundError
>>> check_output(['/usr/local/bin/wkhtmltopdf', #doctest: +ELLIPSIS
... '--blaa',
... '--encoding', 'utf8',
... os.getenv('WKHTML_IN'), os.getenv('WKHTML_OUT')],
... env={'ignore_404': True})
Traceback (most recent call last):
...
CalledProcessError...
"""
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
if kwargs.get('env'):
ignore_404 = kwargs['env'].pop('ignore_404', False)
else:
ignore_404 = False
kwargs.setdefault('stderr', PIPE)
process = Popen(stdout=PIPE, *popenargs, **kwargs)
output, error_message = process.communicate()
retcode = process.poll()
if retcode:
if error_message and ignore_404:
if 'ContentNotFoundError' in str(error_message):
return output
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
error = CalledProcessError(retcode, cmd)
# Add the output attribute to CalledProcessError, which
# doesn't exist until Python 2.7.
error.output = output
raise error
return output
