def testNoEnt(self):
try:
CPopen(['there-is-no-executable-with-this/funny/name'])
except OSError as ose:
self.assertEquals(ose.errno, errno.ENOENT)
else:
self.fail('OSError not raised')
def testEcho(self):
data = "Hello"
p = CPopen([EXT_ECHO, "-n", data])
p.wait()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(p.stdout.read(), data)
def testNoStreams(self):
p = CPopen(['true'], stdin=None, stdout=None, stderr=None)
self.assertIsNone(p.stdin)
self.assertIsNone(p.stdout)
self.assertIsNone(p.stderr)
p.wait()
self.assertEquals(p.returncode, 0)
def _run(self):
self._log.debug("Starting IOProcess...")
myRead, hisWrite = os.pipe()
hisRead, myWrite = os.pipe()
self._partialLogs = ""
cmd = [
self.IOPROCESS_EXE, "--read-pipe-fd",
str(hisRead), "--write-pipe-fd",
str(hisWrite), "--max-threads",
str(self._max_threads)
]
if self._DEBUG_VALGRIND:
cmd = ["valgrind", "--log-file=ioprocess.valgrind.log",
"--leak-check=full", "--tool=memcheck"] + cmd + \
["--keep-fds"]
p = CPopen(cmd)
os.close(hisRead)
os.close(hisWrite)
setNonBlocking(myRead)
setNonBlocking(myWrite)
self._startCommunication(p, myRead, myWrite)
def testCwd(self):
cwd = "/proc"
p = CPopen(["python", "-c", "import os; print os.getcwd()"], cwd=cwd)
p.wait()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(p.stdout.read().strip(), cwd)
def __init__(self):
myRead, hisWrite = os.pipe()
hisRead, myWrite = os.pipe()
try:
# Some imports in vdsm assume /usr/share/vdsm is in your PYTHONPATH
env = os.environ.copy()
env['PYTHONPATH'] = "%s:%s" % (env.get("PYTHONPATH",
""), constants.P_VDSM)
env['PYTHONPATH'] = ":".join(
map(os.path.abspath, env['PYTHONPATH'].split(":")))
self.process = CPopen(
[constants.EXT_PYTHON, __file__,
str(hisRead),
str(hisWrite)],
close_fds=False,
env=env)
self.proxy = CrabRPCProxy(myRead, myWrite)
except:
os.close(myWrite)
os.close(myRead)
raise
finally:
os.close(hisRead)
os.close(hisWrite)
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,
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 testCat(self):
path = "/etc/passwd"
p = CPopen(["cat", path])
p.wait()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
with open(path, "r") as f:
self.assertEquals(p.stdout.read(), f.read())
def testProcessDiesAfterBeingTracked(self):
p = CPopen(["sleep", "1"])
zombiereaper.autoReapPID(p.pid)
# wait for the grim reaper to arrive
sleep(4)
# Throws error because pid is not found or is not child
self.assertRaises(OSError, os.waitpid, p.pid, os.WNOHANG)
def testProcessDiedBeforeBeingTracked(self):
p = CPopen(["sleep", "0"])
# wait for the process to die
sleep(1)
zombiereaper.autoReapPID(p.pid)
# Throws error because pid is not found or is not child
self.assertRaises(OSError, os.waitpid, p.pid, os.WNOHANG)
def testStdin(self):
data = "Hello World"
p = CPopen(["cat"])
p.stdin.write(data)
p.stdin.flush()
p.stdin.close()
p.wait()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(p.stdout.read(), data)
def testUnicodeArg(self):
data = u'hello'
cmd = [EXT_ECHO, "-n", data]
p = CPopen(cmd)
p.wait()
p2 = subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
p2.wait()
self.assertEquals(p.stdout.read(), p2.stdout.read())
def __init__(self, cmd, cwd=None):
self._aborted = False
self._progress = 0.0
self._stdout = bytearray()
self._stderr = bytearray()
cmd = cmdutils.wrap_command(cmd,
with_nice=utils.NICENESS.HIGH,
with_ioclass=utils.IOCLASS.IDLE)
_log.debug(cmdutils.command_log_line(cmd, cwd=cwd))
self._command = CPopen(cmd, cwd=cwd, deathSignal=signal.SIGKILL)
self._stream = utils.CommandStream(self._command, self._recvstdout,
self._recvstderr)
def testUmaskTmpfile(self):
tmp_dir = tempfile.mkdtemp()
name = os.path.join(tmp_dir, "file.txt")
p = CPopen(['touch', name], childUmask=0o007)
p.wait()
data = os.stat(name)
os.unlink(name)
self.assertTrue(data.st_mode & stat.S_IROTH == 0,
"%s is world-readable" % name)
self.assertTrue(data.st_mode & stat.S_IWOTH == 0,
"%s is world-writeable" % name)
self.assertTrue(data.st_mode & stat.S_IXOTH == 0,
"%s is world-executable" % name)
posix.rmdir(tmp_dir)
def testStdinEpoll(self):
import select
data = "Hello World"
p = CPopen(["cat"])
ep = select.epoll()
ep.register(p.stdin, select.EPOLLOUT)
fd, ev = ep.poll(1)[0]
ep.close()
os.write(fd, data)
p.stdin.close()
p.wait()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(p.stdout.read(), data)
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)
p.wait()
p2 = subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
p2.wait()
self.assertEquals(p.stdout.read(), p2.stdout.read())
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 spawn():
procPtr[0] = CPopen(["sleep", "10"], deathSignal=signal.SIGKILL)
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 testUmaskChange(self):
p = CPopen(['umask'], childUmask=0o007)
p.wait()
out = p.stdout.readlines()
self.assertEquals(out[0].strip(), '0007')
def _subTest(self, name, params, *args, **kwargs):
p = CPopen(["python", __file__, name] + params, *args, **kwargs)
p.wait()
self.assertTrue(p.returncode == 0,
"Process failed: %s" % os.strerror(p.returncode))
self.assertEquals(p.stdout.read().strip(), "True")
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
