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 __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 __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 __init__(self, wid, cmd, wdir, shell, uid=None, gid=None, env=None):
self.wid = wid
self.wdir = wdir
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():
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.wdir,
shell=self.shell,
preexec_fn=preexec_fn,
env=self.env)
self.started = time.time()
def __init__(self,
name,
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.name = name
self.wid = wid
self.cmd = cmd
self.args = args
self.working_dir = working_dir or get_working_dir()
self.shell = shell
if uid:
self.uid = to_uid(uid)
self.username = get_username_from_uid(self.uid)
else:
self.username = None
self.uid = 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 = []
self._worker = None
self.redirected = False
self.started = 0
if self.uid is not None and self.gid is None:
self.gid = get_default_gid(self.uid)
if IS_WINDOWS:
if not self.use_fds and (self.pipe_stderr or self.pipe_stdout):
raise ValueError("On Windows, you can't close the fds if "
"you are redirecting stdout or stderr")
if spawn:
self.spawn()
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key in self._options:
self._options[key] = val
action = -1 # XXX for now does not trigger a reload
elif key == "numprocesses":
val = int(val)
if val < 0:
val = 0
if self.singleton and val > 1:
raise ValueError('Singleton watcher has a single process')
self.numprocesses = val
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
elif key == "max_age":
self.max_age = int(val)
action = 1
elif key == "max_age_variance":
self.max_age_variance = int(val)
action = 1
# send update event
self.notify_event("updated", {"time": time.time()})
return action
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key in self._options:
self._options[key] = val
action = -1 # XXX for now does not trigger a reload
elif key == "numprocesses":
val = int(val)
if self.singleton and val > 1:
raise ValueError('Singleton watcher has a single process')
self.numprocesses = val
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
elif key == "max_age":
self.max_age = int(val)
action = 1
elif key == "max_age_variance":
self.max_age_variance = int(val)
action = 1
# send update event
self.notify_event("updated", {"time": time.time()})
return action
def __init__(self, wid, cmd, working_dir=None, shell=False, uid=None,
gid=None, env=None, rlimits=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)
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()
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key == "numprocesses":
self.numprocesses = int(val)
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "flapping_attempts":
self.flapping_attempts = int(val)
action = -1
elif key == "flapping_window":
self.flapping_window = float(val)
elif key == "retry_in":
self.retry_in = float(val)
elif key == "max_retry":
self.max_retry = int(val)
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
# send update event
self.send_msg("updated", {"time": time.time()})
return action
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key == "numprocesses":
self.numprocesses = int(val)
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "flapping_attempts":
self.flapping_attempts = int(val)
action = -1
elif key == "flapping_window":
self.flapping_window = float(val)
elif key == "retry_in":
self.retry_in = float(val)
elif key == "max_retry":
self.max_retry = int(val)
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
# send update event
self.send_msg("updated", {"time": time.time()})
return action
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
if uid:
self.uid = to_uid(uid)
self.username = get_username_from_uid(self.uid)
else:
self.username = None
self.uid = 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 self.uid is not None and self.gid is None:
self.gid = get_default_gid(self.uid)
if spawn:
self.spawn()
def set_opt(self, key, val):
""" set a show option
This function set the show options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the flies;
"""
action = 0
if key == "numflies":
self.numflies = int(val)
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = util.to_bool(val)
elif key == "shell":
self.shell = util.to_bool(val)
action = 1
elif key == "env":
self.env = util.parse_env(val)
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "times":
self.times = int(val)
action = -1
elif key == "within":
self.within = float(val)
elif key == "retry_in":
self.retry_in = float(val)
elif key == "max_retry":
self.max_retry = int(val)
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
self.send_msg("updated", {"time": time.time()})
return action
def __init__(self, name, 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_stdin=True,
close_child_stdout=False, close_child_stderr=False):
self.name = name
self.wid = wid
self.cmd = cmd
self.args = args
self.working_dir = working_dir or get_working_dir()
self.shell = shell
if uid:
self.uid = to_uid(uid)
self.username = get_username_from_uid(self.uid)
else:
self.username = None
self.uid = 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_stdin = close_child_stdin
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 = []
self._worker = None
self.redirected = False
self.started = 0
if self.uid is not None and self.gid is None:
self.gid = get_default_gid(self.uid)
if IS_WINDOWS:
if not self.use_fds and (self.pipe_stderr or self.pipe_stdout):
raise ValueError("On Windows, you can't close the fds if "
"you are redirecting stdout or stderr")
if spawn:
self.spawn()
def set_opt(self, key, val):
""" set a show option
This function set the show options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the flies;
"""
action = 0
if key == "num_flies":
self.num_flies = int(val)
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = util.to_bool(val)
elif key == "shell":
self.shell = util.to_bool(val)
action = 1
elif key == "env":
self.env = util.parse_env(val)
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "times":
self.flapping.times = int(val)
action = -1
elif key == "within":
self.flapping.within = float(val)
elif key == "retry_in":
self.flapping.retry_in = float(val)
elif key == "max_retry":
self.flapping.max_retry = int(val)
return action
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 __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 __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
if uid:
self.uid = to_uid(uid)
self.username = get_username_from_uid(self.uid)
else:
self.username = None
self.uid = 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 self.uid is not None and self.gid is None:
self.gid = get_default_gid(self.uid)
if spawn:
self.spawn()
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()
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key in self._options:
self._options[key] = val
action = -1 # XXX for now does not trigger a reload
elif key == "numprocesses":
val = int(val)
if val < 0:
val = 0
if self.singleton and val > 1:
raise ValueError('Singleton watcher has a single process')
self.numprocesses = val
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "stop_signal":
self.stop_signal = util.to_signum(val)
elif key == "stop_children":
self.stop_children = util.to_bool(val)
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
if PY2 and IS_WINDOWS:
# Windows on Python 2 does not accept Unicode values
# in env dictionary
self.env = dict((b(k), b(v)) for k, v in val.iteritems())
else:
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "args":
self.args = val
action = 1
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
elif key == "max_age":
self.max_age = int(val)
action = 1
elif key == "max_age_variance":
self.max_age_variance = int(val)
action = 1
elif (key.startswith('stdout_stream')
or key.startswith('stderr_stream')):
action = self._reload_stream(key, val)
elif key.startswith('hooks'):
val = val.split(',')
if len(val) == 2:
ignore_error = util.to_bool(val[1])
else:
ignore_error = False
hook = val[0]
self._reload_hook(key, hook, ignore_error)
action = 0
# send update event
self.notify_event("updated", {"time": time.time()})
return action
def test_to_gid_str(self):
with mock.patch('grp.getgrgid') as getgrgid:
gid = to_gid('1042')
self.assertEqual(1042, gid)
getgrgid.assert_called_with(1042)
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key in self._options:
self._options[key] = val
action = -1 # XXX for now does not trigger a reload
elif key == "numprocesses":
val = int(val)
if val < 0:
val = 0
if self.singleton and val > 1:
raise ValueError('Singleton watcher has a single process')
self.numprocesses = val
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "stop_signal":
self.stop_signal = util.to_signum(val)
elif key == "stop_children":
self.stop_children = util.to_bool(val)
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
if PY2 and IS_WINDOWS:
# Windows on Python 2 does not accept Unicode values
# in env dictionary
self.env = dict((b(k), b(v)) for k, v in val.iteritems())
else:
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "args":
self.args = val
action = 1
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
elif key == "max_age":
self.max_age = int(val)
action = 1
elif key == "max_age_variance":
self.max_age_variance = int(val)
action = 1
elif (key.startswith('stdout_stream') or
key.startswith('stderr_stream')):
action = self._reload_stream(key, val)
elif key.startswith('hooks'):
val = val.split(',')
if len(val) == 2:
ignore_error = util.to_bool(val[1])
else:
ignore_error = False
hook = val[0]
self._reload_hook(key, hook, ignore_error)
action = 0
# send update event
self.notify_event("updated", {"time": time.time()})
return action
def test_to_gid_str(self):
with mock.patch('grp.getgrgid') as getgrgid:
gid = to_gid('1042')
self.assertEqual(1042, gid)
getgrgid.assert_called_with(1042)
def set_opt(self, key, val):
"""Set a watcher option.
This function set the watcher options. unknown keys are ignored.
This function return an action number:
- 0: trigger the process management
- 1: trigger a graceful reload of the processes;
"""
action = 0
if key in self._options:
self._options[key] = val
action = -1 # XXX for now does not trigger a reload
elif key == "numprocesses":
val = int(val)
if val < 0:
val = 0
if self.singleton and val > 1:
raise ValueError("Singleton watcher has a single process")
self.numprocesses = val
elif key == "warmup_delay":
self.warmup_delay = float(val)
elif key == "working_dir":
self.working_dir = val
action = 1
elif key == "uid":
self.uid = util.to_uid(val)
action = 1
elif key == "gid":
self.gid = util.to_gid(val)
action = 1
elif key == "send_hup":
self.send_hup = val
elif key == "shell":
self.shell = val
action = 1
elif key == "env":
self.env = val
action = 1
elif key == "cmd":
self.cmd = val
action = 1
elif key == "graceful_timeout":
self.graceful_timeout = float(val)
action = -1
elif key == "max_age":
self.max_age = int(val)
action = 1
elif key == "max_age_variance":
self.max_age_variance = int(val)
action = 1
elif key.startswith("stdout_stream") or key.startswith("stderr_stream"):
action = self._reload_stream(key, val)
elif key.startswith("hook"):
val = val.split(",")
if len(val) == 2:
ignore_error = util.to_bool(val[1])
else:
ignore_error = False
hook = val[0]
self._reload_hook(key, hook, ignore_error)
action = 1
# send update event
self.notify_event("updated", {"time": time.time()})
return action
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()
