def start(self):
"""Starts the broker.
"""
logger.debug('Starting the loop')
if self.started:
return
# running the heartbeat
if self.pong is not None:
self.pong.start()
# running the cleaner
self.cleaner = ioloop.PeriodicCallback(self.ctrl.clean, 2500,
self.loop)
self.cleaner.start()
self.started = True
while self.started:
try:
self.loop.start()
except zmq.ZMQError as e:
logger.debug(str(e))
if e.errno == errno.EINTR:
continue
elif e.errno == zmq.ETERM:
break
else:
logger.debug("got an unexpected error %s (%s)", str(e),
e.errno)
raise
else:
break
def _execute(self):
# calling the clients now
self.test_result.startTestRun()
detached = self.args.get('detach')
if not detached:
cb = ioloop.PeriodicCallback(self.refresh, self.refresh_rate,
self.loop)
cb.start()
try:
self._attach_publisher()
logger.debug('Calling the broker...')
res = self.client.run(self.args)
self.run_id = res['run_id']
self.agents = res['agents']
if not detached:
logger.debug('Waiting for results')
self.loop.start()
else:
logger.info('Detached. run --attach to reattach')
finally:
if not detached:
# end..
cb.stop()
self.test_result.stopTestRun()
self.context.destroy()
self.flush()
def __init__(self,
endpoint=DEFAULT_HEARTBEAT,
interval=10.,
io_loop=None,
ctx=None,
register=5,
onregister=None):
self.loop = io_loop or ioloop.IOLoop.instance()
self.daemon = True
self.kill_context = ctx is None
self.context = ctx or zmq.Context()
self.endpoint = endpoint
self.running = False
self.interval = interval
logger.debug('Publishing to ' + self.endpoint)
self._endpoint = self.context.socket(zmq.PUB)
self._endpoint.linger = 0
self._endpoint.hwm = 0
self._endpoint.bind(self.endpoint)
self._cb = ioloop.PeriodicCallback(self._ping,
interval * 1000,
io_loop=self.loop)
self.register = register
self.current_register = 0
self.onregister = onregister
def _initialize(self):
logger.debug('Subscribing to ' + self.endpoint)
self._endpoint = self.context.socket(zmq.SUB)
self._endpoint.setsockopt(zmq.SUBSCRIBE, '')
self._endpoint.linger = 0
#self._endpoint.identity = str(os.getpid())
self._endpoint.connect(self.endpoint)
self._stream = zmqstream.ZMQStream(self._endpoint, self.loop)
self._stream.on_recv(self._handle_recv)
self._timer = ioloop.PeriodicCallback(self._delayed,
self.delay * 1000,
io_loop=self.loop)
def _initialize(self):
self.directory = self.params['directory']
self.sync_delay = self.params['sync_delay']
if not os.path.exists(self.directory):
os.makedirs(self.directory)
self._buffer = defaultdict(Queue)
self._callback = ioloop.PeriodicCallback(self.flush, self.sync_delay,
self.loop)
self._callback.start()
self._counts = defaultdict(lambda: defaultdict(int))
self._dirty = False
self._metadata = defaultdict(dict)
self._urls = defaultdict(lambda: defaultdict(int))
def attach(self, run_id, started, counts, args):
self._attach_publisher()
self.test_result.args = args
self.test_result.startTestRun(when=started)
self.test_result.set_counts(counts)
for output in self.outputs:
output.args = args
cb = ioloop.PeriodicCallback(self.refresh, self.refresh_rate,
self.loop)
cb.start()
self.run_id = run_id
try:
self.loop.start()
finally:
# end
cb.stop()
self.test_result.stopTestRun()
self.context.destroy()
self.flush()
def start(self):
self.initialize()
self.caller = ioloop.PeriodicCallback(self.wakeup, self.check_delay,
self.loop)
self.caller.start()
def start(self):
self.loop.make_current()
self.initialize()
self.caller = ioloop.PeriodicCallback(self.arbiter.manage_watchers,
self.check_delay)
self.caller.start()