def run_with_hooks(self, hooks):
self.stream = QueueStream()
self.errstream = QueueStream()
dummy_process = 'circus.tests.support.run_process'
return self._create_circus(dummy_process,
stdout_stream={'stream': self.stream},
stderr_stream={'stream': self.errstream},
hooks=hooks)
def setUpClass(cls):
dummy_process = 'circus.tests.support.run_process'
cls.stream = QueueStream()
testfile, arbiter = cls._create_circus(
dummy_process, stdout_stream={'stream': cls.stream})
cls.arbiter = arbiter
cls.test_file = testfile
def test_copy_path(self):
stream = QueueStream()
qstream = {'stream': stream}
old_environ = os.environ
old_paths = sys.path[:]
try:
sys.path = ['XYZ']
os.environ = {'COCONUTS': 'MIGRATE'}
cmd = ('%s -c "import sys; '
'sys.stdout.write(\':\'.join(sys.path)); '
' sys.stdout.flush()"') % sys.executable
watcher = Watcher('xx',
cmd,
copy_env=True,
copy_path=True,
stdout_stream=qstream)
watcher.start()
time.sleep(3.)
watcher.stop()
data = [v for k, v in stream.get().items()][1]
data = ''.join(data)
self.assertTrue('XYZ' in data, data)
finally:
os.environ = old_environ
sys.path[:] = old_paths
def setUp(self):
super(TestWatcher, self).setUp()
self.stream = QueueStream()
dummy_process = 'circus.tests.support.run_process'
self.test_file = self._run_circus(
dummy_process, stdout_stream={'stream': self.stream})
self.arbiter = self.arbiters[-1]
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 __init__(self, loop=None, **kw):
self.stream = QueueStream()
self.watcher = None
self.kw = kw
if loop is None:
self.loop = tornado.ioloop.IOLoop().instance()
else:
self.loop = loop
def run_with_hooks(self, hooks, streams=False):
if streams:
self.stream = QueueStream()
self.errstream = QueueStream()
stdout_stream = {'stream': self.stream}
stderr_stream = {'stream': self.errstream}
else:
self.stream = None
self.errstream = None
stdout_stream = None
stderr_stream = None
dummy_process = 'circus.tests.support.run_process'
return self._create_circus(dummy_process,
stdout_stream=stdout_stream,
stderr_stream=stderr_stream,
hooks=hooks, debug=True, async=True)
def setUp(self):
TestCircus.setUp(self)
self.app = TestApp(app)
self.stream = QueueStream()
# let's run a circus
cmd = [sys.executable, "-c",
"from circus import circusd; circusd.main()", cfg]
self.p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
def setUp(self):
TestCircus.setUp(self)
self.app = TestApp(app)
self.stream = QueueStream()
# let's run a circus
cmd = '%s -c "from circus import circusd; circusd.main()" %s' % \
(sys.executable, cfg)
self.p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
def __init__(self, stream=False, loop=None, **kw):
if stream:
self.stream = QueueStream()
else:
self.stream = None
self.watcher = None
self.kw = kw
if loop is None:
self.loop = tornado.ioloop.IOLoop.current()
else:
self.loop = loop
def setUp(self):
TestCircus.setUp(self)
self.app = TestApp(app)
self.stream = QueueStream()
# let's run a circus
cmd = [sys.executable, "-c",
"from circus import circusd; circusd.main()", cfg]
self.p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# Start auto discovery thread
setup_auto_discovery(DEFAULT_ENDPOINT_MULTICAST)
def test_inherited(self):
cmd = 'circus.tests.test_umask.run_process'
stream = QueueStream()
stdout_stream = {'stream': stream}
yield self.start_arbiter(cmd=cmd, stdout_stream=stdout_stream)
res = yield read_from_stream(stream)
self.assertEqual(res, 'Done')
yield self.stop_arbiter()
self.assertTrue(os.path.isdir(self.test_file))
mode = oct(os.stat(self.test_file).st_mode)[-3:]
self.assertEqual(mode, '755')
def start_arbiter(self,
cmd='circus.tests.support.run_process',
stdout_stream=None,
**kw):
if stdout_stream is None:
self.stream = QueueStream()
stdout_stream = {'stream': self.stream}
testfile, arbiter = self._create_circus(cmd,
stdout_stream=stdout_stream,
debug=True,
async=True,
**kw)
self.test_file = testfile
self.arbiter = arbiter
yield self.arbiter.start()
def test_stdin_socket(self):
cmd = 'circus.tests.test_stdin_socket.run_process'
stream = QueueStream()
stdout_stream = {'stream': stream}
sk = CircusSocket(name='test', host='localhost', port=0)
yield self.start_arbiter(cmd=cmd,
stdout_stream=stdout_stream,
arbiter_kw={'sockets': [sk]},
stdin_socket='test',
use_sockets=True)
# check same socket in child fd 0
addr_string_actual = yield read_from_stream(stream)
addr_string_expected = "%s %s" % (sk.host, sk.port)
self.assertEqual(addr_string_actual, addr_string_expected)
yield self.stop_arbiter()
def test_handler(self):
stream = QueueStream()
cmd = 'circus.tests.test_command_signal.run_process'
stdout_stream = {'stream': stream}
stderr_stream = {'stream': stream}
yield self.start_arbiter(cmd=cmd, stdout_stream=stdout_stream,
stderr_stream=stderr_stream, stats=True,
stop_signal=signal.SIGINT,
debug=False)
# waiting for data to appear in the queue
data = yield read_from_stream(stream, 0)
self.assertEqual('STARTED', data)
# waiting for children
data = yield read_from_stream(stream, 3)
self.assertEqual('STARTED', data)
data = yield read_from_stream(stream, 2)
self.assertEqual('STARTED', data)
data = yield read_from_stream(stream, 1)
self.assertEqual('STARTED', data)
# checking that our system is live and running
client = AsyncCircusClient(endpoint=self.arbiter.endpoint)
res = yield client.send_message('list')
watchers = sorted(res['watchers'])
self.assertEqual(['circusd-stats', 'test'], watchers)
# send USR1 to parent only
res = yield client.send_message('signal', name='test', signum='usr1')
self.assertEqual(res['status'], 'ok')
res = yield read_from_stream(stream, 0)
self.assertEqual(res, 'USR1')
# send USR2 to children only
res = yield client.send_message('signal', name='test', signum='usr2',
children=True)
self.assertEqual(res['status'], 'ok')
res = yield read_from_stream(stream, 1)
self.assertEqual(res, 'USR2')
res = yield read_from_stream(stream, 2)
self.assertEqual(res, 'USR2')
res = yield read_from_stream(stream, 3)
self.assertEqual(res, 'USR2')
# send HUP to parent and children
res = yield client.send_message('signal', name='test', signum='hup',
recursive=True)
self.assertEqual(res['status'], 'ok')
res = yield read_from_stream(stream, 0)
self.assertEqual(res, 'HUP')
res = yield read_from_stream(stream, 1)
self.assertEqual(res, 'HUP')
res = yield read_from_stream(stream, 2)
self.assertEqual(res, 'HUP')
res = yield read_from_stream(stream, 3)
self.assertEqual(res, 'HUP')
# stop process
res = yield client.send_message('stop', name='test')
self.assertEqual(res['status'], 'ok')
res = yield read_from_stream(stream, 0)
self.assertEqual(res, 'INT')
res = yield read_from_stream(stream, 0)
self.assertEqual(res, 'EXITING')
res = yield read_from_stream(stream, 1)
self.assertEqual(res, 'TERM')
res = yield read_from_stream(stream, 1)
self.assertEqual(res, 'EXITING')
res = yield read_from_stream(stream, 2)
self.assertEqual(res, 'TERM')
res = yield read_from_stream(stream, 2)
self.assertEqual(res, 'EXITING')
res = yield read_from_stream(stream, 3)
self.assertEqual(res, 'TERM')
res = yield read_from_stream(stream, 3)
self.assertEqual(res, 'EXITING')
timeout = time.time() + 5
stopped = False
while time.time() < timeout:
res = yield client.send_message('status', name='test')
if res['status'] == 'stopped':
stopped = True
break
self.assertEqual(res['status'], 'stopping')
self.assertTrue(stopped)
yield self.stop_arbiter()
def setUp(self):
super(KillCommandTest, self).setUp()
self.stream = QueueStream()
self.reader = StreamReader(self.stream)
self._client = None
def run_with_hooks(self, hooks):
self.stream = QueueStream()
dummy_process = 'circus.tests.support.run_process'
self._run_circus(dummy_process,
stdout_stream={'stream': self.stream},
hooks=hooks)
def __init__(self, **kw):
threading.Thread.__init__(self)
self.stream = QueueStream()
self.loop = self.watcher = None
self.kw = kw
