Python Poller.register方法代码示例

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class HomeBase(Thread):

    def __init__(self):
        super(HomeBase, self).__init__(name="HomeBase")
        self.context = Context()
        self.pull = self.context.socket(PULL)
        self.pull.bind("tcp://*:7001")
        self._shutdown = False
        self.poller = Poller()
        self.poller.register(self.pull, POLLIN)
        for th in t_enum():
            if th.name == "MainThread":
                self.mainthread = th

    def cleanup(self):
        print "Home exiting..."
        self.pull.close()
        self.context.term()

    def run(self):
        while True:
            if not self.mainthread.is_alive():
                self._shutdown = True
                break
            socks = dict(self.poller.poll(timeout=1))
            if socks.get(self.pull) == POLLIN:
                msg = self.pull.recv(flags=NOBLOCK)
                msg += ", WORK RECEIVED "
                print msg
            if self._shutdown:
                break
        self.cleanup()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class Leatherneck(Thread):

    def __init__(self):
        super(Leatherneck, self).__init__(name="Leatherneck")
        self.context = Context()
        self.pull = self.context.socket(PULL)
        self.pull.connect("tcp://localhost:7000")
        self.push = self.context.socket(PUSH)
        self.push.connect("tcp://localhost:7001")
        self.poller = Poller()
        self.poller.register(self.pull, POLLIN)
        self._shutdown = False
        for th in t_enum():
            if th.name == "MainThread":
                self.mainthread = th

    def cleanup(self):
        print "Workers exiting..."
        self.push.close()
        self.pull.close()
        self.context.term()

    def run(self):
        while True:
            if not self.mainthread.is_alive():
                self._shutdown = True
                break
            socks = dict(self.poller.poll(timeout=1))
            if socks.get(self.pull) == POLLIN:
                msg = self.pull.recv(flags=NOBLOCK)
                msg += " WORK COMPLETE, " + str(time())
                self.push.send(msg, flags=NOBLOCK)
            if self._shutdown:
                break
        self.cleanup()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class HomeBase(Thread):

    def __init__(self):
        super(HomeBase, self).__init__(name="HomeBase")
        self.context = Context()
        self.pull = self.context.socket(PULL)
        self.pull.bind("tcp://*:7001")
        self._shutdown = False
        self.poller = Poller()
        self.poller.register(self.pull, POLLIN)

    def cleanup(self):
        self.pull.close()
        self.context.term()

    def run(self):
        while True:
            socks = dict(self.poller.poll(timeout=1))
            if socks.get(self.pull) == POLLIN:
                msg = self.pull.recv()
                msg += ", WORK RECEIVED "
                print msg
            if self._shutdown:
                break
        self.cleanup()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class Leatherneck(Thread):

    def __init__(self):
        super(Leatherneck, self).__init__(name="Leatherneck")
        self.context = Context()
        self.pull = self.context.socket(PULL)
        self.pull.connect("tcp://localhost:7000")
        self.push = self.context.socket(PUSH)
        self.push.connect("tcp://localhost:7001")
        self.poller = Poller()
        self.poller.register(self.pull, POLLIN)
        self._shutdown = False

    def cleanup(self):
        self.push.close()
        self.pull.close()
        self.context.term()

    def run(self):
        while True:
            socks = dict(self.poller.poll(timeout=1))
            if socks.get(self.pull) == POLLIN:
                msg = self.pull.recv()
                msg += " WORK COMPLETE, " + str(time())
                self.push.send(msg)
            if self._shutdown:
                break
        self.cleanup()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class Listener(Thread):
    def __init__(self):
        super(Listener, self).__init__(name="Listener")

        self._shutdown = False
        self.context = Context()
        self.sub = self.context.socket(SUB)
        self.sub.bind('tcp://*:7000')
        self.sub.setsockopt(SUBSCRIBE, "")

        self.poller = Poller()
        self.poller.register(self.sub, POLLIN)

    def cleanup(self):
        self.sub.close()
        self.context.term()

    def run(self):
        while True:
            socks = dict(self.poller.poll(timeout=1))
            if socks.get(self.sub) == POLLIN:
                msg = self.sub.recv(flags=NOBLOCK)
                print msg
            if self._shutdown:
                break
        self.cleanup()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
def get_pub_address(name, timeout=10, nameserver="localhost"):
    """Get the address of the publisher for a given publisher *name* from the
    nameserver on *nameserver* (localhost by default).
    """

    # Socket to talk to server
    socket = context.socket(REQ)
    try:
        socket.setsockopt(LINGER, timeout * 1000)
        socket.connect("tcp://" + nameserver + ":" + str(PORT))

        poller = Poller()
        poller.register(socket, POLLIN)

        message = Message("/oper/ns", "request", {"service": name})
        socket.send(str(message))

        # Get the reply.
        sock = poller.poll(timeout=timeout * 1000)
        if sock:
            if sock[0][0] == socket:
                message = Message.decode(socket.recv(NOBLOCK))
                return message.data
        else:
            raise TimeoutError("Didn't get an address after %d seconds."
                               % timeout)
    finally:
        socket.close()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class Stethoscope(Thread):

    def __init__(self, context, *args, **kw):
        self.context = context
        self.recv = self.context.socket(PAIR)
        self.recv.connect("inproc://#1")

        self.pub = self.context.socket(PUB)
        self.pub.connect('tcp://localhost:7003')
        self.pub.setsockopt(HWM, 1000)

        self.poller = Poller()
        self.poller.register(self.recv, POLLIN)
        super(Stethoscope, self).__init__(*args, **kw)

    def cleanup(self):
        self.recv.close()
        self.pub.close()

    def run(self):
        try:
            while not shutdown.is_set():
                socks = dict(self.poller.poll())
                if socks.get(self.recv) == POLLIN:
                    msg = self.recv.recv()
                    self.pub.send(msg, flags=NOBLOCK)
                    if msg == "DIE":
                        raise KillThread
        except KillThread:
            print "%s exiting..." % self.name
        finally:
            self.cleanup()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
def _send_request(req_id, action, key, value=None):
    """ Generate a request ID, push the request to the node and wait for the
    result, filtering by the ID on the subscription.

    This should be a request/response call to the node, but since many must be
    possible at the same time, a PUSH/PULL AND PUB/SUB with an unique ID for
    each request is used instead.

    :return: the node response
    :rtype: []
    """
    # Create and connect the sockets.
    context = current_app.config["context"]
    subscriber = context.socket(SUB)
    subscriber.setsockopt_string(SUBSCRIBE, req_id)
    subscriber.connect(SUB_ENDPOINT)
    request = context.socket(PUSH)
    request.setsockopt(SNDTIMEO, _TIMEOUT)
    request.connect(PUSH_ENDPOINT)
    # Push the request.
    request.send_json([req_id, action, key, value])
    # Wait for the response from the publisher.
    poller = Poller()
    poller.register(subscriber, POLLIN)
    sockets = dict(poller.poll(_TIMEOUT))
    if subscriber not in sockets:  # no response, time out
        raise InternalServerError()
    # Return the response, without the unique request ID
    return subscriber.recv_multipart()[1:]

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
    def run(self, *args):
        """Run the listener and answer to requests.
        """
        del args

        arec = AddressReceiver(max_age=self._max_age)
        arec.start()
        port = PORT

        try:
            self.listener = context.socket(REP)
            self.listener.bind("tcp://*:" + str(port))
            poller = Poller()
            poller.register(self.listener, POLLIN)
            while self.loop:
                socks = dict(poller.poll(1000))
                if socks:
                    if socks.get(self.listener) == POLLIN:
                        msg = self.listener.recv()
                else:
                    continue
                logger.debug("Replying to request: " + str(msg))
                msg = Message.decode(msg)
                self.listener.send_unicode(str(get_active_address(
                    msg.data["service"], arec)))
        except KeyboardInterrupt:
            # Needed to stop the nameserver.
            pass
        finally:
            arec.stop()
            self.listener.close()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class MirrorWatcher(Thread):

    """Watches a other server.
    """

    def __init__(self, holder, host, pubport, reqport, sched):
        Thread.__init__(self)
        self._holder = holder
        self._pubaddress = "tcp://" + host + ":" + str(pubport)
        self._reqaddress = "tcp://" + host + ":" + str(reqport)

        self._req = SimpleRequester(host, reqport)

        self._subsocket = context.socket(SUB)
        self._subsocket.connect(self._pubaddress)
        self._subsocket.setsockopt(SUBSCRIBE, "pytroll")
        self._poller = Poller()
        self._poller.register(self._subsocket, POLLIN)
        self._lock = Lock()
        self._loop = True
        self._sched = sched

    def run(self):
        last_hb = datetime.now()
        minutes = 2
        while self._loop:
            if datetime.now() - last_hb > timedelta(minutes=minutes):
                logger.error("No heartbeat from " + str(self._pubaddress))
                last_hb = datetime.now()
                minutes = 1440
            socks = dict(self._poller.poll(2000))
            if (socks and
                    self._subsocket in socks and
                    socks[self._subsocket] == POLLIN):
                message = Message.decode(self._subsocket.recv())
            else:
                continue
            if message.type == "have":
                sat = message.data["satellite"]
                key = strp_isoformat(message.data["timecode"])
                elevation = message.data["elevation"]
                quality = message.data.get("quality", 100)
                data = _MirrorGetter(self._req, sat, key)
                self._holder.add(sat, key, elevation, quality, data)
            if message.type == "heartbeat":
                logger.debug("Got heartbeat from " + str(self._pubaddress)
                             + ": " + str(message))
                self._sched.mirror_next_pass = message.data["next_pass"]
                last_hb = datetime.now()
                minutes = 2

    def stop(self):
        """Stop the watcher
        """
        self._loop = False
        self._req.stop()
        self._subsocket.setsockopt(LINGER, 0)
        self._subsocket.close()

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
    def __stop(self):
        """ try to stop all of this Role's services """

        # send commands
        poller = Poller()
        for (pipe, svc) in self.__services.items():
            pipe.send_string('STOP')
            self.logger.debug('sent STOP command to %s service' % svc)
            poller.register(pipe, POLLIN)

        # give services a few seconds to cleanup and exit before checking responses
        sleep(1)

        max_attempts = len(self.__services)
        attempts = 0

        while self.__some_alive() and attempts < max_attempts:
            attempts += 1

            # poll for any replies
            items = dict(poller.poll(60000))  # wait for messages

            # mark responding services as stopped
            alive = dict(self.__services)  # make copy
            for (pipe, svc) in alive.items():
                if pipe in items:
                    reply = pipe.recv_string()
                    if 'STOPPED' == reply:
                        self.logger.debug('received STOPPED control reply from %s service' % svc)
                        svc.join(timeout=5)  # STOPPED response should be sent right before svc exit
                        if svc.is_alive():
                            self.logger.error('%s service is still alive; not waiting' % svc)
                        else:
                            self.logger.debug('%s service thread stopped' % svc)
                        poller.unregister(pipe)
                        pipe.close()
                        del (self.__services[pipe])
                    else:
                        self.logger.debug('unknown control reply: %s' % reply)

            # log some useful info
            if len(self.__services) > 0:
                msg = '%s services still alive after %d cycles; ' % (
                    [str(s) for s in self.__services.values()], attempts)
                if attempts < max_attempts:
                    msg += 'waiting'
                else:
                    msg += 'giving up'
                self.logger.debug(msg)

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
    def _request_translation(self, language, country, key, plural):
        """ Start up a worker, sync it and then send it a translation request.

        Returns the result, shuts down the worker at the end as well.

        Fails the current test, if something goes wrong.
        """
        request = [
            language, country if country is not None else "", key,
            str(plural) if plural is not None else ""]
        request = [x.encode(_ENCODING) for x in request]
        context = Context()
        # Create synchronization and backend sockets.
        try:
            sync_socket = context.socket(ROUTER)
            try:
                sync_socket.bind(_SYNC_ENDPOINT)
                backend = context.socket(DEALER)
                try:
                    backend.bind(_REQUEST_ENDPOINT)
                    worker_threads, worker_identities = _start_workers(
                        context, sync_socket, 1, _TIMEOUT)
                    poller = Poller()
                    poller.register(backend, POLLIN)
                    poller.register(sync_socket, POLLIN)
                    # Send request.
                    backend.send_multipart(
                        [worker_identities[0], b""] + request)
                    sockets = dict(poller.poll(_TIMEOUT))
                    # Shutdown worker.
                    _shut_down_workers(
                        sync_socket, worker_threads, worker_identities,
                        _TIMEOUT / 1000.0)
                    if backend in sockets:
                        # Return translation.
                        return backend.recv_multipart()[2].decode("utf-8")
                    self.fail("Worker did not response the request in time.")
                finally:
                    backend.set(LINGER, 0)
                    backend.close()
            finally:
                sync_socket.set(LINGER, 0)
                sync_socket.close()
        finally:
            context.destroy(linger=0)

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
 def _server(self, response):
     """ Wait for a client request, record it and send the response. """
     context = Context()
     try:
         socket = context.socket(REP)
         try:
             socket.set(LINGER, 0)
             socket.bind("tcp://*:{}".format(_PORT))
             poller = Poller()
             poller.register(socket, POLLIN)
             sockets = dict(poller.poll(_TIMEOUT))
             if socket in sockets:
                 self._client_request = socket.recv_multipart()
                 if response:
                     socket.send_multipart(response)
         finally:
             socket.close()
     finally:
         context.destroy(linger=0)

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
class ZMQPoller(object):
    """A poller that can be used in the tornado IOLoop.
    
    This simply wraps a regular zmq.Poller, scaling the timeout
    by 1000, so that it is in seconds rather than milliseconds.
    """
    
    def __init__(self):
        self._poller = Poller()
    
    @staticmethod
    def _map_events(events):
        """translate IOLoop.READ/WRITE/ERROR event masks into zmq.POLLIN/OUT/ERR"""
        z_events = 0
        if events & IOLoop.READ:
            z_events |= POLLIN
        if events & IOLoop.WRITE:
            z_events |= POLLOUT
        if events & IOLoop.ERROR:
            z_events |= POLLERR
        return z_events
    
    @staticmethod
    def _remap_events(z_events):
        """translate zmq.POLLIN/OUT/ERR event masks into IOLoop.READ/WRITE/ERROR"""
        events = 0
        if z_events & POLLIN:
            events |= IOLoop.READ
        if z_events & POLLOUT:
            events |= IOLoop.WRITE
        if z_events & POLLERR:
            events |= IOLoop.ERROR
        return events
    
    def register(self, fd, events):
        return self._poller.register(fd, self._map_events(events))
    
    def modify(self, fd, events):
        return self._poller.modify(fd, self._map_events(events))
    
    def unregister(self, fd):
        return self._poller.unregister(fd)
    
    def poll(self, timeout):
        """poll in seconds rather than milliseconds.
        
        Event masks will be IOLoop.READ/WRITE/ERROR
        """
        z_events = self._poller.poll(1000*timeout)
        return [ (fd,self._remap_events(evt)) for (fd,evt) in z_events ]
    
    def close(self):
        pass

# 需要导入模块: from zmq import Poller [as 别名]
# 或者: from zmq.Poller import register [as 别名]
def _start_workers(context, sync_socket, count, timeout=None):
    """
    :type context: zmq.Context
    :type sync_socker: zmq.Socket
    :type count: int
    :param timeout: Timeout for waiting for worker messages, in milliseconds.
    :type timeout: float
    """
    _LOG.debug("Starting workers...")
    worker_threads = [
        Thread(
            target=_handle_requests, name="worker {}".format(i),
            args=(context, ))
        for i in range(count)]
    for thread in worker_threads:
        thread.start()
    _LOG.debug("Synchronizing workers...")
    poller = Poller()
    poller.register(sync_socket, POLLIN)
    worker_identities = []
    for _ in worker_threads:
        sockets = dict(poller.poll(timeout=timeout))
        if sync_socket in sockets:
            worker_identities.append(sync_socket.recv_multipart()[0])
        else:
            raise RuntimeError("Worker did not respond in time.")
    for worker_identity in worker_identities:
        sync_socket.send_multipart([worker_identity, b"", b""])
    for _ in worker_identities:
        sockets = dict(poller.poll(timeout=timeout))
        if sync_socket in sockets:
            sync_socket.recv_multipart()
        else:
            raise RuntimeError("Worker did not respond in time.")
    _LOG.debug("Workers synchronized.")
    return worker_threads, worker_identities