class Process(object):
"""Wraps a process.
Options:
- **wid**: the process unique identifier. This value will be used to
replace the *$WID* string in the command line if present.
- **cmd**: the command to run. May contain any of the variables available
that are being passed to this class. They will be replaced using the
python format syntax.
- **args**: the arguments for the command to run. Can be a list or
a string. If **args** is a string, it's splitted using
:func:`shlex.split`. Defaults to None.
- **executable**: When executable is given, the first item in
the args sequence obtained from **cmd** is still treated by most
programs as the command name, which can then be different from the
actual executable name. It becomes the display name for the executing
program in utilities such as **ps**.
- **working_dir**: the working directory to run the command in. If
not provided, will default to the current working directory.
- **shell**: if *True*, will run the command in the shell
environment. *False* by default. **warning: this is a
security hazard**.
- **uid**: if given, is the user id or name the command should run
with. The current uid is the default.
- **gid**: if given, is the group id or name the command should run
with. The current gid is the default.
- **env**: a mapping containing the environment variables the command
will run with. Optional.
- **rlimits**: a mapping containing rlimit names and values that will
be set before the command runs.
- **use_fds**: if True, will not close the fds in the subprocess.
default: False.
- **pipe_stdout**: if True, will open a PIPE on stdout. default: True.
- **pipe_stderr**: if True, will open a PIPE on stderr. default: True.
- **close_child_stdout**: If True, redirects the child process' stdout
to /dev/null after the fork. default: False.
- **close_child_stderr**: If True, redirects the child process' stdout
to /dev/null after the fork. default: False.
"""
def __init__(self,
wid,
cmd,
args=None,
working_dir=None,
shell=False,
uid=None,
gid=None,
env=None,
rlimits=None,
executable=None,
use_fds=False,
watcher=None,
spawn=True,
pipe_stdout=True,
pipe_stderr=True,
close_child_stdout=False,
close_child_stderr=False):
self.wid = wid
self.cmd = cmd
self.args = args
self.working_dir = working_dir or get_working_dir()
self.shell = shell
self.uid = to_uid(uid) if uid else None
self.gid = to_gid(gid) if gid else None
self.env = env or {}
self.rlimits = rlimits or {}
self.executable = executable
self.use_fds = use_fds
self.watcher = watcher
self.pipe_stdout = pipe_stdout
self.pipe_stderr = pipe_stderr
self.close_child_stdout = close_child_stdout
self.close_child_stderr = close_child_stderr
self.stopping = False
# sockets created before fork, should be let go after.
self._sockets = []
if spawn:
self.spawn()
def _null_streams(self, streams):
devnull = os.open(os.devnull, os.O_RDWR)
try:
for stream in streams:
if not hasattr(stream, 'fileno'):
# we're probably dealing with a file-like
continue
try:
stream.flush()
os.dup2(devnull, stream.fileno())
except IOError:
# some streams, like stdin - might be already closed.
pass
finally:
os.close(devnull)
def _get_sockets_fds(self):
"""Returns sockets dict. If this worker's cmd indicates use of
a SO_REUSEPORT socket, a new socket is created and bound. This
new socket's FD replaces original socket's FD in returned dict.
This method populates `self._sockets` list. This list should be
let go after `fork()`.
"""
sockets_fds = None
if self.watcher is not None and self.watcher.sockets is not None:
sockets_fds = self.watcher._get_sockets_fds()
reuseport_sockets = tuple(
(sn, s) for (sn, s) in self.watcher.sockets.items()
if s.so_reuseport)
for sn, s in reuseport_sockets:
# watcher.cmd uses this reuseport socket
if 'circus.sockets.%s' % sn in self.watcher.cmd:
sock = CircusSocket.load_from_config(s._cfg)
sock.bind_and_listen()
# replace original socket's fd
sockets_fds[sn] = sock.fileno()
# keep new socket until fork returns
self._sockets.append(sock)
return sockets_fds
def spawn(self):
sockets_fds = self._get_sockets_fds()
args = self.format_args(sockets_fds=sockets_fds)
def preexec_fn():
streams = [sys.stdin]
if self.close_child_stdout:
streams.append(sys.stdout)
if self.close_child_stderr:
streams.append(sys.stderr)
self._null_streams(streams)
os.setsid()
for limit, value in self.rlimits.items():
res = getattr(resource, 'RLIMIT_%s' % limit.upper(), None)
if res is None:
raise ValueError('unknown rlimit "%s"' % limit)
# TODO(petef): support hard/soft limits
resource.setrlimit(res, (value, value))
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
extra = {}
if self.pipe_stdout:
extra['stdout'] = PIPE
if self.pipe_stderr:
extra['stderr'] = PIPE
self._worker = Popen(args,
cwd=self.working_dir,
shell=self.shell,
preexec_fn=preexec_fn,
env=self.env,
close_fds=not self.use_fds,
executable=self.executable,
**extra)
# let go of sockets created only for self._worker to inherit
self._sockets = []
self.started = time.time()
def format_args(self, sockets_fds=None):
""" It's possible to use environment variables and some other variables
that are available in this context, when spawning the processes.
"""
logger.debug('cmd: ' + bytestring(self.cmd))
logger.debug('args: ' + str(self.args))
current_env = ObjectDict(self.env.copy())
format_kwargs = {
'wid': self.wid,
'shell': self.shell,
'args': self.args,
'env': current_env,
'working_dir': self.working_dir,
'uid': self.uid,
'gid': self.gid,
'rlimits': self.rlimits,
'executable': self.executable,
'use_fds': self.use_fds
}
if sockets_fds is not None:
format_kwargs['sockets'] = sockets_fds
if self.watcher is not None:
for option in self.watcher.optnames:
if option not in format_kwargs\
and hasattr(self.watcher, option):
format_kwargs[option] = getattr(self.watcher, option)
cmd = replace_gnu_args(self.cmd, **format_kwargs)
if '$WID' in cmd or (self.args and '$WID' in self.args):
msg = "Using $WID in the command is deprecated. You should use "\
"the python string format instead. In you case, this means "\
"replacing the $WID in your command by $(WID)."
warnings.warn(msg, DeprecationWarning)
self.cmd = cmd.replace('$WID', str(self.wid))
if self.args is not None:
if isinstance(self.args, string_types):
args = shlex.split(
bytestring(replace_gnu_args(self.args, **format_kwargs)))
else:
args = [
bytestring(replace_gnu_args(arg, **format_kwargs))
for arg in self.args
]
args = shlex.split(bytestring(cmd)) + args
else:
args = shlex.split(bytestring(cmd))
if self.shell:
# subprocess.Popen(shell=True) implies that 1st arg is the
# requested command, remaining args are applied to sh.
args = [' '.join(quote(arg) for arg in args)]
shell_args = format_kwargs.get('shell_args', None)
if shell_args and is_win():
logger.warn(
"shell_args won't apply for "
"windows platforms: %s", shell_args)
elif isinstance(shell_args, string_types):
args += shlex.split(
bytestring(replace_gnu_args(shell_args, **format_kwargs)))
elif shell_args:
args += [
bytestring(replace_gnu_args(arg, **format_kwargs))
for arg in shell_args
]
elif format_kwargs.get('shell_args', False):
logger.warn(
"shell_args is defined but won't be used "
"in this context: %s", format_kwargs['shell_args'])
logger.debug("process args: %s", args)
return args
def returncode(self):
return self._worker.returncode
@debuglog
def poll(self):
return self._worker.poll()
@debuglog
def is_alive(self):
return self.poll() is None
@debuglog
def send_signal(self, sig):
"""Sends a signal **sig** to the process."""
logger.debug("sending signal %s to %s" % (sig, self.pid))
return self._worker.send_signal(sig)
@debuglog
def stop(self):
"""Stop the process and close stdout/stderr
If the corresponding process is still here
(normally it's already killed by the watcher),
a SIGTERM is sent, then a SIGKILL after 1 second.
The shutdown process (SIGTERM then SIGKILL) is
normally taken by the watcher. So if the process
is still there here, it's a kind of bad behavior
because the graceful timeout won't be respected here.
"""
try:
try:
if self._worker.poll() is None:
return self._worker.terminate()
finally:
if self._worker.stderr is not None:
self._worker.stderr.close()
if self._worker.stdout is not None:
self._worker.stdout.close()
except NoSuchProcess:
pass
def age(self):
"""Return the age of the process in seconds."""
return time.time() - self.started
def info(self):
"""Return process info.
The info returned is a mapping with these keys:
- **mem_info1**: Resident Set Size Memory in bytes (RSS)
- **mem_info2**: Virtual Memory Size in bytes (VMS).
- **cpu**: % of cpu usage.
- **mem**: % of memory usage.
- **ctime**: process CPU (user + system) time in seconds.
- **pid**: process id.
- **username**: user name that owns the process.
- **nice**: process niceness (between -20 and 20)
- **cmdline**: the command line the process was run with.
"""
try:
info = get_info(self._worker)
except NoSuchProcess:
return "No such process (stopped?)"
info["age"] = self.age()
info["started"] = self.started
info["children"] = []
info['wid'] = self.wid
for child in self._worker.get_children():
info["children"].append(get_info(child))
return info
def children(self):
"""Return a list of children pids."""
return [child.pid for child in self._worker.get_children()]
def is_child(self, pid):
"""Return True is the given *pid* is a child of that process."""
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
return True
return False
@debuglog
def send_signal_child(self, pid, signum):
"""Send signal *signum* to child *pid*."""
children = dict(
(child.pid, child) for child in self._worker.get_children())
try:
children[pid].send_signal(signum)
except KeyError:
raise NoSuchProcess(pid)
@debuglog
def send_signal_children(self, signum):
"""Send signal *signum* to all children."""
for child in self._worker.get_children():
try:
child.send_signal(signum)
except OSError as e:
if e.errno != errno.ESRCH:
raise
@property
def status(self):
"""Return the process status as a constant
- RUNNING
- DEAD_OR_ZOMBIE
- UNEXISTING
- OTHER
"""
try:
if self._worker.status in (STATUS_ZOMBIE, STATUS_DEAD):
return DEAD_OR_ZOMBIE
except NoSuchProcess:
return UNEXISTING
if self._worker.is_running():
return RUNNING
return OTHER
@property
def pid(self):
"""Return the *pid*"""
return self._worker.pid
@property
def stdout(self):
"""Return the *stdout* stream"""
return self._worker.stdout
@property
def stderr(self):
"""Return the *stdout* stream"""
return self._worker.stderr
def __eq__(self, other):
return self is other
def __lt__(self, other):
return self.started < other.started
def __gt__(self, other):
return self.started > other.started
class Process(object):
"""Wraps a process.
Options:
- **wid**: the process unique identifier. This value will be used to
replace the *$WID* string in the command line if present.
- **cmd**: the command to run. May contain any of the variables available
that are being passed to this class. They will be replaced using the
python format syntax.
- **args**: the arguments for the command to run. Can be a list or
a string. If **args** is a string, it's splitted using
:func:`shlex.split`. Defaults to None.
- **executable**: When executable is given, the first item in
the args sequence obtained from **cmd** is still treated by most
programs as the command name, which can then be different from the
actual executable name. It becomes the display name for the executing
program in utilities such as **ps**.
- **working_dir**: the working directory to run the command in. If
not provided, will default to the current working directory.
- **shell**: if *True*, will run the command in the shell
environment. *False* by default. **warning: this is a
security hazard**.
- **uid**: if given, is the user id or name the command should run
with. The current uid is the default.
- **gid**: if given, is the group id or name the command should run
with. The current gid is the default.
- **env**: a mapping containing the environment variables the command
will run with. Optional.
- **rlimits**: a mapping containing rlimit names and values that will
be set before the command runs.
- **use_fds**: if True, will not close the fds in the subprocess.
default: False.
- **pipe_stdout**: if True, will open a PIPE on stdout. default: True.
- **pipe_stderr**: if True, will open a PIPE on stderr. default: True.
- **close_child_stdout**: If True, redirects the child process' stdout
to /dev/null after the fork. default: False.
- **close_child_stderr**: If True, redirects the child process' stdout
to /dev/null after the fork. default: False.
"""
def __init__(self, wid, cmd, args=None, working_dir=None, shell=False,
uid=None, gid=None, env=None, rlimits=None, executable=None,
use_fds=False, watcher=None, spawn=True,
pipe_stdout=True, pipe_stderr=True,
close_child_stdout=False, close_child_stderr=False):
self.wid = wid
self.cmd = cmd
self.args = args
self.working_dir = working_dir or get_working_dir()
self.shell = shell
self.uid = to_uid(uid) if uid else None
self.gid = to_gid(gid) if gid else None
self.env = env or {}
self.rlimits = rlimits or {}
self.executable = executable
self.use_fds = use_fds
self.watcher = watcher
self.pipe_stdout = pipe_stdout
self.pipe_stderr = pipe_stderr
self.close_child_stdout = close_child_stdout
self.close_child_stderr = close_child_stderr
self.stopping = False
if spawn:
self.spawn()
def _null_streams(self, streams):
devnull = os.open(os.devnull, os.O_RDWR)
try:
for stream in streams:
if not hasattr(stream, 'fileno'):
# we're probably dealing with a file-like
continue
try:
stream.flush()
os.dup2(devnull, stream.fileno())
except IOError:
# some streams, like stdin - might be already closed.
pass
finally:
os.close(devnull)
def spawn(self):
args = self.format_args()
def preexec_fn():
streams = [sys.stdin]
if self.close_child_stdout:
streams.append(sys.stdout)
if self.close_child_stderr:
streams.append(sys.stderr)
self._null_streams(streams)
os.setsid()
for limit, value in self.rlimits.items():
res = getattr(resource, 'RLIMIT_%s' % limit.upper(), None)
if res is None:
raise ValueError('unknown rlimit "%s"' % limit)
# TODO(petef): support hard/soft limits
resource.setrlimit(res, (value, value))
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
extra = {}
if self.pipe_stdout:
extra['stdout'] = PIPE
if self.pipe_stderr:
extra['stderr'] = PIPE
self._worker = Popen(args, cwd=self.working_dir,
shell=self.shell, preexec_fn=preexec_fn,
env=self.env, close_fds=not self.use_fds,
executable=self.executable, **extra)
self.started = time.time()
def format_args(self):
""" It's possible to use environment variables and some other variables
that are available in this context, when spawning the processes.
"""
logger.debug('cmd: ' + bytestring(self.cmd))
logger.debug('args: ' + str(self.args))
current_env = ObjectDict(self.env.copy())
format_kwargs = {
'wid': self.wid, 'shell': self.shell, 'args': self.args,
'env': current_env, 'working_dir': self.working_dir,
'uid': self.uid, 'gid': self.gid, 'rlimits': self.rlimits,
'executable': self.executable, 'use_fds': self.use_fds}
if self.watcher is not None:
format_kwargs['sockets'] = self.watcher._get_sockets_fds()
for option in self.watcher.optnames:
if option not in format_kwargs\
and hasattr(self.watcher, option):
format_kwargs[option] = getattr(self.watcher, option)
cmd = replace_gnu_args(self.cmd, **format_kwargs)
if '$WID' in cmd or (self.args and '$WID' in self.args):
msg = "Using $WID in the command is deprecated. You should use "\
"the python string format instead. In you case, this means "\
"replacing the $WID in your command by $(WID)."
warnings.warn(msg, DeprecationWarning)
self.cmd = cmd.replace('$WID', str(self.wid))
if self.args is not None:
if isinstance(self.args, string_types):
args = shlex.split(bytestring(replace_gnu_args(
self.args, **format_kwargs)))
else:
args = [bytestring(replace_gnu_args(arg, **format_kwargs))
for arg in self.args]
args = shlex.split(bytestring(cmd)) + args
else:
args = shlex.split(bytestring(cmd))
logger.debug("process args: %s", args)
return args
@debuglog
def poll(self):
return self._worker.poll()
@debuglog
def is_alive(self):
return self.poll() is None
@debuglog
def send_signal(self, sig):
"""Sends a signal **sig** to the process."""
logger.debug("sending signal %s to %s" % (sig, self.pid))
return self._worker.send_signal(sig)
@debuglog
def stop(self):
"""Stop the process and close stdout/stderr
If the corresponding process is still here
(normally it's already killed by the watcher),
a SIGTERM is sent, then a SIGKILL after 1 second.
The shutdown process (SIGTERM then SIGKILL) is
normally taken by the watcher. So if the process
is still there here, it's a kind of bad behavior
because the graceful timeout won't be respected here.
"""
try:
try:
if self._worker.poll() is None:
return self._worker.terminate()
finally:
if self._worker.stderr is not None:
self._worker.stderr.close()
if self._worker.stdout is not None:
self._worker.stdout.close()
except NoSuchProcess:
pass
def age(self):
"""Return the age of the process in seconds."""
return time.time() - self.started
def info(self):
"""Return process info.
The info returned is a mapping with these keys:
- **mem_info1**: Resident Set Size Memory in bytes (RSS)
- **mem_info2**: Virtual Memory Size in bytes (VMS).
- **cpu**: % of cpu usage.
- **mem**: % of memory usage.
- **ctime**: process CPU (user + system) time in seconds.
- **pid**: process id.
- **username**: user name that owns the process.
- **nice**: process niceness (between -20 and 20)
- **cmdline**: the command line the process was run with.
"""
try:
info = get_info(self._worker)
except NoSuchProcess:
return "No such process (stopped?)"
info["age"] = self.age()
info["started"] = self.started
info["children"] = []
for child in self._worker.get_children():
info["children"].append(get_info(child))
return info
def children(self):
"""Return a list of children pids."""
return [child.pid for child in self._worker.get_children()]
def is_child(self, pid):
"""Return True is the given *pid* is a child of that process."""
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
return True
return False
@debuglog
def send_signal_child(self, pid, signum):
"""Send signal *signum* to child *pid*."""
children = dict([(child.pid, child)
for child in self._worker.get_children()])
children[pid].send_signal(signum)
@debuglog
def send_signal_children(self, signum):
"""Send signal *signum* to all children."""
for child in self._worker.get_children():
try:
child.send_signal(signum)
except OSError as e:
if e.errno != errno.ESRCH:
raise
@property
def status(self):
"""Return the process status as a constant
- RUNNING
- DEAD_OR_ZOMBIE
- UNEXISTING
- OTHER
"""
try:
if self._worker.status in (STATUS_ZOMBIE, STATUS_DEAD):
return DEAD_OR_ZOMBIE
except NoSuchProcess:
return UNEXISTING
if self._worker.is_running():
return RUNNING
return OTHER
@property
def pid(self):
"""Return the *pid*"""
return self._worker.pid
@property
def stdout(self):
"""Return the *stdout* stream"""
return self._worker.stdout
@property
def stderr(self):
"""Return the *stdout* stream"""
return self._worker.stderr
def __eq__(self, other):
return self is other
def __lt__(self, other):
return self.started < other.started
def __gt__(self, other):
return self.started > other.started
class Process(object):
"""Wraps a process.
Options:
- **wid**: the process unique identifier. This value will be used to
replace the *$WID* string in the command line if present.
- **cmd**: the command to run. May contain any of the variables available
that are being passed to this class. They will be replaced using the
python format syntax.
- **args**: the arguments for the command to run. Can be a list or
a string. If **args** is a string, it's splitted using
:func:`shlex.split`. Defaults to None.
- **executable**: When executable is given, the first item in
the args sequence obtained from **cmd** is still treated by most
programs as the command name, which can then be different from the
actual executable name. It becomes the display name for the executing
program in utilities such as **ps**.
- **working_dir**: the working directory to run the command in. If
not provided, will default to the current working directory.
- **shell**: if *True*, will run the command in the shell
environment. *False* by default. **warning: this is a
security hazard**.
- **uid**: if given, is the user id or name the command should run
with. The current uid is the default.
- **gid**: if given, is the group id or name the command should run
with. The current gid is the default.
- **env**: a mapping containing the environment variables the command
will run with. Optional.
- **rlimits**: a mapping containing rlimit names and values that will
be set before the command runs.
- **use_fds**: if True, will not close the fds in the subprocess.
default: False.
"""
def __init__(self,
wid,
cmd,
args=None,
working_dir=None,
shell=False,
uid=None,
gid=None,
env=None,
rlimits=None,
executable=None,
use_fds=False,
watcher=None,
spawn=True):
self.wid = wid
self.cmd = cmd
self.args = args
self.working_dir = working_dir or get_working_dir()
self.shell = shell
self.uid = to_uid(uid) if uid else None
self.gid = to_gid(gid) if gid else None
self.env = env or {}
self.rlimits = rlimits or {}
self.executable = executable
self.use_fds = use_fds
self.watcher = watcher
if spawn:
self.spawn()
def spawn(self):
args = self.format_args()
def preexec_fn():
os.setsid()
for limit, value in self.rlimits.items():
res = getattr(resource, 'RLIMIT_%s' % limit.upper(), None)
if res is None:
raise ValueError('unknown rlimit "%s"' % limit)
# TODO(petef): support hard/soft limits
resource.setrlimit(res, (value, value))
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
self._worker = Popen(args,
cwd=self.working_dir,
shell=self.shell,
preexec_fn=preexec_fn,
env=self.env,
close_fds=not self.use_fds,
stdout=PIPE,
stderr=PIPE,
executable=self.executable)
self.started = time.time()
def format_args(self):
""" It's possible to use environment variables and some other variables
that are available in this context, when spawning the processes.
"""
logger.debug('cmd: ' + bytestring(self.cmd))
logger.debug('args: ' + str(self.args))
current_env = ObjectDict(self.env.copy())
format_kwargs = {
'wid': self.wid,
'shell': self.shell,
'args': self.args,
'env': current_env,
'working_dir': self.working_dir,
'uid': self.uid,
'gid': self.gid,
'rlimits': self.rlimits,
'executable': self.executable,
'use_fds': self.use_fds
}
if self.watcher is not None:
for option in self.watcher.optnames:
if option not in format_kwargs\
and hasattr(self.watcher, option):
format_kwargs[option] = getattr(self.watcher, option)
cmd = replace_gnu_args(self.cmd, **format_kwargs)
if '$WID' in cmd or (self.args and '$WID' in self.args):
msg = "Using $WID in the command is deprecated. You should use "\
"the python string format instead. In you case, this means "\
"replacing the $WID in your command by $(WID)."
warnings.warn(msg, DeprecationWarning)
self.cmd = cmd.replace('$WID', str(self.wid))
if self.args is not None:
if isinstance(self.args, string_types):
args = shlex.split(
bytestring(replace_gnu_args(self.args, **format_kwargs)))
else:
args = [bytestring(replace_gnu_args(arg, **format_kwargs))\
for arg in self.args]
args = shlex.split(bytestring(cmd)) + args
else:
args = shlex.split(bytestring(cmd))
logger.debug("process args: %s", args)
return args
@debuglog
def poll(self):
return self._worker.poll()
@debuglog
def send_signal(self, sig):
"""Sends a signal **sig** to the process."""
logger.debug("sending signal %s to %s" % (sig, self.pid))
return self._worker.send_signal(sig)
@debuglog
def stop(self):
"""Terminate the process."""
try:
try:
if self._worker.poll() is None:
return self._worker.terminate()
finally:
self._worker.stderr.close()
self._worker.stdout.close()
except NoSuchProcess:
pass
def age(self):
"""Return the age of the process in seconds."""
return time.time() - self.started
def info(self):
"""Return process info.
The info returned is a mapping with these keys:
- **mem_info1**: Resident Set Size Memory in bytes (RSS)
- **mem_info2**: Virtual Memory Size in bytes (VMS).
- **cpu**: % of cpu usage.
- **mem**: % of memory usage.
- **ctime**: process CPU (user + system) time in seconds.
- **pid**: process id.
- **username**: user name that owns the process.
- **nice**: process niceness (between -20 and 20)
- **cmdline**: the command line the process was run with.
"""
try:
info = get_info(self._worker)
except NoSuchProcess:
return "No such process (stopped?)"
info["age"] = self.age()
info["started"] = self.started
info["children"] = []
for child in self._worker.get_children():
info["children"].append(get_info(child))
return info
def children(self):
"""Return a list of children pids."""
return [child.pid for child in self._worker.get_children()]
def is_child(self, pid):
"""Return True is the given *pid* is a child of that process."""
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
return True
return False
@debuglog
def send_signal_child(self, pid, signum):
"""Send signal *signum* to child *pid*."""
children = dict([(child.pid, child) \
for child in self._worker.get_children()])
children[pid].send_signal(signum)
@debuglog
def send_signal_children(self, signum):
"""Send signal *signum* to all children."""
for child in self._worker.get_children():
try:
child.send_signal(signum)
except OSError as e:
if e.errno != errno.ESRCH:
raise
@property
def status(self):
"""Return the process status as a constant
- RUNNING
- DEAD_OR_ZOMBIE
- UNEXISTING
- OTHER
"""
try:
if self._worker.status in (STATUS_ZOMBIE, STATUS_DEAD):
return DEAD_OR_ZOMBIE
except NoSuchProcess:
return UNEXISTING
if self._worker.is_running():
return RUNNING
return OTHER
@property
def pid(self):
"""Return the *pid*"""
return self._worker.pid
@property
def stdout(self):
"""Return the *stdout* stream"""
return self._worker.stdout
@property
def stderr(self):
"""Return the *stdout* stream"""
return self._worker.stderr
def __eq__(self, other):
return self is other
def __lt__(self, other):
return self.started < other.started
def __gt__(self, other):
return self.started > other.started
class Process(object):
"""Wraps a process.
Options:
- **wid**: the process unique identifier. This value will be used to
replace the *$WID* string in the command line if present.
- **cmd**: the command to run. May contain *$WID*, which will be
replaced by **wid**.
- **args**: the arguments for the command to run. Can be a list or
a string. If **args** is a string, it's splitted using
:func:`shlex.split`. Defaults to None.
- **executable**: When executable is given, the first item in
the args sequence obtained from **cmd** is still treated by most
programs as the command name, which can then be different from the
actual executable name. It becomes the display name for the executing
program in utilities such as **ps**.
- **working_dir**: the working directory to run the command in. If
not provided, will default to the current working directory.
- **shell**: if *True*, will run the command in the shell
environment. *False* by default. **warning: this is a
security hazard**.
- **uid**: if given, is the user id or name the command should run
with. The current uid is the default.
- **gid**: if given, is the group id or name the command should run
with. The current gid is the default.
- **env**: a mapping containing the environment variables the command
will run with. Optional.
- **rlimits**: a mapping containing rlimit names and values that will
be set before the command runs.
"""
def __init__(self, wid, cmd, args=None, working_dir=None, shell=False,
uid=None, gid=None, env=None, rlimits=None, executable=None):
self.wid = wid
if working_dir is None:
self.working_dir = get_working_dir()
else:
self.working_dir = working_dir
self.shell = shell
self.env = env
if rlimits is not None:
self.rlimits = rlimits
else:
self.rlimits = {}
self.cmd = cmd.replace('$WID', str(self.wid))
if uid is None:
self.uid = None
else:
self.uid = to_uid(uid)
if gid is None:
self.gid = None
else:
self.gid = to_gid(gid)
def preexec_fn():
os.setsid()
for limit, value in self.rlimits.items():
res = getattr(resource, 'RLIMIT_%s' % limit.upper(), None)
if res is None:
raise ValueError('unknown rlimit "%s"' % limit)
# TODO(petef): support hard/soft limits
resource.setrlimit(res, (value, value))
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
logger.debug('cmd: ' + cmd)
logger.debug('args: ' + str(args))
if args is not None:
if isinstance(args, str):
args_ = shlex.split(bytestring(args))
else:
args_ = args[:]
args_ = shlex.split(bytestring(cmd)) + args_
else:
args_ = shlex.split(bytestring(cmd))
logger.debug('Running %r' % ' '.join(args_))
self._worker = Popen(args_, cwd=self.working_dir,
shell=self.shell, preexec_fn=preexec_fn,
env=self.env, close_fds=True, stdout=PIPE,
stderr=PIPE, executable=executable)
self.started = time.time()
@debuglog
def poll(self):
return self._worker.poll()
@debuglog
def send_signal(self, sig):
"""Sends a signal **sig** to the process."""
return self._worker.send_signal(sig)
@debuglog
def stop(self):
"""Terminate the process."""
try:
if self._worker.poll() is None:
return self._worker.terminate()
finally:
self._worker.stderr.close()
self._worker.stdout.close()
def age(self):
"""Return the age of the process in seconds."""
return time.time() - self.started
def info(self):
"""Return process info.
The info returned is a mapping with these keys:
- **mem_info1**: Resident Set Size Memory in bytes (RSS)
- **mem_info2**: Virtual Memory Size in bytes (VMS).
- **cpu**: % of cpu usage.
- **mem**: % of memory usage.
- **ctime**: process CPU (user + system) time in seconds.
- **pid**: process id.
- **username**: user name that owns the process.
- **nice**: process niceness (between -20 and 20)
- **cmdline**: the command line the process was run with.
"""
try:
info = get_info(self._worker)
except NoSuchProcess:
return "No such process (stopped?)"
info["children"] = []
for child in self._worker.get_children():
info["children"].append(get_info(child))
return info
def children(self):
"""Return a list of children pids."""
return [child.pid for child in self._worker.get_children()]
def is_child(self, pid):
"""Return True is the given *pid* is a child of that process."""
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
return True
return False
@debuglog
def send_signal_child(self, pid, signum):
"""Send signal *signum* to child *pid*."""
children = dict([(child.pid, child) \
for child in self._worker.get_children()])
children[pid].send_signal(signum)
@debuglog
def send_signal_children(self, signum):
"""Send signal *signum* to all children."""
for child in self._worker.get_children():
try:
child.send_signal(signum)
except OSError as e:
if e.errno != errno.ESRCH:
raise
@property
def status(self):
"""Return the process status as a constant
- RUNNING
- DEAD_OR_ZOMBIE
- OTHER
"""
try:
if self._worker.status in (STATUS_ZOMBIE, STATUS_DEAD):
return DEAD_OR_ZOMBIE
except NoSuchProcess:
return OTHER
if self._worker.is_running():
return RUNNING
return OTHER
@property
def pid(self):
"""Return the *pid*"""
return self._worker.pid
@property
def stdout(self):
"""Return the *stdout* stream"""
return self._worker.stdout
@property
def stderr(self):
"""Return the *stdout* stream"""
return self._worker.stderr
class Fly(object):
def __init__(self, wid, cmd, working_dir, shell, uid=None, gid=None, env=None):
self.wid = wid
self.working_dir = working_dir
self.shell = shell
self.env = env
self.cmd = cmd.replace("$WID", str(self.wid))
self.uid = to_uid(uid)
self.gid = to_gid(gid)
def preexec_fn():
os.setsid()
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
self._worker = Popen(
self.cmd.split(),
cwd=self.working_dir,
shell=self.shell,
preexec_fn=preexec_fn,
env=self.env,
close_fds=True,
)
self.started = time.time()
def poll(self):
return self._worker.poll()
def send_signal(self, sig):
return self._worker.send_signal(sig)
def stop(self):
if self._worker.poll() is None:
return self._worker.terminate()
def age(self):
return time.time() - self.started
def info(self):
""" return process info """
info = _INFOLINE % get_info(self._worker)
lines = ["%s: %s" % (self.wid, info)]
for child in self._worker.get_children():
info = _INFOLINE % get_info(child)
lines.append(" %s" % info)
return "\n".join(lines)
def children(self):
return ",".join(["%s" % child.pid for child in self._worker.get_children()])
def send_signal_child(self, pid, signum):
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
child.send_signal(signum)
return "ok"
else:
return "error: child not found"
def send_signal_children(self, signum):
for child in self._worker.get_children():
child.send_signal(signum)
return "ok"
@property
def pid(self):
return self._worker.pid
class Process(object):
"""Wraps a process.
Options:
- **wid**: the process unique identifier. This value will be used to
replace the *$WID* string in the command line if present.
- **cmd**: the command to run. May contain *$WID*, which will be
replaced by **wid**.
- **args**: the arguments for the command to run. Can be a list or
a string. If **args** is a string, it's splitted using
:func:`shlex.split`. Defaults to None.
- **executable**: When executable is given, the first item in
the args sequence obtained from **cmd** is still treated by most
programs as the command name, which can then be different from the
actual executable name. It becomes the display name for the executing
program in utilities such as **ps**.
- **working_dir**: the working directory to run the command in. If
not provided, will default to the current working directory.
- **shell**: if *True*, will run the command in the shell
environment. *False* by default. **warning: this is a
security hazard**.
- **uid**: if given, is the user id or name the command should run
with. The current uid is the default.
- **gid**: if given, is the group id or name the command should run
with. The current gid is the default.
- **env**: a mapping containing the environment variables the command
will run with. Optional.
- **rlimits**: a mapping containing rlimit names and values that will
be set before the command runs.
"""
def __init__(self,
wid,
cmd,
args=None,
working_dir=None,
shell=False,
uid=None,
gid=None,
env=None,
rlimits=None,
executable=None):
self.wid = wid
if working_dir is None:
self.working_dir = get_working_dir()
else:
self.working_dir = working_dir
self.shell = shell
self.env = env
if rlimits is not None:
self.rlimits = rlimits
else:
self.rlimits = {}
self.cmd = cmd.replace('$WID', str(self.wid))
if uid is None:
self.uid = None
else:
self.uid = to_uid(uid)
if gid is None:
self.gid = None
else:
self.gid = to_gid(gid)
def preexec_fn():
os.setsid()
for limit, value in self.rlimits.items():
res = getattr(resource, 'RLIMIT_%s' % limit.upper(), None)
if res is None:
raise ValueError('unknown rlimit "%s"' % limit)
# TODO(petef): support hard/soft limits
resource.setrlimit(res, (value, value))
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
logger.debug('cmd: ' + bytestring(cmd))
logger.debug('args: ' + str(args))
if args is not None:
if isinstance(args, string_types):
args_ = shlex.split(bytestring(args))
else:
args_ = [bytestring(arg) for arg in args]
args_ = shlex.split(bytestring(cmd)) + args_
else:
args_ = shlex.split(bytestring(cmd))
logger.debug("process args: %s", args_)
logger.debug('Running %r' % ' '.join(args_))
self._worker = Popen(args_,
cwd=self.working_dir,
shell=self.shell,
preexec_fn=preexec_fn,
env=self.env,
close_fds=True,
stdout=PIPE,
stderr=PIPE,
executable=executable)
self.started = time.time()
@debuglog
def poll(self):
return self._worker.poll()
@debuglog
def send_signal(self, sig):
"""Sends a signal **sig** to the process."""
return self._worker.send_signal(sig)
@debuglog
def stop(self):
"""Terminate the process."""
try:
if self._worker.poll() is None:
return self._worker.terminate()
finally:
self._worker.stderr.close()
self._worker.stdout.close()
def age(self):
"""Return the age of the process in seconds."""
return time.time() - self.started
def info(self):
"""Return process info.
The info returned is a mapping with these keys:
- **mem_info1**: Resident Set Size Memory in bytes (RSS)
- **mem_info2**: Virtual Memory Size in bytes (VMS).
- **cpu**: % of cpu usage.
- **mem**: % of memory usage.
- **ctime**: process CPU (user + system) time in seconds.
- **pid**: process id.
- **username**: user name that owns the process.
- **nice**: process niceness (between -20 and 20)
- **cmdline**: the command line the process was run with.
"""
try:
info = get_info(self._worker)
except NoSuchProcess:
return "No such process (stopped?)"
info["children"] = []
for child in self._worker.get_children():
info["children"].append(get_info(child))
return info
def children(self):
"""Return a list of children pids."""
return [child.pid for child in self._worker.get_children()]
def is_child(self, pid):
"""Return True is the given *pid* is a child of that process."""
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
return True
return False
@debuglog
def send_signal_child(self, pid, signum):
"""Send signal *signum* to child *pid*."""
children = dict([(child.pid, child) \
for child in self._worker.get_children()])
children[pid].send_signal(signum)
@debuglog
def send_signal_children(self, signum):
"""Send signal *signum* to all children."""
for child in self._worker.get_children():
try:
child.send_signal(signum)
except OSError as e:
if e.errno != errno.ESRCH:
raise
@property
def status(self):
"""Return the process status as a constant
- RUNNING
- DEAD_OR_ZOMBIE
- OTHER
"""
try:
if self._worker.status in (STATUS_ZOMBIE, STATUS_DEAD):
return DEAD_OR_ZOMBIE
except NoSuchProcess:
return OTHER
if self._worker.is_running():
return RUNNING
return OTHER
@property
def pid(self):
"""Return the *pid*"""
return self._worker.pid
@property
def stdout(self):
"""Return the *stdout* stream"""
return self._worker.stdout
@property
def stderr(self):
"""Return the *stdout* stream"""
return self._worker.stderr
class Process(object):
"""Wraps a process.
Options:
- **wid**: the process unique identifier. This value will be used to
replace the *$WID* string in the command line if present.
- **cmd**: the command to run. May contain *$WID*, which will be
replaced by **wid**.
- **working_dir**: the working directory to run the command in. If
not provided, will default to the current working directory.
- **shell**: if *True*, will run the command in the shell
environment. *False* by default. **warning: this is a
security hazard**.
- **uid**: if given, is the user id or name the command should run
with. The current uid is the default.
- **gid**: if given, is the group id or name the command should run
with. The current gid is the default.
- **env**: a mapping containing the environment variables the command
will run with. Optional.
"""
def __init__(self, wid, cmd, working_dir=None, shell=False, uid=None,
gid=None, env=None):
self.wid = wid
if working_dir is None:
self.working_dir = get_working_dir()
else:
self.working_dir = working_dir
self.shell = shell
self.env = env
self.cmd = cmd.replace('$WID', str(self.wid))
if uid is None:
self.uid = None
else:
self.uid = to_uid(uid)
if gid is None:
self.gid = None
else:
self.gid = to_gid(gid)
def preexec_fn():
os.setsid()
if self.gid:
try:
os.setgid(self.gid)
except OverflowError:
if not ctypes:
raise
# versions of python < 2.6.2 don't manage unsigned int for
# groups like on osx or fedora
os.setgid(-ctypes.c_int(-self.gid).value)
if self.uid:
os.setuid(self.uid)
self._worker = Popen(self.cmd.split(), cwd=self.working_dir,
shell=self.shell, preexec_fn=preexec_fn,
env=self.env, close_fds=True, stdout=PIPE,
stderr=PIPE)
self.started = time.time()
@debuglog
def poll(self):
return self._worker.poll()
@debuglog
def send_signal(self, sig):
"""Sends a signal **sig** to the process."""
return self._worker.send_signal(sig)
@debuglog
def stop(self):
"""Terminate the process."""
if self._worker.poll() is None:
return self._worker.terminate()
def age(self):
"""Return the age of the process in seconds."""
return time.time() - self.started
def info(self):
"""Return process info.
The info returned is a mapping with these keys:
- **mem_info1**: Resident Set Size Memory in bytes (RSS)
- **mem_info2**: Virtual Memory Size in bytes (VMS).
- **cpu**: % of cpu usage.
- **mem**: % of memory usage.
- **ctime**: process CPU (user + system) time in seconds.
- **pid**: process id.
- **username**: user name that owns the process.
- **nice**: process niceness (between -20 and 20)
- **cmdline**: the command line the process was run with.
"""
try:
info = get_info(self._worker)
except NoSuchProcess:
return "No such process (stopped?)"
info["children"] = []
for child in self._worker.get_children():
info["children"].append(get_info(child))
return info
def children(self):
"""Return a list of children pids."""
return [child.pid for child in self._worker.get_children()]
def is_child(self, pid):
"""Return True is the given *pid* is a child of that process."""
pids = [child.pid for child in self._worker.get_children()]
if pid in pids:
return True
return False
@debuglog
def send_signal_child(self, pid, signum):
"""Send signal *signum* to child *pid*."""
children = dict([(child.pid, child) \
for child in self._worker.get_children()])
children[pid].send_signal(signum)
@debuglog
def send_signal_children(self, signum):
"""Send signal *signum* to all children."""
for child in self._worker.get_children():
try:
child.send_signal(signum)
except OSError as e:
if e.errno != errno.ESRCH:
raise
@property
def status(self):
"""Return the process status as a constant
- RUNNING
- DEAD_OR_ZOMBIE
- OTHER
"""
try:
if self._worker.status in (STATUS_ZOMBIE, STATUS_DEAD):
return DEAD_OR_ZOMBIE
except NoSuchProcess:
return OTHER
if self._worker.is_running():
return RUNNING
return OTHER
@property
def pid(self):
"""Return the *pid*"""
return self._worker.pid
@property
def stdout(self):
"""Return the *stdout* stream"""
return self._worker.stdout
@property
def stderr(self):
"""Return the *stdout* stream"""
return self._worker.stderr
