Python KVMsg.send方法代码示例

# 需要导入模块: from kvmsg import KVMsg [as 别名]
# 或者: from kvmsg.KVMsg import send [as 别名]
    def control_message (self):
        msg = self.pipe.recv_multipart()
        command = msg.pop(0)

        if command == "CONNECT":
            address = msg.pop(0)
            port = int(msg.pop(0))
            if len(self.servers) < SERVER_MAX:
                self.servers.append(CloneServer(self.ctx, address, port, self.subtree))
                self.publisher.connect("%s:%i" % (address,port+2))
            else:
                logging.error("E: too many servers (max. %i)", SERVER_MAX)
        elif command == "SET":
            key,value,sttl = msg
            ttl = int(sttl)

            # Send key-value pair on to server
            kvmsg = KVMsg(0, key=key, body=value)
            kvmsg.store(self.kvmap)
            if ttl:
                kvmsg["ttl"] = ttl
            kvmsg.send(self.publisher)
        elif command == "GET":
            key = msg[0]
            value = self.kvmap.get(key)
            self.pipe.send(value.body if value else '')

# 需要导入模块: from kvmsg import KVMsg [as 别名]
# 或者: from kvmsg.KVMsg import send [as 别名]
    def handle_snapshot(self, msg):
        """snapshot requests"""

        logging.info("I: received state request on snapshot: %s" % msg)
        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():
                logging.info("I: Sending snapshot: %s" % v)
                send_single(k, v, route)

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

# 需要导入模块: from kvmsg import KVMsg [as 别名]
# 或者: from kvmsg.KVMsg import send [as 别名]
    def handle_snapshot(self, socket, msg):
        """snapshot requests"""
        if msg[1] != "ICANHAZ?" or len(msg) != 3:
            logging.error("E: bad request, aborting")
            dump(msg)
            self.bstar.loop.stop()
            return
        identity, request = msg[:2]
        if len(msg) >= 3:
            subtree = msg[2]
            # Send state snapshot to client
            route = Route(socket, 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)
            socket.send(identity, zmq.SNDMORE)
            kvmsg = KVMsg(self.sequence)
            kvmsg.key = "KTHXBAI"
            kvmsg.body = subtree
            kvmsg.send(socket)

# 需要导入模块: from kvmsg import KVMsg [as 别名]
# 或者: from kvmsg.KVMsg import send [as 别名]
 def send_hugz(self):
     """Send hugz to anyone listening on the publisher socket"""
     kvmsg = KVMsg(self.sequence)
     kvmsg.key = "HUGZ"
     kvmsg.body = ""
     kvmsg.send(self.publisher)

# 需要导入模块: from kvmsg import KVMsg [as 别名]
# 或者: from kvmsg.KVMsg import send [as 别名]
def main():
    
    # Prepare our context and subscriber
    ctx = zmq.Context()
    snapshot = ctx.socket(zmq.DEALER)
    snapshot.linger = 0
    snapshot.connect("tcp://localhost:5556")
    subscriber = ctx.socket(zmq.SUB)
    subscriber.linger = 0
    subscriber.setsockopt(zmq.SUBSCRIBE, SUBTREE)
    subscriber.connect("tcp://localhost:5557")
    publisher = ctx.socket(zmq.PUB)
    publisher.linger = 0
    publisher.connect("tcp://localhost:5558")

    random.seed(time.time())
    kvmap = {}

    # Get state snapshot
    sequence = 0
    snapshot.send_multipart(["ICANHAZ?", SUBTREE])
    while True:
        try:
            kvmsg = KVMsg.recv(snapshot)
        except:
            raise
            return          # Interrupted
            
        if kvmsg.key == "KTHXBAI":
            sequence = kvmsg.sequence
            print "I: Received snapshot=%d" % sequence
            break          # Done
        kvmsg.store(kvmap)
    
    poller = zmq.Poller()
    poller.register(subscriber, zmq.POLLIN)
    
    alarm = time.time()+1.
    while True:
        tickless = 1000*max(0, alarm - time.time())
        try:
            items = dict(poller.poll(tickless))
        except:
            break           # Interrupted
        
        if subscriber in items:
            kvmsg = KVMsg.recv(subscriber)

            # Discard out-of-sequence kvmsgs, incl. heartbeats
            if kvmsg.sequence > sequence:
                sequence = kvmsg.sequence
                kvmsg.store(kvmap)
                action = "update" if kvmsg.body else "delete"
                print "I: received %s=%d" % (action, sequence)
        
        # If we timed-out, generate a random kvmsg
        if time.time() >= alarm:
            kvmsg = KVMsg(0)
            kvmsg.key = SUBTREE + "%d" % random.randint(1,10000)
            kvmsg.body = "%d" % random.randint(1,1000000)
            kvmsg['ttl'] = random.randint(0,30)
            kvmsg.send(publisher)
            kvmsg.store(kvmap)
            alarm = time.time() + 1.

    print " Interrupted\n%d messages in" % sequence

# 需要导入模块: from kvmsg import KVMsg [as 别名]
# 或者: from kvmsg.KVMsg import send [as 别名]
    def control_message(self):
        msg = self.pipe.recv_multipart()
        command = msg.pop(0)

        if self.debug:
            logger.debug('cmd=%s msg=%s', command, msg)
            pp(msg)

        if command == "CONNECT":
            #connect_kwargs = pipeline.load(msg[0])
            #self.connect(**connect_kwargs)
            self.connect(msg[0])
            self.pipe.send_multipart(['OK'])

        elif command == 'CONNECT_DISCOVERY':
            self.connect_via_discovery()
            self.pipe.send_multipart(['OK'])

        elif command == "DISCONNECT":
            address = msg.pop(0)
            port = int(msg.pop(0))
            self.disconnect(address, port)
            self.pipe.send_multipart(['OK'])

        elif command == "SET":
            #key, value, sttl, serializer = msg
            key, value, sttl = msg
            ttl = int(sttl)

            value = pipeline.load(value)

            # Send key-value pair on to server
            kvmsg = KVMsg(0, key=key, body=value)
            kvmsg.store(self.kvmap)
            if ttl:
                kvmsg["ttl"] = ttl
            #if serializer:
            #    kvmsg["serializer"] = serializer
            kvmsg.send(self.publisher)
            self.pipe.send_multipart(['OK'])

        elif command == "GET":
            key = msg[0]
            value = self.kvmap.get(key)

            if value:
                body = value.body
                #serializer = str(value.properties.get('serializer', ''))
            else:
                body = ''
                #serializer = ''

            body = pipeline.dump(body)

            #self.pipe.send_multipart([body, serializer])
            self.pipe.send_multipart([body])

        elif command == "SHOW":
            key = msg[0].upper()
            if key == 'SERVERS':
                self.pipe.send_multipart([
                    str(','.join([x.__repr__() for x in self.servers])), ''])
            elif key == 'SERVER':
                self.pipe.send_multipart([str(self.cur_server), ''])
            elif key == 'SEQ':
                self.pipe.send_multipart([str(self.sequence), ''])
            elif key == 'STATUS':
                self.pipe.send_multipart([str(self.cur_status), ''])
            elif key == 'KVMAP':
                #kvmap_s = pickle.dumps(self.kvmap)
                #self.pipe.send_multipart([kvmap_s, 'pickle'])
                kvmap_s = pipeline.dump(self.kvmap)
                self.pipe.send_multipart([kvmap_s])