def __init__(self, runtime, port=5556):
from rill.runtime.handlers.runtime import RuntimeHandler
self.runtime = runtime
self.port = port
# Context wrapper
self.ctx = zmq.Context()
# IOLoop reactor
self.loop = IOLoop.instance()
if not isinstance(self.loop, IOLoop):
raise TypeError("Expected %s, got %s" % (IOLoop, type(self.loop)))
# Set up our client server sockets
# Publish updates to clients
self.publisher = self.ctx.socket(zmq.PUB)
# Collect updates and snapshot requests from clients, and send back
# errors
self.collector = self.ctx.socket(zmq.ROUTER)
self.collector.bind("tcp://*:%d" % (self.port))
self.publisher.bind("tcp://*:%d" % (self.port + 1))
# Wrap sockets in ZMQStreams for IOLoop handlers
self.publisher = zmqstream.ZMQStream(
self.publisher) # only necessary for heartbeat
self.collector = zmqstream.ZMQStream(self.collector)
# Register handlers with reactor
self.collector.on_recv(self.handle_message)
self.dispatcher = MessageDispatcher(self.publisher, self.collector)
self.handler = RuntimeHandler(self.dispatcher, runtime)
def __init__(self, args):
super(DistributedRunner, self).__init__(args)
self.ssh = args.get('ssh')
self.run_id = None
self._stopped_agents = 0
self._nb_agents = args.get('agents')
# socket where the results are published
self.context = zmq.Context()
self.sub = self.context.socket(zmq.SUB)
self.sub.setsockopt(zmq.SUBSCRIBE, '')
self.sub.set_hwm(8096 * 10)
self.sub.setsockopt(zmq.LINGER, -1)
self.zmq_publisher = None
self.zstream = None
# io loop
self.loop = ioloop.IOLoop()
self.zstream = zmqstream.ZMQStream(self.sub, self.loop)
self.zstream.on_recv(self._recv_result)
self.agents = []
self._client = None
self.refresh_rate = 100
def _attach_publisher(self):
zmq_publisher = self.args.get('zmq_publisher')
if zmq_publisher in (None, DEFAULT_PUBLISHER):
# if this option is not provided by the command line,
# we ask the broker about it
res = self.client.ping()
endpoint = res['endpoints']['publisher']
if endpoint.startswith('ipc'):
# IPC - lets hope we're on the same box
zmq_publisher = endpoint
elif endpoint.startswith('tcp'):
# TCP, let's see what IP & port we have
splitted = split_endpoint(endpoint)
if splitted['ip'] == '0.0.0.0':
# let's use the broker ip
broker = self.args['broker']
broker_ip = split_endpoint(broker)['ip']
zmq_publisher = 'tcp://%s:%d' % (broker_ip,
splitted['port'])
else:
# let's use the original ip
zmq_publisher = endpoint
else:
zmq_publisher = DEFAULT_PUBLISHER
self.sub.connect(zmq_publisher)
self.zstream = zmqstream.ZMQStream(self.sub, self.loop)
self.zstream.on_recv(self._recv_result)
self.zmq_publisher = zmq_publisher
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 _init_stream(self):
self.stream = zmqstream.ZMQStream(self.ctrl_socket, self.loop)
self.stream.on_recv(self.handle_message)
def __init__(self,
frontend=DEFAULT_FRONTEND,
backend=DEFAULT_BACKEND,
heartbeat=None,
register=DEFAULT_REG,
io_threads=DEFAULT_IOTHREADS,
agent_timeout=DEFAULT_AGENT_TIMEOUT,
receiver=DEFAULT_BROKER_RECEIVER,
publisher=DEFAULT_PUBLISHER,
db='python',
dboptions=None,
web_root=None):
# before doing anything, we verify if a broker is already up and
# running
logger.debug('Verifying if there is a running broker')
pid = verify_broker(frontend)
if pid is not None: # oops. can't do this !
logger.debug('Ooops, we have a running broker on that socket')
raise DuplicateBrokerError(pid)
self.endpoints = {
'frontend': frontend,
'backend': backend,
'register': register,
'receiver': receiver,
'publisher': publisher
}
if heartbeat is not None:
self.endpoints['heartbeat'] = heartbeat
logger.debug('Initializing the broker.')
for endpoint in self.endpoints.values():
if endpoint.startswith('ipc'):
register_ipc_file(endpoint)
self.context = zmq.Context(io_threads=io_threads)
# setting up the sockets
self._frontend = self.context.socket(zmq.ROUTER)
self._frontend.identity = 'broker-' + frontend
self._frontend.bind(frontend)
self._backend = self.context.socket(zmq.ROUTER)
self.pid = str(os.getpid())
self._backend.identity = self.pid
self._backend.bind(backend)
self._registration = self.context.socket(zmq.PULL)
self._registration.bind(register)
self._receiver = self.context.socket(zmq.PULL)
self._receiver.bind(receiver)
self._publisher = self.context.socket(zmq.PUB)
self._publisher.bind(publisher)
# setting up the streams
self.loop = ioloop.IOLoop()
self._frontstream = zmqstream.ZMQStream(self._frontend, self.loop)
self._frontstream.on_recv(self._handle_recv_front)
self._backstream = zmqstream.ZMQStream(self._backend, self.loop)
self._backstream.on_recv(self._handle_recv_back)
self._regstream = zmqstream.ZMQStream(self._registration, self.loop)
self._regstream.on_recv(self._handle_reg)
self._rcvstream = zmqstream.ZMQStream(self._receiver, self.loop)
self._rcvstream.on_recv(self._handle_recv)
# heartbeat
if heartbeat is not None:
self.pong = Heartbeat(heartbeat,
io_loop=self.loop,
ctx=self.context,
onregister=self._deregister)
else:
self.pong = None
# status
self.started = False
self.poll_timeout = None
# controller
self.ctrl = BrokerController(self,
self.loop,
db=db,
dboptions=dboptions,
agent_timeout=agent_timeout)
self.web_root = web_root
