class TestWatcher(TestCircus):
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.test_watcher.run_process'
self.test_file = self._run_circus(
dummy_process, stdout_stream={'stream': self.stream})
self.cli = CircusClient()
def call(self, cmd, **props):
msg = make_message(cmd, **props)
return self.cli.call(msg)
def tearDown(self):
super(TestWatcher, self).tearDown()
self.cli.stop()
def status(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('status')
def numprocesses(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('numprocesses')
def test_signal(self):
self.assertEquals(self.numprocesses('incr', name='test'), 2)
def get_pids():
return self.call('list', name='test').get('pids')
pids = get_pids()
self.assertEquals(len(pids), 2)
to_kill = pids[0]
self.assertEquals(
self.status('signal',
name='test',
pid=to_kill,
signum=signal.SIGKILL), 'ok')
time.sleep(1) # wait for the process to die
# we still should have two processes, but not the same pids for them
pids = get_pids()
self.assertEquals(len(pids), 2)
self.assertTrue(to_kill not in pids)
def test_stats(self):
resp = self.call("stats").get('infos')
self.assertTrue("test" in resp)
watchers = resp['test']
self.assertEqual(watchers[watchers.keys()[0]]['cmdline'],
sys.executable.split(os.sep)[-1])
def test_streams(self):
time.sleep(1.)
# let's see what we got
self.assertTrue(self.stream.qsize() > 1)
class TestWatcher(TestCircus):
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.test_watcher.run_process'
self.test_file = self._run_circus(
dummy_process, stdout_stream={'stream': self.stream})
self.cli = CircusClient()
def call(self, cmd, **props):
msg = make_message(cmd, **props)
return self.cli.call(msg)
def tearDown(self):
super(TestWatcher, self).tearDown()
self.cli.stop()
def status(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('status')
def numprocesses(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('numprocesses')
def testSignal(self):
self.assertEquals(self.numprocesses("incr", name="test"), 2)
self.assertEquals(
self.call("list", name="test").get('processes'), [1, 2])
self.assertEquals(
self.status("signal",
name="test",
process=2,
signum=signal.SIGKILL), "ok")
time.sleep(1.0)
self.assertEquals(
self.call("list", name="test").get('processes'), [1, 3])
processes = self.call("list", name="test").get('processes')
self.assertEquals(
self.status("signal", name="test", signum=signal.SIGKILL), "ok")
time.sleep(1.0)
self.assertNotEqual(
self.call("list", name="test").get('processes'), processes)
def testStats(self):
resp = self.call("stats").get('infos')
self.assertTrue("test" in resp)
self.assertEqual(resp['test']['1']['cmdline'],
sys.executable.split(os.sep)[-1])
def test_streams(self):
time.sleep(2.)
# let's see what we got
self.assertTrue(self.stream.qsize() > 1)
class TestWatcher(TestCircus):
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.test_watcher.run_process'
self.test_file = self._run_circus(dummy_process,
stdout_stream={'stream': self.stream})
self.cli = CircusClient()
def call(self, cmd, **props):
msg = make_message(cmd, **props)
return self.cli.call(msg)
def tearDown(self):
super(TestWatcher, self).tearDown()
self.cli.stop()
def status(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('status')
def numprocesses(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('numprocesses')
def test_signal(self):
self.assertEquals(self.numprocesses('incr', name='test'), 2)
def get_pids():
return self.call('list', name='test').get('pids')
pids = get_pids()
self.assertEquals(len(pids), 2)
to_kill = pids[0]
self.assertEquals(self.status('signal', name='test', pid=to_kill,
signum=signal.SIGKILL), 'ok')
time.sleep(1) # wait for the process to die
# we still should have two processes, but not the same pids for them
pids = get_pids()
self.assertEquals(len(pids), 2)
self.assertTrue(to_kill not in pids)
def test_stats(self):
resp = self.call("stats").get('infos')
self.assertTrue("test" in resp)
watchers = resp['test']
self.assertEqual(watchers[watchers.keys()[0]]['cmdline'],
sys.executable.split(os.sep)[-1])
def test_streams(self):
time.sleep(1.)
# let's see what we got
self.assertTrue(self.stream.qsize() > 1)
class TestWatcher(TestCircus):
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.test_watcher.run_process'
self.test_file = self._run_circus(dummy_process,
stdout_stream={'stream': self.stream})
self.cli = CircusClient()
def call(self, cmd, **props):
msg = make_message(cmd, **props)
return self.cli.call(msg)
def tearDown(self):
super(TestWatcher, self).tearDown()
self.cli.stop()
def status(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('status')
def numprocesses(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('numprocesses')
def testSignal(self):
self.assertEquals(self.numprocesses("incr", name="test"), 2)
self.assertEquals(self.call("list", name="test").get('processes'),
[1, 2])
self.assertEquals(self.status("signal", name="test", process=2,
signum=signal.SIGKILL), "ok")
time.sleep(1.0)
self.assertEquals(self.call("list", name="test").get('processes'),
[1, 3])
processes = self.call("list", name="test").get('processes')
self.assertEquals(self.status("signal", name="test",
signum=signal.SIGKILL), "ok")
time.sleep(1.0)
self.assertNotEqual(self.call("list", name="test").get('processes'),
processes)
def testStats(self):
resp = self.call("stats").get('infos')
self.assertTrue("test" in resp)
self.assertEqual(resp['test']['1']['cmdline'],
sys.executable.split(os.sep)[-1])
def test_streams(self):
time.sleep(2.)
# let's see what we got
self.assertTrue(self.stream.qsize() > 1)
class TestWatcher(TestCircus):
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.test_watcher.run_process'
self.test_file = self._run_circus(dummy_process,
stdout_stream={'stream': self.stream})
self.arbiter = self.arbiters[-1]
def status(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('status')
def numprocesses(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('numprocesses')
def pids(self):
return self.call('list', name='test').get('pids')
def test_signal(self):
self.assertEquals(self.numprocesses('incr', name='test'), 2)
pids = self.pids()
self.assertEquals(len(pids), 2)
to_kill = pids[0]
self.assertEquals(self.status('signal', name='test', pid=to_kill,
signum=signal.SIGKILL), 'ok')
time.sleep(1) # wait for the process to die
# we still should have two processes, but not the same pids for them
pids = self.pids()
self.assertEquals(len(pids), 2)
self.assertTrue(to_kill not in pids)
def test_unexisting(self):
watcher = self.arbiter.get_watcher("test")
self.assertEquals(len(watcher.processes), 1)
process = watcher.processes.values()[0]
to_kill = process.pid
# the process is killed in an unsual way
os.kill(to_kill, signal.SIGSEGV)
# and wait for it to die
try:
pid, status = os.waitpid(to_kill, 0)
except OSError:
pass
# ansure the old process is considered "unexisting"
self.assertEquals(process.status, UNEXISTING)
# this should clean up and create a new process
watcher.reap_and_manage_processes()
# we should have a new process here now
self.assertEquals(len(watcher.processes), 1)
process = watcher.processes.values()[0]
# and that one needs to have a new pid.
self.assertNotEqual(process.pid, to_kill)
# and should not be unexisting...
self.assertNotEqual(process.status, UNEXISTING)
def test_stats(self):
resp = self.call("stats").get('infos')
self.assertTrue("test" in resp)
watchers = resp['test']
self.assertEqual(watchers[watchers.keys()[0]]['cmdline'],
sys.executable.split(os.sep)[-1])
def test_streams(self):
time.sleep(1.)
# let's see what we got
self.assertTrue(self.stream.qsize() > 1)
def test_max_age(self):
result = self.call('set', name='test',
options={'max_age': 1, 'max_age_variance': 0})
self.assertEquals(result.get('status'), 'ok')
initial_pids = self.pids()
time.sleep(3.0) # allow process to reach max_age and restart
current_pids = self.pids()
self.assertEqual(len(current_pids), 1)
self.assertNotEqual(initial_pids, current_pids)
def test_arbiter_reference(self):
self.assertEqual(self.arbiters[0].watchers[0].arbiter,
self.arbiters[0])
class TestWatcher(TestCircus):
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.test_watcher.run_process'
self.test_file = self._run_circus(
dummy_process, stdout_stream={'stream': self.stream})
self.arbiter = self.arbiters[-1]
self.cli = CircusClient()
def call(self, cmd, **props):
msg = make_message(cmd, **props)
return self.cli.call(msg)
def tearDown(self):
super(TestWatcher, self).tearDown()
self.cli.stop()
def status(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('status')
def numprocesses(self, cmd, **props):
resp = self.call(cmd, **props)
return resp.get('numprocesses')
def pids(self):
return self.call('list', name='test').get('pids')
def test_signal(self):
self.assertEquals(self.numprocesses('incr', name='test'), 2)
pids = self.pids()
self.assertEquals(len(pids), 2)
to_kill = pids[0]
self.assertEquals(
self.status('signal',
name='test',
pid=to_kill,
signum=signal.SIGKILL), 'ok')
time.sleep(1) # wait for the process to die
# we still should have two processes, but not the same pids for them
pids = self.pids()
self.assertEquals(len(pids), 2)
self.assertTrue(to_kill not in pids)
def test_unexisting(self):
watcher = self.arbiter.get_watcher("test")
self.assertEquals(len(watcher.processes), 1)
process = watcher.processes.values()[0]
to_kill = process.pid
# the process is killed in an unsual way
os.kill(to_kill, signal.SIGSEGV)
# and wait for it to die
pid, status = os.waitpid(to_kill, 0)
# ansure the old process is considered "unexisting"
self.assertEquals(process.status, UNEXISTING)
# this should clean up and create a new process
watcher.reap_and_manage_processes()
# we should have a new process here now
self.assertEquals(len(watcher.processes), 1)
process = watcher.processes.values()[0]
# and that one needs to have a new pid.
self.assertNotEqual(process.pid, to_kill)
# and should not be unexisting...
self.assertNotEqual(process.status, UNEXISTING)
def test_stats(self):
resp = self.call("stats").get('infos')
self.assertTrue("test" in resp)
watchers = resp['test']
self.assertEqual(watchers[watchers.keys()[0]]['cmdline'],
sys.executable.split(os.sep)[-1])
def test_streams(self):
time.sleep(1.)
# let's see what we got
self.assertTrue(self.stream.qsize() > 1)
def test_max_age(self):
result = self.call('set',
name='test',
options={
'max_age': 1,
'max_age_variance': 0
})
self.assertEquals(result.get('status'), 'ok')
initial_pids = self.pids()
time.sleep(3.0) # allow process to reach max_age and restart
current_pids = self.pids()
self.assertEqual(len(current_pids), 1)
self.assertNotEqual(initial_pids, current_pids)
