def start(args, stdin=None, stdout=None, stderr=None, cwd=None, env=None,
sudo=False, setsid=False, nice=None, ioclass=None, ioclassdata=None,
reset_cpu_affinity=True):
"""
Starts a command and return it. The caller is responsible for communicating
with the commmand, waiting for it, and if needed, terminating it.
args are always logged when command starts. If args contain sensitive
information that should not be logged, such as passwords, they must be
wrapped with ProtectedPassword.
Arguments:
args (list): Command arguments
stdin (file or int): file object or descriptor for sending data to the
child process stdin.
stdout (file or int): file object or descriptor for receiving data from
the child process stdout.
stderr (file or int): file object or descriptor for receiving data from
the child process stderr.
cwd (str): working directory for the child process
env (dict): environment of the new child process
sudo (bool): if set to True, run the command via sudo
nice (int): if not None, run the command via nice command with the
specified nice value
ioclass (int): if not None, run the command with the ionice command
using specified ioclass value.
ioclassdata (int): if ioclass is set, the scheduling class data. 0-7
are valid data (priority levels).
reset_cpu_affinity (bool): Run the command via the taskset command,
allowing the child process to run on all cpus (default True).
Returns:
subprocess.Popen instance or commands.PrivilegedPopen if sudo is True.
Raises:
OSError if the command could not start.
"""
args = cmdutils.wrap_command(
args,
with_ioclass=ioclass,
ioclassdata=ioclassdata,
with_nice=nice,
with_setsid=setsid,
with_sudo=sudo,
reset_cpu_affinity=reset_cpu_affinity,
)
log.debug(cmdutils.command_log_line(args, cwd=cwd))
args = [password.unprotect(a) for a in args]
cmd_class = PrivilegedPopen if sudo else subprocess.Popen
return cmd_class(
args,
cwd=cwd,
stdin=stdin,
stdout=stdout,
stderr=stderr,
env=env)
def _simple_exec_cmd(command,
env=None,
nice=None,
ioclass=None,
stdin=None,
stdout=None,
stderr=None):
command = wrap_command(command,
with_ioclass=ioclass,
ioclassdata=None,
with_nice=nice,
with_setsid=False,
with_sudo=False,
reset_cpu_affinity=True)
logging.debug(cmdutils.command_log_line(command, cwd=None))
p = subprocess.Popen(command,
close_fds=True,
cwd=None,
env=env,
stdin=stdin,
stdout=stdout,
stderr=stderr)
return p
def start(args, stdin=None, stdout=None, stderr=None, cwd=None, env=None,
sudo=False, setsid=False, nice=None, ioclass=None, ioclassdata=None,
reset_cpu_affinity=True):
"""
Starts a command and return it. The caller is responsible for communicating
with the commmand, waiting for it, and if needed, terminating it.
args are always logged when command starts. If args contain sensitive
information that should not be logged, such as passwords, they must be
wrapped with ProtectedPassword.
Arguments:
args (list): Command arguments
stdin (file or int): file object or descriptor for sending data to the
child process stdin.
stdout (file or int): file object or descriptor for receiving data from
the child process stdout.
stderr (file or int): file object or descriptor for receiving data from
the child process stderr.
cwd (str): working directory for the child process
env (dict): environment of the new child process
sudo (bool): if set to True, run the command via sudo
nice (int): if not None, run the command via nice command with the
specified nice value
ioclass (int): if not None, run the command with the ionice command
using specified ioclass value.
ioclassdata (int): if ioclass is set, the scheduling class data. 0-7
are valid data (priority levels).
reset_cpu_affinity (bool): Run the command via the taskset command,
allowing the child process to run on all cpus (default True).
Returns:
subprocess.Popen instance or commands.PrivilegedPopen if sudo is True.
Raises:
OSError if the command could not start.
"""
args = cmdutils.wrap_command(
args,
with_ioclass=ioclass,
ioclassdata=ioclassdata,
with_nice=nice,
with_setsid=setsid,
with_sudo=sudo,
reset_cpu_affinity=reset_cpu_affinity,
)
log.debug(cmdutils.command_log_line(args, cwd=cwd))
args = [password.unprotect(a) for a in args]
cmd_class = PrivilegedPopen if sudo else subprocess.Popen
return cmd_class(
args,
cwd=cwd,
stdin=stdin,
stdout=stdout,
stderr=stdout,
env=env)
def execCmd(command,
sudo=False,
cwd=None,
data=None,
raw=False,
printable=None,
env=None,
nice=None,
ioclass=None,
ioclassdata=None,
setsid=False,
execCmdLogger=logging.root,
resetCpuAffinity=True):
"""
Executes an external command, optionally via sudo.
"""
command = cmdutils.wrap_command(command,
with_ioclass=ioclass,
ioclassdata=ioclassdata,
with_nice=nice,
with_setsid=setsid,
with_sudo=sudo,
reset_cpu_affinity=resetCpuAffinity)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug(command_log_line(printable, cwd=cwd))
p = subprocess.Popen(command,
close_fds=True,
cwd=cwd,
env=env,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
with terminating(p):
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = b""
execCmdLogger.debug(retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def execCmd(command, sudo=False, cwd=None, data=None, raw=False,
printable=None, env=None, sync=True, nice=None, ioclass=None,
ioclassdata=None, setsid=False, execCmdLogger=logging.root,
deathSignal=None, resetCpuAffinity=True):
"""
Executes an external command, optionally via sudo.
IMPORTANT NOTE: the new process would receive `deathSignal` when the
controlling thread dies, which may not be what you intended: if you create
a temporary thread, spawn a sync=False sub-process, and have the thread
finish, the new subprocess would die immediately.
"""
command = cmdutils.wrap_command(command, with_ioclass=ioclass,
ioclassdata=ioclassdata, with_nice=nice,
with_setsid=setsid, with_sudo=sudo,
reset_cpu_affinity=resetCpuAffinity)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug(command_log_line(printable, cwd=cwd))
extra = {}
extra['stderr'] = subprocess.PIPE
extra['stdout'] = subprocess.PIPE
if deathSignal is not None:
extra['deathSignal'] = deathSignal
p = CPopen(command, close_fds=True, cwd=cwd, env=env, **extra)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
with terminating(p):
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def exec_sync(cmds):
logging.debug(cmdutils.command_log_line(cmds))
p = Popen(
cmds, close_fds=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
logging.debug(cmdutils.retcode_log_line(p.returncode, err=err))
return p.returncode, out, err
def _simple_exec_cmd(command, env=None, nice=None, ioclass=None,
stdin=None, stdout=None, stderr=None):
command = wrap_command(command, with_ioclass=ioclass,
ioclassdata=None, with_nice=nice,
with_setsid=False, with_sudo=False,
reset_cpu_affinity=True)
logging.debug(cmdutils.command_log_line(command, cwd=None))
p = CPopen(command, close_fds=True, cwd=None, env=env,
stdin=stdin, stdout=stdout, stderr=stderr)
return p
def exec_sync_bytes(cmds):
logging.debug(cmdutils.command_log_line(cmds))
p = Popen(cmds,
close_fds=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = p.communicate()
logging.debug(cmdutils.retcode_log_line(p.returncode, err=err))
return p.returncode, out, err
def __init__(self, cmd, cwd=None):
self._lock = threading.Lock()
self._aborted = False
self._progress = 0.0
self._stdout = bytearray()
self._stderr = bytearray()
self.cmd = wrap_command(cmd,
with_nice=utils.NICENESS.HIGH,
with_ioclass=utils.IOCLASS.IDLE)
_log.debug(cmdutils.command_log_line(self.cmd, cwd=cwd))
self._command = CPopen(self.cmd, cwd=cwd, deathSignal=signal.SIGKILL)
self._stream = utils.CommandStream(self._command, self._recvstdout,
self._recvstderr)
def execCmd(command, sudo=False, cwd=None, data=None, raw=False,
printable=None, env=None, sync=True, nice=None, ioclass=None,
ioclassdata=None, setsid=False, execCmdLogger=logging.root,
resetCpuAffinity=True):
"""
Executes an external command, optionally via sudo.
"""
command = cmdutils.wrap_command(command, with_ioclass=ioclass,
ioclassdata=ioclassdata, with_nice=nice,
with_setsid=setsid, with_sudo=sudo,
reset_cpu_affinity=resetCpuAffinity)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug(command_log_line(printable, cwd=cwd))
p = subprocess.Popen(
command, close_fds=True, cwd=cwd, env=env,
stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
with terminating(p):
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def __init__(self, cmd, cwd=None):
self._lock = threading.Lock()
self._aborted = False
self._progress = 0.0
self._stdout = bytearray()
self._stderr = bytearray()
self.cmd = wrap_command(
cmd,
with_nice=utils.NICENESS.HIGH,
with_ioclass=utils.IOCLASS.IDLE)
_log.debug(cmdutils.command_log_line(self.cmd, cwd=cwd))
self._command = CPopen(self.cmd, cwd=cwd,
deathSignal=signal.SIGKILL)
self._stream = utils.CommandStream(
self._command, self._recvstdout, self._recvstderr)
def _start_process(self):
"""
Start the underlying process.
Raises:
`RuntimeError` if invoked more then once
"""
with self._lock:
if self._state == ABORTED:
raise exception.ActionStopped
if self._state != CREATED:
raise RuntimeError("Attempt to run an operation twice")
log.debug(cmdutils.command_log_line(self._cmd, cwd=self._cwd))
self._proc = compat.CPopen(self._cmd,
cwd=self._cwd,
stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
self._state = RUNNING
def _start_process(self):
"""
Start the underlying process.
Raises:
`RuntimeError` if invoked more then once
"""
with self._lock:
if self._state == ABORTED:
raise exception.ActionStopped
if self._state != CREATED:
raise RuntimeError("Attempt to run an operation twice")
log.debug(cmdutils.command_log_line(self._cmd, cwd=self._cwd))
self._proc = compat.CPopen(self._cmd,
cwd=self._cwd,
stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
self._state = RUNNING
def execCmd(command,
sudo=False,
cwd=None,
data=None,
raw=False,
printable=None,
env=None,
sync=True,
nice=None,
ioclass=None,
ioclassdata=None,
setsid=False,
execCmdLogger=logging.root,
deathSignal=None,
resetCpuAffinity=True):
"""
Executes an external command, optionally via sudo.
IMPORTANT NOTE: the new process would receive `deathSignal` when the
controlling thread dies, which may not be what you intended: if you create
a temporary thread, spawn a sync=False sub-process, and have the thread
finish, the new subprocess would die immediately.
"""
command = cmdutils.wrap_command(command,
with_ioclass=ioclass,
ioclassdata=ioclassdata,
with_nice=nice,
with_setsid=setsid,
with_sudo=sudo,
reset_cpu_affinity=resetCpuAffinity)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug(command_log_line(printable, cwd=cwd))
extra = {}
extra['stderr'] = subprocess.PIPE
extra['stdout'] = subprocess.PIPE
if deathSignal is not None:
extra['deathSignal'] = deathSignal
p = CPopen(command, close_fds=True, cwd=cwd, env=env, **extra)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
with terminating(p):
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
