def __init__(self, frontend=DEFAULT_FRONTEND, backend=DEFAULT_BACKEND,
heartbeat=DEFAULT_HEARTBEAT):
logger.debug('Initializing the broker.')
for endpoint in (frontend, backend, heartbeat):
if endpoint.startswith('ipc'):
register_ipc_file(endpoint)
self.context = zmq.Context()
# setting up the two sockets
self._frontend = self.context.socket(zmq.ROUTER)
self._frontend.bind(frontend)
self._backend = self.context.socket(zmq.DEALER)
self._backend.bind(backend)
# setting up the poller
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)
# heartbeat
self.pong = Heartbeat(heartbeat)
# status
self.started = False
self.poll_timeout = None
def __init__(self, endpoint=_ENDPOINT, retries=3):
if endpoint.startswith('ipc'):
register_ipc_file(endpoint)
self.started = False
self.endpoint = endpoint
self.workers = Workers()
self.registration = WorkerRegistration(self.workers, self.endpoint)
self.retries = retries
def __init__(self, frontend=DEFAULT_FRONTEND, backend=DEFAULT_BACKEND,
heartbeat=DEFAULT_HEARTBEAT, register=DEFAULT_REG,
io_threads=DEFAULT_IOTHREADS,
worker_timeout=DEFAULT_TIMEOUT_MOVF):
# 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)
logger.debug('Initializing the broker.')
for endpoint in (frontend, backend, heartbeat):
if endpoint.startswith('ipc'):
register_ipc_file(endpoint)
self.context = zmq.Context(io_threads=io_threads)
# setting up the three 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._backend.bind(backend)
self._registration = self.context.socket(zmq.PULL)
self._registration.bind(register)
# 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)
# heartbeat
self.pong = Heartbeat(heartbeat, io_loop=self.loop, ctx=self.context)
# status
self.started = False
self.poll_timeout = None
# workers registration and timers
self._workers = []
self._worker_times = {}
self.worker_timeout = worker_timeout
def __init__(self, endpoint, identity, target, timeout=1.):
self.identity = identity
if identity.startswith('ipc'):
register_ipc_file(identity)
self.ctx = zmq.Context()
self.timeout = timeout * 1000
self.master = self.ctx.socket(zmq.REQ)
self.master.connect(endpoint)
self.work = self.ctx.socket(zmq.REP)
self.work.bind(identity)
self.registered = self.running = False
# setting a poller
self.poller = zmq.Poller()
self.poller.register(self.work, zmq.POLLIN)
self.locker = threading.RLock()
self.pinger = Pinger(self.identity, self.master, self.locker,
self.failed)
self.target = target
def __init__(self, frontend=DEFAULT_FRONTEND, backend=DEFAULT_BACKEND,
heartbeat=DEFAULT_HEARTBEAT):
# 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)
logger.debug('Initializing the broker.')
for endpoint in (frontend, backend, heartbeat):
if endpoint.startswith('ipc'):
register_ipc_file(endpoint)
self.context = zmq.Context()
# setting up the two sockets
self._frontend = self.context.socket(zmq.ROUTER)
self._frontend.identity = 'broker-' + frontend
self._frontend.bind(frontend)
self._backend = self.context.socket(zmq.DEALER)
self._backend.bind(backend)
# setting up the poller
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)
# heartbeat
self.pong = Heartbeat(heartbeat, io_loop=self.loop)
# status
self.started = False
self.poll_timeout = None
