Python ZMQStream.send方法代码示例

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class Client(object):
    def __init__(self):
        self.stream = None
        self.result = None

    def connect(self, port):
        context = zmq.Context()
        socket = context.socket(zmq.REQ)
        socket.connect(port)
        self.stream = ZMQStream(socket)

    def __getattr__(self, item):
        def wrapper(*args):
            request = [item]
            for param in args:
                request.append(param)
            return self._run(tuple(request))
        return wrapper

    def _run(self, request):
        def on_response(message):
            response = msgpack.unpackb(message[0], use_list=False)
            if response[0] == 'OK':
                self.result = response[1]
            elif response[0] == 'ERR':
                raise Exception(response[2])
            ZMQIOLoop.instance().stop()

        self.stream.send(msgpack.packb(request))
        self.stream.on_recv(on_response)
        ZMQIOLoop.instance().start()
        return self.result

    def disconnect(self):
        self.stream.close()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class DevPort(object):
    def __init__(self, card, depth, rate):
        self.card = card
        self.depth = depth
        self.rate = rate
        self.running = False

        context = zmq.Context() 

        self.prog_socket = context.socket(zmq.PUB)
        self.prog_socket.connect('ipc:///tmp/progressIn.ipc')
        self.prog_stream = ZMQStream(self.prog_socket, IOLoop.instance())
        self.scheduleProgress()
        
        self.peak_socket = context.socket(zmq.PUB)
        self.peak_socket.bind('ipc:///tmp/peaks.ipc')
        self.peak_stream = ZMQStream(self.peak_socket, IOLoop.instance())
        self.sendPeaks()
        
    def startRecording(self, path):
        self.curPath = path
        self.started = time()
        self.running = True

    def stopRecording(self):
        self.running = False

    def resetPeaks(self):
        pass

    def stop(self):
        self.stopRecording()

    def  waitTillFinished(self):
        pass

    def gotSignal(self):
        return True

    def sendProgress(self):
        duration = 0
        mode = 0
        if self.running:
            duration = int((time() - self.started) * self.rate)
            mode = 1

        d = {'t':duration, 'm': mode, 'b' : 0 }

        s = json.dumps(d)
        self.prog_stream.send(s)        
        IOLoop.instance().add_timeout(time() + .333, self.sendProgress)

    def sendPeaks(self):
        l = [-140, -140, -140, -140]
        self.peak_stream.send(json.dumps(l))
        IOLoop.instance().add_timeout(time() + .1, self.sendPeaks)
        
    def scheduleProgress(self):
        IOLoop.instance().add_timeout(time() + .333, self.sendProgress)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class TheWorker(object):
    def __init__(self, context):
        #context = zmq.Context(1)
        self.frontend = ZMQStream(worker_socket(context))
        self.frontend.on_recv(self.handle_frontend)

        self.liveness = HEARTBEAT_LIVENESS
        self.heartbeat = HEARTBEAT_INTERVAL
        self.interval = INTERVAL_INIT
        self.loop = IOLoop.instance()

        self.time = self.interval * self.heartbeat
        self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS        
        self.callback = None
        self.timed_out = False

        self.start()

    def start(self):
        self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)
        # try:
        #     IOLoop.instance().start()
        # except KeyboardInterrupt:
        #     times_str('ctrlc')


    def send_heartbeat(self):
        if time.time() > self.heartbeat_at:
            self.time *= 2 if self.time < INTERVAL_MAX else 1
            times_str('W: Timed out.. Retrying in {} seconds..'.format(self.time))
            self.callback = self.loop.add_timeout(time.time()+self.time*1, self.send_heartbeat)
            self.timed_out = True
            return
        
        times_str('W: Sending Heartbeat..')
        self.frontend.send(PPP_HEARTBEAT)
        self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)

    def handle_frontend(self,msg):
        m = msg[:]
        if len(m) == 1:
            times_str('W: Received Heartbeat')
            if self.timed_out:
                self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)
                self.timed_out = False
                self.loop.remove_timeout(self.callback)
                self.time = self.interval * self.heartbeat
        elif len(m) == 3:
            times_str('Received: '+str(m))
            time.sleep(10)
            times_str('Sending it back..')
            self.frontend.send_multipart(m)
        self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class ZQueue(object):
    def __init__(self, backend_socket):
        self.frontend = ZMQStream(backend_socket)
        self.frontend.on_recv(self.handle_backend)
        self.loop = IOLoop.instance()

    def handle_backend(self,msg):
        m = msg[:]
        print(m)

    def run(self):
        try:
            self.frontend.send(PPP_READY)
            self.loop.start()
        except KeyboardInterrupt:
            helpers.Helpers.times_str('ctrlc')

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class TornadoAsyncClient(object):

    def __init__(self, ip, port):
        from zmq.eventloop.zmqstream import ZMQStream
        self.client = context.socket(zmq.PUSH)
        self.client.connect("tcp://{0}:{1}".format(ip,port))
        self.stream = ZMQStream(self.client)
    
    def __getattr__(self, attr):
        def _(*arg):
            return self.send(attr, *arg)
        return _

    def send(self, func, *arg):
        send_dict = {'func':func,'arg':arg}
        self.stream.send(json.dumps(send_dict))

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class PubQueue(BaseQueue):

    def __init__(self, bind, ioloop=None):
        super().__init__(zmq.PUSH)
        self.socket.bind(bind)
        self.stream = ZMQStream(self.socket, ioloop)
        self.stream.on_send(self.__on_send)

    def __on_send(self, msq, status):
        print(msq, status)

    def send(self, data):
        self.stream.send(data)
        self.stream.flush()

    def send_string(self, data):
        self.stream.send_string(data)
        self.stream.flush()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class ZeroMQHandler(tornado.websocket.WebSocketHandler):

    def __init__(self, *args, **kwargs):
        super(ZeroMQHandler, self).__init__(*args, **kwargs)
        self.socket = None
        self.stream = None

    def open(self):
        settings = self.application.settings
        self.socket = settings['zeromq']['context'].socket(REQ)
        self.socket.connect(settings['zeromq']['url'])
        self.stream = ZMQStream(self.socket, settings['ioloop'])
        self.stream.on_recv(self.on_dispatch)

    def on_message(self, message):
        request = load_message(message)
        if request:
            data = message.encode('utf8')
            self.stream.send(data)
        else:
            self.write_message(ERROR_INVALID_REQUEST)

    def on_dispatch(self, messages):
        for message in messages:
            data = message.encode('utf8')
            self.write_message(data)

    def on_close(self):
        self.stream.close()
        self.socket.close()

    def check_origin(self, origin):
        return True

    def data_received(self, chunk):
        pass

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class TornadoClient(object):

    def __init__(self, ip, port):
        from zmq.eventloop.zmqstream import ZMQStream
        self.client = context.socket(zmq.REQ)
        self.client.connect("tcp://{0}:{1}".format(ip,port))
        self.stream = ZMQStream(self.client)
    
    def __getattr__(self, attr):
        def _(*arg):
            return self.send(attr, *arg)
        return _

    def send(self, func, callback, *arg, **kwargs):
        send_dict = {'func':func,'arg':arg}
        self.callback = callback
        self.stream.send(json.dumps(send_dict))
        self.stream.on_recv(self._recv_msg, True)

    def _recv_msg(self, msg):
        recv_dict = json.loads(msg[0])
        main = recv_dict['main']
        err = recv_dict['error']
        self.callback(main, err)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class MidgardDaemon:
    def __init__(self, addr):
        self.init_midgard()
        self.init_rdf_mapper()
        self.init_zmq(addr)

    def init_midgard(self):
        print("Connecting to midgard")
        Midgard.init()
        self.mgd = Midgard.Connection()
        self.mgd.open_config(DaemonConfig())
        print("... DONE")

    def init_rdf_mapper(self):
        print("Parsing RDF mapping info")
        self.rm = RdfMapper(self.mgd)
        print("... DONE")

    def init_zmq(self, addr):
        print("starting 0MQ thread")
        context = zmq.Context()

        socket = context.socket(zmq.REP)
        socket.bind(addr)

        self.loop = ioloop.IOLoop.instance()

        self.stream = ZMQStream(socket, self.loop)
        self.stream.on_recv(self.handler)
        print("... DONE")


    def handler(self, message):
        msg = str(message[0], 'utf8')

        try:
            data = json.loads(msg)
            if 'query' in data:
                response = self.handleQuery(data['query'])
            elif 'update' in data:
                response = self.handleUpdate(data['update'])
        except (TypeError, ValueError) as e:
            resp_obj = {"status": {"code": -128, "error": "Invalid request. %s" % (e) }}
            response = json.dumps(resp_obj)
        except gobject.GError as e:
            resp_obj = {"status": {"code": e.code, "error": "Invalid request. %s" % (e.message)}}
            response = json.dumps(resp_obj)

        self.stream.send(bytes(response, 'utf8'))

    def handleQuery(self, fields):
        handler = QueryHandler(self.mgd, self.rm, fields)
        return handler.handle()

    def handleUpdate(self, fields):
        handler = UpdateHandler(self.mgd, self.rm, fields)
        return handler.handle()

    def run(self):
        print("\nwaiting for requests...")
        self.loop.start()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class CloneServer(object):

    # Our server is defined by these properties
    ctx = None                  # Context wrapper
    kvmap = None                # Key-value store
    loop = None                 # IOLoop reactor
    port = None                 # Main port we're working on
    sequence = 0                # How many updates we're at
    snapshot = None             # Handle snapshot requests
    publisher = None            # Publish updates to clients
    collector = None            # Collect updates from clients

    def __init__(self, port=5556):
        self.port = port
        self.ctx = zmq.Context()
        self.kvmap = {}
        self.loop = IOLoop.instance()

        # Set up our clone server sockets
        self.snapshot  = self.ctx.socket(zmq.ROUTER)
        self.publisher = self.ctx.socket(zmq.PUB)
        self.collector = self.ctx.socket(zmq.PULL)
        self.snapshot.bind("tcp://*:%d" % self.port)
        self.publisher.bind("tcp://*:%d" % (self.port + 1))
        self.collector.bind("tcp://*:%d" % (self.port + 2))

        # Wrap sockets in ZMQStreams for IOLoop handlers
        self.snapshot = ZMQStream(self.snapshot)
        self.publisher = ZMQStream(self.publisher)
        self.collector = ZMQStream(self.collector)

        # Register our handlers with reactor
        self.snapshot.on_recv(self.handle_snapshot)
        self.collector.on_recv(self.handle_collect)
        self.flush_callback = PeriodicCallback(self.flush_ttl, 1000)

        # basic log formatting:
        logging.basicConfig(format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S",
                level=logging.INFO)


    def start(self):
        # Run reactor until process interrupted
        self.flush_callback.start()
        try:
            self.loop.start()
        except KeyboardInterrupt:
            pass

    def handle_snapshot(self, msg):
        """snapshot requests"""
        if len(msg) != 3 or msg[1] != "ICANHAZ?":
            print "E: bad request, aborting"
            dump(msg)
            self.loop.stop()
            return
        identity, request, subtree = msg
        if subtree:
            # Send state snapshot to client
            route = Route(self.snapshot, identity, subtree)

            # For each entry in kvmap, send kvmsg to client
            for k,v in self.kvmap.items():
                send_single(k,v,route)

            # Now send END message with sequence number
            logging.info("I: Sending state shapshot=%d" % self.sequence)
            self.snapshot.send(identity, zmq.SNDMORE)
            kvmsg = KVMsg(self.sequence)
            kvmsg.key = "KTHXBAI"
            kvmsg.body = subtree
            kvmsg.send(self.snapshot)

    def handle_collect(self, msg):
        """Collect updates from clients"""
        kvmsg = KVMsg.from_msg(msg)
        self.sequence += 1
        kvmsg.sequence = self.sequence
        kvmsg.send(self.publisher)
        ttl = float(kvmsg.get('ttl', 0))
        if ttl:
            kvmsg['ttl'] = time.time() + ttl
        kvmsg.store(self.kvmap)
        logging.info("I: publishing update=%d", self.sequence)

    def flush_ttl(self):
        """Purge ephemeral values that have expired"""
        for key,kvmsg in self.kvmap.items():
            self.flush_single(kvmsg)

    def flush_single(self, kvmsg):
        """If key-value pair has expired, delete it and publish the fact
        to listening clients."""
        ttl = float(kvmsg.get('ttl', 0))
        if ttl and ttl <= time.time():
            kvmsg.body = ""
            self.sequence += 1
            kvmsg.sequence = self.sequence
            kvmsg.send(self.publisher)
            del self.kvmap[kvmsg.key]
#.........这里部分代码省略.........

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class BaseServer(App):
    """Base class for a ZMQ server object that manages a ROUTER socket.

    When a new message arrives on the socket, ZMQ cals the _dispatch()
    method. After validating the message, dispatch() looks for a
    method on the class whose name corresponds to the 'msg_type' (in
    the message's header). This method then gets called as method(**msg),
    with three arguments, header, parent_header and content.

    The method should respond on the stream by calling send_message()
    """

    zmq_port = Int(12345, config=True, help='ZeroMQ port to serve on')
    db_path = Unicode('db.sqlite', config=True, help='''
        Path to the database (sqlite3 file)''')


    def start(self):
        url = 'tcp://*:%s' % int(self.zmq_port)

        self.uuid = str(uuid.uuid4())
        self.ctx = zmq.Context()
        s = self.ctx.socket(zmq.ROUTER)
        s.bind(url)
        self._stream = ZMQStream(s)
        self._stream.on_recv(self._dispatch)
        connect_to_sqlite_db(self.db_path)

    def send_message(self, client_id, msg_type, content=None):
        """Send a message out to a client

        Parameters
        ----------
        client_id : uuid
            Who do you want to send the message to? This is string that
            identifies the client to the ZMQ routing layer. Within our
            messaging protocol, when the server recieves a message, it can
            get the id of the sender from within the message's header -- but
            this is dependent on the fact that the device.Device() code
            puts the same string in the message header that it uses
            to identify the socket to zeromq, in the line
                setsockopt(zmq.IDENTITY, str(self.uuid))
        msg_type : str
            The type of the message
        content : dict
            Content of the message
        Notes
        -----
        For details on the messaging protocol, refer to message.py
        """
        if content is None:
            content = {}

        msg = pack_message(msg_type, self.uuid, content)
        self.log.info('SENDING MESSAGE: %s', msg)

        self._stream.send(client_id, zmq.SNDMORE)
        self._stream.send('', zmq.SNDMORE)
        self._stream.send_json(msg)

    def _validate_msg_dict(self, msg_dict):
        if 'header' not in msg_dict:
            raise ValueError('msg does not contain "header"')
        if 'content' not in msg_dict:
            raise ValueError('msg does not contain "content"')
        if 'sender_id' not in msg_dict['header']:
            raise ValueError('msg header does not contain "sender_id"')
        if 'msg_type' not in msg_dict['header']:
            raise ValueError('msg header does not contain "msg_type"')


    def _dispatch(self, frames):
        """Callback that responds to new messages on the stream

        This is the first point where new messages enter the system. Basically
        we just pack them up and send them on to the correct responder.

        Parameters
        ----------
        stream : ZMQStream
            The stream that we're responding too (probably self._stream)
        messages : list
            A list of messages that have arrived
        """
        # for some reason we seem to be getting double logging
        # inside the event loop, but not outside it. i'm not sure
        # if this is a tornado thing or what, but disabling
        # the parent log handler seems to fix it.
        self.log.parent.handlers = []

        if not len(frames) == 3:
            self.log.error('invalid message received. messages are expected to contain only three frames: %s', str(frames))

        client, _, raw_msg = frames
        # using the PyYaml loader is a hack force regular strings
        # instead of unicode, since you can't send unicode over zmq
        # since json is a subset of yaml, this works
        msg_dict = yaml.load(raw_msg)

        try:
#.........这里部分代码省略.........

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class MainHandler(tornado.web.RequestHandler):
    handler = None

    def initialize(self):
        # import ipdb; ipdb.set_trace()
        print(os.getcwd())
        self._loader = tornado.template.Loader("data")
        broadcast = Broadcast()
        print(broadcast.push_address + " / " + broadcast.subscribe_address)
        self._push_address = broadcast.push_address
        self._subscribe_address = broadcast.subscribe_address
        self._context = zmq.Context.instance()
        push_socket = self._context.socket(zmq.PUSH)
        push_socket.connect(self._push_address)
        self._push_stream = ZMQStream(push_socket)
        subscribe_socket = self._context.socket(zmq.SUB)
        subscribe_socket.connect(self._subscribe_address)
        subscribe_socket.setsockopt(zmq.SUBSCRIBE, "")
        self._subscribe_stream = ZMQStream(subscribe_socket)
        self._subscribe_stream.on_recv(self._handle_message_parts)
        self._routing_id = "temporary_id_" + str(RANDOM.randint(0, 32768))
        MainHandler.handler = self

    @tornado.web.asynchronous
    def get(self):
        content = self._loader.load("index.html").generate(
                videofeed="/test",
                status="well let's say pending")
        self.write(content)
        hello = self._build_hello()
        print("Send Hello: " + repr(hello))
        # self._subscribe_stream.send(hello)
        self._push_stream.send(hello)

    @tornado.web.asynchronous
    def _handle_message_parts(self, message_parts):
        # print('message received: %s' % map(repr, message_parts))
        for message in message_parts:
            recipient, _, typed_payload = message.partition(' ')
            message_type, _, payload = typed_payload.partition(' ')
            self._handle_message(recipient, message_type, payload)

    def _handle_message(self, recipient, message_type, payload):
        if (self._destination_matches(recipient)):
            if ("Welcome" == message_type):
                self._handle_welcome(payload)
            elif ("Goodbye" == message_type):
                self._handle_goodbye(payload)
            elif ("GameState" == message_type):
                self._handle_game_state(payload)
            else:
                print("Message ignored: " + message_type)

    def _destination_matches(self, recipient):
        return True  # for now

    def _handle_welcome(self, payload):
        message = pb_server_game.Welcome()
        message.ParseFromString(payload)
        print(
            "Welcome ; id = " + str(message.id) +
            " ; video_address = " + message.video_address +
            " ; video_port = " + str(message.video_port))
        self._routing_id = str(message.id)
        if (message.game_state):
            print("playing ? " + str(message.game_state.playing))
            print("time left: " + str(message.game_state.seconds))
            for team in message.game_state.teams:
                print(team.name + " (" + str(team.num_players) +
                      ") -> " + str(team.score))
        videofeed = message.video_address + ":" + str(message.video_port)
        print("videofeed =", videofeed,
              ";", len(OrwellConnection.all_connections))
        video_url = "/video?address={}&port={}".format(
            message.video_address,
            str(message.video_port))
        # video_url = "/test?address={}&port={}".format(
            # message.video_address,
            # str(message.video_port))
        json_str = json.dumps({"videofeed": video_url})
        OrwellConnection.data_to_send.append(json_str)
        # for connection in OrwellConnection.all_connections:
            # print("send videofeed(" + json_str + ") to", connection)
            # connection.send(json_str)
        print("_handle_welcome - finish")
        self.finish()

    def _handle_goodbye(self, payload):
        message = pb_server_game.Goodbye()
        message.ParseFromString(payload)
        print("Goodbye ...")
        print("_handle_goodbye - finish")
        self.finish()

    def _handle_game_state(self, payload):
        message = pb_server_game.GameState()
        message.ParseFromString(payload)
        if (message.HasField("winner")):
            status = "Game won by team " + message.winner
        else:
#.........这里部分代码省略.........

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class Client:

  def __init__(self):
    self._current_packet_id = 0
    self._request_response_map = {}
    self._new_response_condition = Condition()
    self._packet_id_lock = Lock()
    self._notification_callbacks = []

  def connect_to_server(self, server):
    self.context = zmq.Context()
    self.socket = self.context.socket(zmq.DEALER)

    tmpdir = tempfile.gettempdir()
    connection_string  = 'ipc://%s/%s_%s' %  (tmpdir, 'zmq', server)
    self.socket.connect(connection_string)

    io_loop = ioloop.IOLoop(ioloop.ZMQPoller())

    self.stream = ZMQStream(self.socket, io_loop)

    # create partial function that has self as first argument
    callback = partial(_on_recv, self)
    self.stream.on_recv(callback)
    self.event_loop = EventLoop(io_loop)
    self.event_loop.start()

  def disconnect(self):
    self.stream.flush()
    self.event_loop.stop()
    self.socket.close()

  def register_notification_callback(self, callback):
    # check a valid function has been past
    assert callable(callback)
    self._notification_callbacks.append(callback)

  def request_queue_list_update(self):
    pass

  def submit_job_request(self, request, timeout=None):
    params = JsonRpc.jobrequest_to_json_params(request)
    packet_id = self._next_packet_id()
    jsonrpc = JsonRpc.generate_request(packet_id,
                                      'submitJob',
                                      params)

    self._send_request(packet_id, jsonrpc)
    response = self._wait_for_response(packet_id, timeout)

    # Timeout
    if response == None:
      return None

    # if we an error occurred then throw an exception
    if 'error' in response:
      exception = JobRequestException(response['id'],
                                      response['error']['code'],
                                      response['error']['message'])
      raise exception

    # otherwise return the molequeue id
    return response['result']['moleQueueId']

  def cancel_job(self):
    # TODO
    pass

  def lookup_job(self, molequeue_id, timeout=None):

    params = {'moleQueueId': molequeue_id}

    packet_id = self._next_packet_id()
    jsonrpc = JsonRpc.generate_request(packet_id,
                                      'lookupJob',
                                      params)

    self._send_request(packet_id, jsonrpc)
    response = self._wait_for_response(packet_id, timeout)

    # Timeout
    if response == None:
      return None

    # if we an error occurred then throw an exception
    if 'error' in response:
      exception = JobRequestInformationException(response['id'],
                                                 reponse['error']['data'],
                                                 reponse['error']['code'],
                                                 reponse['error']['message'])
      raise exception

    jobrequest = JsonRpc.json_to_jobrequest(response)

    return jobrequest


  def _on_response(self, packet_id, msg):
    if packet_id in self._request_response_map:
      self._new_response_condition.acquire()
#.........这里部分代码省略.........

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class TheQueue(object):
    def __init__(self, context, front, back, top=True):
        self.workers = WorkerQueue()
        self.loop = IOLoop.instance()
                
        self.liveness = HEARTBEAT_LIVENESS
        self.heartbeat = HEARTBEAT_INTERVAL
        self.interval = INTERVAL_INIT       
        self.time = self.interval * self.heartbeat
        self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS

        self.callback = None
        self.timed_out = False
        self.hearbeats = 0

        if top:
            self.frontend_socket = context.socket(zmq.ROUTER)
            self.frontend_socket.bind(url_str(front,True))
        else:
            self.frontend_socket = context.socket(zmq.DEALER)
            self.frontend_socket.connect(url_str(front))
            self.frontend.send(PPP_READY)
        self.backend_socket = context.socket(zmq.ROUTER)
        self.backend_socket.bind(url_str(back,True))

        self.frontend = ZMQStream(self.frontend_socket)
        self.backend = ZMQStream(self.backend_socket)

        self.start()

    def start(self):
        self.frontend.on_recv(self.handle_frontend)
        self.backend.on_recv(self.handle_backend)
        self.period = PeriodicCallback(self.workers.purge, self.heartbeat*1000)
        self.period.start()

        try:
            self.frontend.send(PPP_READY)
            #self.loop.start()
        except KeyboardInterrupt:
            times_str('ctrlc1')

    def handle_frontend(self,msg):
        m = msg[:]
        if len(m) == 1:
            times_str('Q: Received Heartbeat')
            if self.timed_out:
                self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)
                self.timed_out = False
                self.loop.remove_timeout(self.callback)
        elif len(m) == 3:
            times_str('Received: '+str(m))
            address, worker = self.workers.getLRU()
            worker.working = True
            m.insert(0,address)
            self.backend.send_multipart(m)
        self.heartbeat_at = time.time() + self.heartbeat * self.liveness

    def handle_backend(self,msg):
        m = msg[:]
        address = m[0]

        #times_str('Backend Received: {}'.format(m))
        self.workers.ready(WorkerModel(address))
        self.backend.send_multipart([address,PPP_HEARTBEAT])

        mm = m[1:]
        if len(mm) == 1:
            if mm[0] == PPP_HEARTBEAT:
                self.hearbeats += 1
                times_str('Got hearbeat {}'.format(self.hearbeats))               
        else:
            times_str('Sending it back..')
            self.frontend.send_multipart(mm)

    def send_heartbeat(self):
        if time.time() > self.heartbeat_at:
            self.time *= 2 if self.time < INTERVAL_MAX else 1
            times_str('Timed out.. Retrying in {} seconds..'.format(self.time))
            self.callback = self.loop.add_timeout(time.time()+self.time, self.send_heartbeat)
            self.timed_out = True
            return
        self.time = self.interval * self.heartbeat
        times_str('Q: Sending Heartbeat..')
        self.frontend.send(PPP_HEARTBEAT)
        self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send [as 别名]
class Channel(object):

    """Mother of all channels. Defines the interface.

    Callbacks:
      The callbacks will receive the channel as first parameter and
      the message as second parameter. The error callback will get
      the stream where the error occured as second parameter.

    Attributes:
      * stream_in, stream_out : the streams for eventlopp handling
      * serializer : the serializer used
    """

    def __init__(self, socket_in, socket_out, serializer):
        self.stream_in = ZMQStream(socket_in)
        self.stream_out = ZMQStream(socket_out)
        self.serializer = serializer
        self._cb_receive = None
        self._cb_send = None
        self._cb_error = None
        self._chan_id = id(self)
        return

    def on_receive(self, callback):
        """Set callback to invoke when a message was received.
        """
        self.stream_in.stop_on_recv()
        self._cb_receive = callback
        if callback:
            self.stream_in.on_recv(self._on_recv)
        return

    def on_send(self, callback):
        """Set callback to invoke when a message was sent.
        """
        self.stream_out.stop_on_send()
        self._cb_send = callback
        if callback:
            self.stream_out.on_send(self._on_send)
        return

    def on_error(self, callback):
        """Set callback to invoke when an error event occured.
        """
        self.stream_in.stop_on_err()
        self.stream_out.stop_on_err()
        self._cb_error = callback
        if callback:
            self.stream_in.on_err(self._on_err_in)
            self.stream_out.on_err(self._on_err_out)
        return

    def send(self, message):
        """Send given message.
        """
        m = self.serializer.serialize(message)
        if self.serializer.multipart:
            self.stream_out.send_multipart(m)
        else:
            self.stream_out.send(m)
        return

    def _on_recv(self, msg):
        """Helper interfacing w/ streams.
        """
        if self.serializer.multipart:
            msg = self.serializer.deserialize(msg)
        else:
            msg = self.serializer.deserialize(msg[0])
        self._cb_receive(self, msg)
        return

    def _on_send(self, sent, _):
        """Helper interfacing w/ streams.
        """
        msg = sent[0]
        if self.serializer.multipart:
             msg = self.serializer.deserialize(msg)
        else:
            msg = self.serializer.deserialize(msg[0])
        self._cb_send(self, msg)
        return

    def _on_err_in(self):
        self._cb_error(self, self.stream_in)
        return

    def _on_err_out(self):
        self._cb_error(self, self.stream_out)
        return

    def __hash__(self):
        return self._chan_id

    def __eq__(self, other):
        if not isinstance(other, self.__class__):
            return False
        return self._chan_id == other._chan_id

#.........这里部分代码省略.........