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, name, cmd, num_flies=1, warmup_delay=0.,
working_dir=None, shell=False, uid=None,
gid=None, send_hup=False, env=None, stopped=False,
times=2, within=1., retry_in=7., max_retry=5):
self.name = name
self.num_flies = int(num_flies)
self.warmup_delay = warmup_delay
self.cmd = cmd
self._fly_counter = 0
self.stopped = stopped
self.max_retry = max_retry
self.optnames = ("num_flies", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "shell", "env",
"cmd", "times", "within", "retry_in",
"max_retry")
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.flies = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.send_hup = send_hup
# define flapping object
self.flapping = Flapping(self, times, within, retry_in, max_retry)
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,
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 __init__(self, name, cmd, args=None, numprocesses=1, warmup_delay=0.,
working_dir=None, shell=False, uid=None,
gid=None, send_hup=False, env=None, stopped=True,
flapping_attempts=2, flapping_window=1., retry_in=7.,
max_retry=5,
graceful_timeout=30., prereload_fn=None,
rlimits=None, executable=None, stdout_stream=None,
stderr_stream=None, stream_backend='thread'):
self.name = name
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.flapping_attempts = flapping_attempts
self.flapping_window = flapping_window
self.retry_in = retry_in
self.max_retry = max_retry
self.graceful_timeout = 30
self.prereload_fn = prereload_fn
self.executable = None
self.stream_backend = stream_backend
self.stdout_stream = stdout_stream
if stdout_stream:
self.stdout_redirector = get_pipe_redirector(stdout_stream,
backend=stream_backend)
else:
self.stdout_redirector = None
self.stderr_stream = stderr_stream
if stderr_stream:
self.stderr_redirector = get_pipe_redirector(stderr_stream,
backend=stream_backend)
else:
self.stderr_redirector = None
self.optnames = ("numprocesses", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "shell", "env",
"cmd", "flapping_attempts", "flapping_window",
"retry_in", "args",
"max_retry", "graceful_timeout", "executable")
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.rlimits = rlimits
self.send_hup = send_hup
self.evpub_socket = None
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 __init__(self, name, cmd, args=None, numprocesses=1, warmup_delay=0.,
working_dir=None, shell=False, uid=None, max_retry=5,
gid=None, send_hup=False, env=None, stopped=True,
graceful_timeout=30., prereload_fn=None,
rlimits=None, executable=None, stdout_stream=None,
stderr_stream=None, stream_backend='thread', priority=0,
singleton=False, use_sockets=False, **options):
self.name = name
self.use_sockets = use_sockets
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.graceful_timeout = graceful_timeout
self.prereload_fn = prereload_fn
self.executable = None
self.stream_backend = stream_backend
self.priority = priority
self.stdout_stream_conf = stdout_stream
self.stderr_stream_conf = stderr_stream
self.stdout_stream = get_stream(self.stdout_stream_conf)
self.stderr_stream = get_stream(self.stderr_stream_conf)
self.stdout_redirector = self.stderr_redirector = None
self.max_retry = max_retry
self._options = options
self.singleton = singleton
if singleton and self.numprocesses not in (0, 1):
raise ValueError("Cannot have %d processes with a singleton "
" watcher" % self.numprocesses)
self.optnames = (("numprocesses", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "shell", "env", "max_retry",
"cmd", "args", "graceful_timeout", "executable",
"use_sockets", "priority",
"singleton", "stdout_stream_conf", "stderr_stream_conf")
+ tuple(options.keys()))
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.rlimits = rlimits
self.send_hup = send_hup
self.sockets = self.evpub_socket = None
def test_working_dir_return_pwd_when_paths_are_equals(self):
def _stat(path):
stat = mock.MagicMock()
stat.ino = 'path'
stat.dev = 'dev'
return stat
_old_os_stat = util.os.stat
try:
util.os.stat = _stat
self.assertEqual(get_working_dir(), '/path/to/pwd')
finally:
util.os.stat = _old_os_stat
def test_working_dir_return_pwd_when_paths_are_equals(self):
def _stat(path):
stat = mock.MagicMock()
stat.ino = 'path'
stat.dev = 'dev'
return stat
_old_os_stat = util.os.stat
try:
util.os.stat = _stat
self.assertEqual(get_working_dir(), '/path/to/pwd')
finally:
util.os.stat = _old_os_stat
def test_working_dir_return_pwd_when_paths_are_equals(self):
def _stat(path):
stat = mock.MagicMock()
stat.ino = "path"
stat.dev = "dev"
return stat
try:
_old_os_stat = util.os.stat
util.os.stat = _stat
self.assertEquals(get_working_dir(), "/path/to/pwd")
finally:
util.os.stat = _old_os_stat
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, 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 __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,
name,
cmd,
num_flies=1,
warmup_delay=0.,
working_dir=None,
shell=False,
uid=None,
gid=None,
send_hup=False,
env=None,
stopped=False,
times=2,
within=1.,
retry_in=7.,
max_retry=5):
self.name = name
self.num_flies = int(num_flies)
self.warmup_delay = warmup_delay
self.cmd = cmd
self._fly_counter = 0
self.stopped = stopped
self.max_retry = max_retry
self.optnames = ("num_flies", "warmup_delay", "working_dir", "uid",
"gid", "send_hup", "shell", "env", "cmd", "times",
"within", "retry_in", "max_retry")
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.flies = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.send_hup = send_hup
# define flapping object
self.flapping = Flapping(self, times, within, retry_in, max_retry)
def __init__(self, name, cmd, args=None, numprocesses=1, warmup_delay=0.,
working_dir=None, shell=False, uid=None,
gid=None, send_hup=False, env=None, stopped=True,
times=2, within=1., retry_in=7., max_retry=5,
graceful_timeout=30., prereload_fn=None,
rlimits=None, executable=None):
""" init
"""
self.name = name
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.times = times
self.within = within
self.retry_in = retry_in
self.max_retry = max_retry
self.graceful_timeout = 30
self.prereload_fn = prereload_fn
self.executable = None
self.optnames = ("numprocesses", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "shell", "env",
"cmd", "times", "within", "retry_in", "args",
"max_retry", "graceful_timeout", "executable")
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.rlimits = rlimits
self.send_hup = send_hup
self.evpub_socket = None
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()
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,
name,
cmd,
args=None,
numprocesses=1,
warmup_delay=0.,
working_dir=None,
shell=False,
shell_args=None,
uid=None,
max_retry=5,
gid=None,
send_hup=False,
stop_signal=signal.SIGTERM,
stop_children=False,
env=None,
graceful_timeout=30.0,
prereload_fn=None,
rlimits=None,
executable=None,
stdout_stream=None,
stderr_stream=None,
priority=0,
loop=None,
singleton=False,
use_sockets=False,
copy_env=False,
copy_path=False,
max_age=0,
max_age_variance=30,
hooks=None,
respawn=True,
autostart=True,
on_demand=False,
virtualenv=None,
stdin_socket=None,
close_child_stdin=True,
close_child_stdout=False,
close_child_stderr=False,
virtualenv_py_ver=None,
use_papa=False,
**options):
self.name = name
self.use_sockets = use_sockets
self.on_demand = on_demand
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._status = "stopped"
self.graceful_timeout = float(graceful_timeout)
self.prereload_fn = prereload_fn
self.executable = None
self.priority = priority
self.stdout_stream_conf = copy.copy(stdout_stream)
self.stderr_stream_conf = copy.copy(stderr_stream)
self.stdout_stream = get_stream(self.stdout_stream_conf)
self.stderr_stream = get_stream(self.stderr_stream_conf)
self.stream_redirector = None
self.max_retry = int(max_retry)
self._options = options
self.singleton = singleton
self.copy_env = copy_env
self.copy_path = copy_path
self.virtualenv = virtualenv
self.virtualenv_py_ver = virtualenv_py_ver
self.max_age = int(max_age)
self.max_age_variance = int(max_age_variance)
self.ignore_hook_failure = [
'before_stop', 'after_stop', 'before_signal', 'after_signal',
'extended_stats'
]
self.respawn = respawn
self.autostart = autostart
self.stdin_socket = stdin_socket
self.close_child_stdin = close_child_stdin
self.close_child_stdout = close_child_stdout
self.close_child_stderr = close_child_stderr
self.use_papa = use_papa and papa is not None
self.loop = loop or ioloop.IOLoop.instance()
if singleton and self.numprocesses not in (0, 1):
raise ValueError("Cannot have %d processes with a singleton "
" watcher" % self.numprocesses)
if IS_WINDOWS:
if self.stdout_stream or self.stderr_stream:
raise NotImplementedError("Streams are not supported"
" on Windows.")
if not copy_env and not env:
# Copy the env by default on Windows as we can't run any
# executable without some env variables
# Eventually, we could set only some required variables,
# such as SystemRoot
self.copy_env = True
self.optnames = (
("numprocesses", "warmup_delay", "working_dir", "uid", "gid",
"send_hup", "stop_signal", "stop_children", "shell", "shell_args",
"env", "max_retry", "cmd", "args", "respawn", "graceful_timeout",
"executable", "use_sockets", "priority", "copy_env", "singleton",
"stdout_stream_conf", "on_demand", "stderr_stream_conf",
"max_age", "max_age_variance", "close_child_stdin",
"close_child_stdout", "close_child_stderr", "use_papa") +
tuple(options.keys()))
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.shell_args = shell_args
self.uid = uid
self.gid = gid
if self.copy_env:
self.env = os.environ.copy()
if self.copy_path:
path = os.pathsep.join(sys.path)
self.env['PYTHONPATH'] = path
if env is not None:
self.env.update(env)
else:
if self.copy_path:
raise ValueError(('copy_env and copy_path must have the '
'same value'))
self.env = env
if self.virtualenv:
util.load_virtualenv(self, py_ver=virtualenv_py_ver)
# load directories in PYTHONPATH if provided
# so if a hook is there, it can be loaded
if self.env is not None and 'PYTHONPATH' in self.env:
for path in self.env['PYTHONPATH'].split(os.pathsep):
if path in sys.path:
continue
site.addsitedir(path)
self.rlimits = rlimits
self.send_hup = send_hup
self.stop_signal = stop_signal
self.stop_children = stop_children
self.sockets = self.evpub_socket = None
self.arbiter = None
self.hooks = {}
self._resolve_hooks(hooks)
self._found_wids = []
if self.use_papa:
with papa.Papa() as p:
base_name = 'circus.{0}.*'.format(name.lower())
running = p.list_processes(base_name)
self._found_wids = [
int(proc_name[len(base_name) - 1:])
for proc_name in running
]
def __init__(self, name, cmd, args=None, numprocesses=1, warmup_delay=0.,
working_dir=None, shell=False, uid=None, max_retry=5,
gid=None, send_hup=False, env=None, stopped=True,
graceful_timeout=30., prereload_fn=None,
rlimits=None, executable=None, stdout_stream=None,
stderr_stream=None, priority=0, loop=None,
singleton=False, use_sockets=False, copy_env=False,
copy_path=False, max_age=0, max_age_variance=30,
hooks=None, respawn=True, autostart=True, **options):
self.name = name
self.use_sockets = use_sockets
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.graceful_timeout = float(graceful_timeout)
self.prereload_fn = prereload_fn
self.executable = None
self.priority = priority
self.stdout_stream_conf = copy.copy(stdout_stream)
self.stderr_stream_conf = copy.copy(stderr_stream)
self.stdout_stream = get_stream(self.stdout_stream_conf)
self.stderr_stream = get_stream(self.stderr_stream_conf)
self.stdout_redirector = self.stderr_redirector = None
self.max_retry = max_retry
self._options = options
self.singleton = singleton
self.copy_env = copy_env
self.copy_path = copy_path
self.max_age = int(max_age)
self.max_age_variance = int(max_age_variance)
self.ignore_hook_failure = ['before_stop', 'after_stop']
self.hooks = self._resolve_hooks(hooks)
self.respawn = respawn
self.autostart = autostart
self.loop = loop or ioloop.IOLoop.instance()
if singleton and self.numprocesses not in (0, 1):
raise ValueError("Cannot have %d processes with a singleton "
" watcher" % self.numprocesses)
self.optnames = (("numprocesses", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "shell", "env",
"max_retry", "cmd", "args", "graceful_timeout",
"executable", "use_sockets", "priority", "copy_env",
"singleton", "stdout_stream_conf",
"stderr_stream_conf", "max_age", "max_age_variance")
+ tuple(options.keys()))
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
if self.copy_env:
self.env = os.environ.copy()
if self.copy_path:
path = os.pathsep.join(sys.path)
self.env['PYTHONPATH'] = path
if env is not None:
self.env.update(env)
else:
if self.copy_path:
raise ValueError(('copy_env and copy_path must have the '
'same value'))
self.env = env
self.rlimits = rlimits
self.send_hup = send_hup
self.sockets = self.evpub_socket = None
self.arbiter = None
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 __init__(self,
name,
cmd,
args=None,
numprocesses=1,
warmup_delay=0.,
working_dir=None,
shell=False,
uid=None,
max_retry=5,
gid=None,
send_hup=False,
env=None,
stopped=True,
graceful_timeout=30.,
prereload_fn=None,
rlimits=None,
executable=None,
stdout_stream=None,
stderr_stream=None,
stream_backend='thread',
priority=0,
singleton=False,
use_sockets=False,
**options):
self.name = name
self.use_sockets = use_sockets
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.graceful_timeout = graceful_timeout
self.prereload_fn = prereload_fn
self.executable = None
self.stream_backend = stream_backend
self.priority = priority
self.stdout_stream = get_stream(stdout_stream)
self.stderr_stream = get_stream(stderr_stream)
self.stdout_redirector = self.stderr_redirector = None
self.max_retry = max_retry
self._options = options
self.singleton = singleton
if singleton and self.numprocesses not in (0, 1):
raise ValueError("Cannot have %d processes with a singleton "
" watcher" % self.numprocesses)
self.optnames = ("numprocesses", "warmup_delay", "working_dir", "uid",
"gid", "send_hup", "shell", "env", "max_retry", "cmd",
"args", "graceful_timeout", "executable",
"use_sockets", "priority", "singleton") + tuple(
options.keys())
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.rlimits = rlimits
self.send_hup = send_hup
self.sockets = self.evpub_socket = None
def __init__(self, name, cmd, args=None, numprocesses=1, warmup_delay=0.,
working_dir=None, shell=False, uid=None,
gid=None, send_hup=False, env=None, stopped=True,
flapping_attempts=2, flapping_window=1., retry_in=7.,
max_retry=5,
graceful_timeout=30., prereload_fn=None,
rlimits=None, executable=None, stdout_stream=None,
stderr_stream=None, stream_backend='thread', priority=0):
self.name = name
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.flapping_attempts = flapping_attempts
self.flapping_window = flapping_window
self.retry_in = retry_in
self.max_retry = max_retry
self.graceful_timeout = 30
self.prereload_fn = prereload_fn
self.executable = None
self.stream_backend = stream_backend
self.priority = priority
self.stdout_stream = stdout_stream
if stdout_stream:
self.stdout_redirector = get_pipe_redirector(stdout_stream,
backend=stream_backend)
else:
self.stdout_redirector = None
self.stderr_stream = stderr_stream
if stderr_stream:
self.stderr_redirector = get_pipe_redirector(stderr_stream,
backend=stream_backend)
else:
self.stderr_redirector = None
self.optnames = ("numprocesses", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "shell", "env",
"cmd", "flapping_attempts", "flapping_window",
"retry_in", "args",
"max_retry", "graceful_timeout", "executable",
"priority")
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.pids = {}
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
self.env = env
self.rlimits = rlimits
self.send_hup = send_hup
self.evpub_socket = None
def __init__(self, name, cmd, args=None, numprocesses=1, warmup_delay=0.,
working_dir=None, shell=False, shell_args=None, uid=None,
max_retry=5, gid=None, send_hup=False,
stop_signal=signal.SIGTERM, stop_children=False, env=None,
graceful_timeout=30.0, prereload_fn=None, rlimits=None,
executable=None, stdout_stream=None, stderr_stream=None,
priority=0, loop=None, singleton=False, use_sockets=False,
copy_env=False, copy_path=False, max_age=0,
max_age_variance=30, hooks=None, respawn=True,
autostart=True, on_demand=False, virtualenv=None,
stdin_socket=None, close_child_stdin=True,
close_child_stdout=False,
close_child_stderr=False, virtualenv_py_ver=None,
use_papa=False, **options):
self.name = name
self.use_sockets = use_sockets
self.on_demand = on_demand
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._status = "stopped"
self.graceful_timeout = float(graceful_timeout)
self.prereload_fn = prereload_fn
self.executable = None
self.priority = priority
self.stdout_stream_conf = copy.copy(stdout_stream)
self.stderr_stream_conf = copy.copy(stderr_stream)
self.stdout_stream = get_stream(self.stdout_stream_conf)
self.stderr_stream = get_stream(self.stderr_stream_conf)
self.stream_redirector = None
self.max_retry = int(max_retry)
self._options = options
self.singleton = singleton
self.copy_env = copy_env
self.copy_path = copy_path
self.virtualenv = virtualenv
self.virtualenv_py_ver = virtualenv_py_ver
self.max_age = int(max_age)
self.max_age_variance = int(max_age_variance)
self.ignore_hook_failure = ['before_stop', 'after_stop',
'before_signal', 'after_signal',
'extended_stats']
self.respawn = respawn
self.autostart = autostart
self.stdin_socket = stdin_socket
self.close_child_stdin = close_child_stdin
self.close_child_stdout = close_child_stdout
self.close_child_stderr = close_child_stderr
self.use_papa = use_papa and papa is not None
self.loop = loop or ioloop.IOLoop.instance()
if singleton and self.numprocesses not in (0, 1):
raise ValueError("Cannot have %d processes with a singleton "
" watcher" % self.numprocesses)
if IS_WINDOWS:
if self.stdout_stream or self.stderr_stream:
raise NotImplementedError("Streams are not supported"
" on Windows.")
if not copy_env and not env:
# Copy the env by default on Windows as we can't run any
# executable without some env variables
# Eventually, we could set only some required variables,
# such as SystemRoot
self.copy_env = True
self.optnames = (("numprocesses", "warmup_delay", "working_dir",
"uid", "gid", "send_hup", "stop_signal",
"stop_children", "shell", "shell_args",
"env", "max_retry", "cmd", "args", "respawn",
"graceful_timeout", "executable", "use_sockets",
"priority", "copy_env", "singleton",
"stdout_stream_conf", "on_demand",
"stderr_stream_conf", "max_age", "max_age_variance",
"close_child_stdin", "close_child_stdout",
"close_child_stderr", "use_papa") +
tuple(options.keys()))
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.shell_args = shell_args
self.uid = uid
self.gid = gid
if self.copy_env:
self.env = os.environ.copy()
if self.copy_path:
path = os.pathsep.join(sys.path)
self.env['PYTHONPATH'] = path
if env is not None:
self.env.update(env)
else:
if self.copy_path:
raise ValueError(('copy_env and copy_path must have the '
'same value'))
self.env = env
if self.virtualenv:
util.load_virtualenv(self, py_ver=virtualenv_py_ver)
# load directories in PYTHONPATH if provided
# so if a hook is there, it can be loaded
if self.env is not None and 'PYTHONPATH' in self.env:
for path in self.env['PYTHONPATH'].split(os.pathsep):
if path in sys.path:
continue
site.addsitedir(path)
self.rlimits = rlimits
self.send_hup = send_hup
self.stop_signal = stop_signal
self.stop_children = stop_children
self.sockets = self.evpub_socket = None
self.arbiter = None
self.hooks = {}
self._resolve_hooks(hooks)
self._found_wids = []
if self.use_papa:
with papa.Papa() as p:
base_name = 'circus.{0}.*'.format(name.lower())
running = p.list_processes(base_name)
self._found_wids = [int(proc_name[len(base_name) - 1:])
for proc_name in running]
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 __init__(self,
name,
cmd,
args=None,
numprocesses=1,
warmup_delay=0.,
working_dir=None,
shell=False,
uid=None,
max_retry=5,
gid=None,
send_hup=False,
env=None,
stopped=True,
graceful_timeout=30.,
prereload_fn=None,
rlimits=None,
executable=None,
stdout_stream=None,
stderr_stream=None,
priority=0,
loop=None,
singleton=False,
use_sockets=False,
copy_env=False,
copy_path=False,
max_age=0,
max_age_variance=30,
hooks=None,
respawn=True,
autostart=True,
on_demand=False,
virtualenv=None,
close_child_stdout=False,
close_child_stderr=False,
**options):
self.name = name
self.use_sockets = use_sockets
self.on_demand = on_demand
self.res_name = name.lower().replace(" ", "_")
self.numprocesses = int(numprocesses)
self.warmup_delay = warmup_delay
self.cmd = cmd
self.args = args
self._process_counter = 0
self.stopped = stopped
self.graceful_timeout = float(graceful_timeout)
self.prereload_fn = prereload_fn
self.executable = None
self.priority = priority
self.stdout_stream_conf = copy.copy(stdout_stream)
self.stderr_stream_conf = copy.copy(stderr_stream)
self.stdout_stream = get_stream(self.stdout_stream_conf)
self.stderr_stream = get_stream(self.stderr_stream_conf)
self.stdout_redirector = self.stderr_redirector = None
self.max_retry = max_retry
self._options = options
self.singleton = singleton
self.copy_env = copy_env
self.copy_path = copy_path
self.virtualenv = virtualenv
self.max_age = int(max_age)
self.max_age_variance = int(max_age_variance)
self.ignore_hook_failure = ['before_stop', 'after_stop']
self.hooks = self._resolve_hooks(hooks)
self.respawn = respawn
self.autostart = autostart
self.close_child_stdout = close_child_stdout
self.close_child_stderr = close_child_stderr
self.loop = loop or ioloop.IOLoop.instance()
if singleton and self.numprocesses not in (0, 1):
raise ValueError("Cannot have %d processes with a singleton "
" watcher" % self.numprocesses)
self.optnames = (
("numprocesses", "warmup_delay", "working_dir", "uid", "gid",
"send_hup", "shell", "env", "max_retry", "cmd", "args",
"graceful_timeout", "executable", "use_sockets", "priority",
"copy_env", "singleton", "stdout_stream_conf", "on_demand",
"stderr_stream_conf", "max_age", "max_age_variance",
"close_child_stdout", "close_child_stderr") +
tuple(options.keys()))
if not working_dir:
# working dir hasn't been set
working_dir = util.get_working_dir()
self.working_dir = working_dir
self.processes = {}
self.shell = shell
self.uid = uid
self.gid = gid
if self.copy_env:
self.env = os.environ.copy()
if self.copy_path:
path = os.pathsep.join(sys.path)
self.env['PYTHONPATH'] = path
if env is not None:
self.env.update(env)
else:
if self.copy_path:
raise ValueError(('copy_env and copy_path must have the '
'same value'))
self.env = env
if self.virtualenv:
util.load_virtualenv(self)
self.rlimits = rlimits
self.send_hup = send_hup
self.sockets = self.evpub_socket = None
self.arbiter = None
