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=0, childUmask=None):
"""
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.
"""
if ioclass is not None:
command = cmdutils.ionice(command, ioclass=ioclass,
ioclassdata=ioclassdata)
if nice is not None:
command = cmdutils.nice(command, nice=nice)
if setsid:
command = cmdutils.setsid(command)
if sudo:
command = cmdutils.sudo(command)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug("%s (cwd %s)", _list2cmdline(printable), cwd)
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal, childUmask=childUmask)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug("%s: <err> = %r; <rc> = %d",
"SUCCESS" if p.returncode == 0 else "FAILED",
err, p.returncode)
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=0, childUmask=None):
"""
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.
"""
if ioclass is not None:
command = cmdutils.ionice(command, ioclass=ioclass,
ioclassdata=ioclassdata)
if nice is not None:
command = cmdutils.nice(command, nice=nice)
if setsid:
command = cmdutils.setsid(command)
if sudo:
command = cmdutils.sudo(command)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug("%s (cwd %s)", _list2cmdline(printable), cwd)
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal, childUmask=childUmask)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug("%s: <err> = %r; <rc> = %d",
"SUCCESS" if p.returncode == 0 else "FAILED",
err, p.returncode)
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def execCmd(command, cwd=None, data=None, raw=False,
env=None, sync=True, deathSignal=0, childUmask=None):
"""
Executes an external command,
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.
"""
cmdline = repr(subprocess.list2cmdline(command))
logger.info("%s (cwd %s)", cmdline, cwd)
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal, childUmask=childUmask)
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
logger.debug("%s: <err> = %s; <rc> = %d",
{True: "SUCCESS", False: "FAILED"}[p.returncode == 0],
repr(err), p.returncode)
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, logErr=True,
printable=None, env=None, sync=True, nice=None, ioclass=None,
ioclassdata=None, setsid=False, execCmdLogger=logging.root,
deathSignal=0, childUmask=None):
"""
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.
"""
if ioclass is not None:
cmd = command
command = [ioniceCmdPath.cmd, '-c', str(ioclass)]
if ioclassdata is not None:
command.extend(("-n", str(ioclassdata)))
command = command + cmd
if nice is not None:
command = [niceCmdPath.cmd, '-n', str(nice)] + command
if setsid:
command = [setsidCmdPath.cmd] + command
if sudo:
command = [sudoCmdPath.cmd, SUDO_NON_INTERACTIVE_FLAG] + command
if not printable:
printable = command
cmdline = repr(subprocess.list2cmdline(printable))
execCmdLogger.debug("%s (cwd %s)", cmdline, cwd)
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal, childUmask=childUmask)
p = AsyncProc(p)
if not sync:
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug("%s: <err> = %s; <rc> = %d",
{True: "SUCCESS", False: "FAILED"}[p.returncode == 0],
repr(err), p.returncode)
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return (p.returncode, out, err)
def testEcho(self):
data = "Hello"
p = CPopen([EXT_ECHO, "-n", data])
out, err = p.communicate()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(out, data)
def testCat(self):
path = "/etc/passwd"
p = CPopen(["cat", path])
out, err = p.communicate()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
with open(path, "r") as f:
self.assertEquals(out, f.read())
def testStdin(self):
data = "Hello World"
p = CPopen(["cat"])
out, err = p.communicate(data)
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(out, data)
def testCwd(self):
cwd = "/proc"
p = CPopen(["python", "-c", "import os; print os.getcwd()"],
cwd=cwd)
out, err = p.communicate()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(out.strip(), cwd)
def execCmd(command, sudo=False, cwd=None, data=None, raw=False, logErr=True,
printable=None, env=None, sync=True, nice=None, ioclass=None,
ioclassdata=None, setsid=False, execCmdLogger=logging.root,
deathSignal=0):
"""
Executes an external command, optionally via sudo.
IMPORTANT NOTE: don't define a deathSignal when sync=False
"""
if ioclass is not None:
cmd = command
command = [constants.EXT_IONICE, '-c', str(ioclass)]
if ioclassdata is not None:
command.extend(("-n", str(ioclassdata)))
command = command + cmd
if nice is not None:
command = [constants.EXT_NICE, '-n', str(nice)] + command
if setsid:
command = [constants.EXT_SETSID] + command
if sudo:
command = [constants.EXT_SUDO, SUDO_NON_INTERACTIVE_FLAG] + command
if not printable:
printable = command
cmdline = repr(subprocess.list2cmdline(printable))
execCmdLogger.debug("%s (cwd %s)", cmdline, cwd)
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal)
p = AsyncProc(p)
if not sync:
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug("%s: <err> = %s; <rc> = %d",
{True: "SUCCESS", False: "FAILED"}[p.returncode == 0],
repr(err), p.returncode)
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return (p.returncode, out, err)
def testCloseOnExecStdin(self):
# Unset close-on-exec on stdin fd
data = "data"
with tempfile.NamedTemporaryFile() as f:
f.write(data)
f.flush()
set_close_on_exec(f.fileno())
p = CPopen(["cat", f.name], stdin=f.fileno(), stdout=PIPE)
out, err = p.communicate()
self.assertEqual(out, data)
def testUnicodeArg(self):
data = u'hello'
cmd = [EXT_ECHO, "-n", data]
p = CPopen(cmd)
out, err = p.communicate()
p2 = subprocess.Popen(cmd, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out2, err2 = p2.communicate()
self.assertEquals(out, out2)
def testPipeline(self):
# echo -n 'it works!' | cat
data = "it works!"
p2 = CPopen(["cat"], stdin=PIPE, stdout=PIPE)
try:
p1 = CPopen(["echo", "-n", data], stdin=PIPE, stdout=p2.stdin)
p1.wait()
finally:
out, err = p2.communicate()
self.assertEqual(data, out)
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=0, childUmask=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(cmdutils.command_log_line(printable, cwd=cwd))
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal, childUmask=childUmask)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(cmdutils.retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def testNonASCIIUnicodeArg(self):
data = u'\u05e9\u05dc\u05d5\u05dd'
# If the default encoding is not utf-8 the test *should* fail as non
# ascii conversion shouldn't work
if sys.getfilesystemencoding() != "UTF-8":
raise SkipTest("The default encoding isn't unicode")
cmd = [EXT_ECHO, "-n", data]
p = CPopen(cmd)
out, err = p.communicate()
p2 = subprocess.Popen(cmd, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out2, err2 = p2.communicate()
self.assertEquals(out, out2)
def testEnvUnicodeKey(self):
p = CPopen(["printenv"], env={u"\u05d0": "value"})
out, err = p.communicate()
self.assertEqual(out, "\xd7\x90=value\n")
def testEnvUnicodeValue(self):
p = CPopen(["printenv"], env={"key": u"\u05d0"})
out, err = p.communicate()
self.assertEqual(out, "key=\xd7\x90\n")
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=0,
childUmask=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(cmdutils.command_log_line(printable, cwd=cwd))
p = CPopen(command,
close_fds=True,
cwd=cwd,
env=env,
deathSignal=deathSignal,
childUmask=childUmask)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(cmdutils.retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def testUmaskChange(self):
p = CPopen(['sh', '-c', 'umask'], childUmask=0o007)
out, err = p.communicate()
self.assertEquals(out.splitlines()[0].strip(), '0007')
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=0,
childUmask=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.
"""
if ioclass is not None:
command = cmdutils.ionice(command,
ioclass=ioclass,
ioclassdata=ioclassdata)
if nice is not None:
command = cmdutils.nice(command, nice=nice)
if setsid:
command = cmdutils.setsid(command)
if sudo:
command = cmdutils.sudo(command)
# warning: the order of commands matters. If we add taskset
# after sudo, we'll need to configure sudoers to allow both
# 'sudo <command>' and 'sudo taskset <command>', which is
# impractical. On the other hand, using 'taskset sudo <command>'
# is much simpler and delivers the same end result.
if resetCpuAffinity and _USING_CPU_AFFINITY:
# only VDSM itself should be bound
command = cmdutils.taskset(command, _ANY_CPU)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug(cmdutils.command_log_line(printable, cwd=cwd))
p = CPopen(command,
close_fds=True,
cwd=cwd,
env=env,
deathSignal=deathSignal,
childUmask=childUmask)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(cmdutils.retcode_log_line(p.returncode, err=err))
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return p.returncode, out, err
def testEnv(self):
p = CPopen(["printenv"], env={"key": "value"})
out, err = p.communicate()
self.assertEqual(out, "key=value\n")
def execCmd(command,
sudo=False,
cwd=None,
data=None,
raw=False,
logErr=True,
printable=None,
env=None,
sync=True,
nice=None,
ioclass=None,
ioclassdata=None,
setsid=False,
execCmdLogger=logging.root,
deathSignal=0,
childUmask=None):
"""
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.
"""
if ioclass is not None:
cmd = command
command = [ioniceCmdPath.cmd, '-c', str(ioclass)]
if ioclassdata is not None:
command.extend(("-n", str(ioclassdata)))
command = command + cmd
if nice is not None:
command = [niceCmdPath.cmd, '-n', str(nice)] + command
if setsid:
command = [setsidCmdPath.cmd] + command
if sudo:
command = [sudoCmdPath.cmd, SUDO_NON_INTERACTIVE_FLAG] + command
if not printable:
printable = command
cmdline = repr(subprocess.list2cmdline(printable))
execCmdLogger.debug("%s (cwd %s)", cmdline, cwd)
p = CPopen(command,
close_fds=True,
cwd=cwd,
env=env,
deathSignal=deathSignal,
childUmask=childUmask)
p = AsyncProc(p)
if not sync:
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug("%s: <err> = %s; <rc> = %d", {
True: "SUCCESS",
False: "FAILED"
}[p.returncode == 0], repr(err), p.returncode)
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=0, childUmask=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.
"""
if ioclass is not None:
command = cmdutils.ionice(command, ioclass=ioclass,
ioclassdata=ioclassdata)
if nice is not None:
command = cmdutils.nice(command, nice=nice)
if setsid:
command = cmdutils.setsid(command)
if sudo:
command = cmdutils.sudo(command)
# warning: the order of commands matters. If we add taskset
# after sudo, we'll need to configure sudoers to allow both
# 'sudo <command>' and 'sudo taskset <command>', which is
# impractical. On the other hand, using 'taskset sudo <command>'
# is much simpler and delivers the same end result.
if resetCpuAffinity and _USING_CPU_AFFINITY:
# only VDSM itself should be bound
command = cmdutils.taskset(command, _ANY_CPU)
# Unsubscriptable objects (e.g. generators) need conversion
if not callable(getattr(command, '__getitem__', None)):
command = tuple(command)
if not printable:
printable = command
execCmdLogger.debug(cmdutils.command_log_line(printable, cwd=cwd))
p = CPopen(command, close_fds=True, cwd=cwd, env=env,
deathSignal=deathSignal, childUmask=childUmask)
if not sync:
p = AsyncProc(p)
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug(cmdutils.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,
logErr=True,
printable=None,
env=None,
sync=True,
nice=None,
ioclass=None,
ioclassdata=None,
setsid=False,
execCmdLogger=logging.root):
"""
Executes an external command, optionally via sudo.
"""
if ioclass is not None:
cmd = command
command = [constants.EXT_IONICE, '-c', str(ioclass)]
if ioclassdata is not None:
command.extend(("-n", str(ioclassdata)))
command = command + cmd
if nice is not None:
command = [constants.EXT_NICE, '-n', str(nice)] + command
if setsid:
command = [constants.EXT_SETSID] + command
if sudo:
command = [constants.EXT_SUDO, SUDO_NON_INTERACTIVE_FLAG] + command
if not printable:
printable = command
cmdline = repr(subprocess.list2cmdline(printable))
execCmdLogger.debug("%s (cwd %s)", cmdline, cwd)
p = BetterPopen(command, close_fds=True, cwd=cwd, env=env)
p = AsyncProc(p)
if not sync:
if data is not None:
p.stdin.write(data)
p.stdin.flush()
return p
(out, err) = p.communicate(data)
if out is None:
# Prevent splitlines() from barfing later on
out = ""
execCmdLogger.debug("%s: <err> = %s; <rc> = %d", {
True: "SUCCESS",
False: "FAILED"
}[p.returncode == 0], repr(err), p.returncode)
if not raw:
out = out.splitlines(False)
err = err.splitlines(False)
return (p.returncode, out, err)
