Python zhelpers.dump函数代码示例

    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)

	def recv(self):
		"""
		Returns the reply message or None if there was no reply.
		"""
		try:
			items = self.poller.poll(self.timeout)
		except KeyboardInterrupt:
			return # interrupted

		if items:
			# if we got a reply, process it
			msg = self.client.recv_multipart()
			if self.verbose:
				logging.info("I: received reply:")
				dump(msg)

			# Don't try to handle errors, just assert noisily
			assert len(msg) >= 4

			empty = msg.pop(0)
			header = msg.pop(0)
			assert MDP.C_CLIENT == header

			service = msg.pop(0)
			return msg
		else:      
			logging.warn("W: permanent error, abandoning request")

    def mediate(self):#Main SBROKER work happens here, TEST ALL INCOMING MESSAGES FOR VALIDITY
        while True:# LOOP
            try:
                items = self.poller.poll(self.HEARTBEAT_INTERVAL)# SET POLLING INTERVAL ON SOCKET
            except KeyboardInterrupt:#STOP LOOP IF CTRL+C IS PRESSED
                break# Interrupted
            if items:# IF DATA CAME IN ON POLLING SOCKET
                msg = self.socket.recv_multipart()# ASSIGN INCOMING MESSAGE TO 'MSG' LIST VARIABLE
                if self.verbose:
                    logging.info("I: received message:")
                    dump(msg)

                sender = msg.pop(0)# ITEM.0 IN MSG IDENTIFIES THE CWRITER
                empty = msg.pop(0)# ITEM.1 IN MSG IDENTIFIES EMPTY DELIMITER
                assert empty == ''# CHECK IF EMPTY DELIMITER IS ACTUALLY EMPTY
                header = msg.pop(0)# ITEM.2 IN MSG IDENTIFIES CWRITER THAT SENT THE MESSAGE
                if (MDP.C_CLIENT == header):# CHECK MDP PROTOCOL AGAINST CWRITER TO CHECK THAT CWRITER LINKED TO SOCKET
                    self.process_cwriter(sender, msg)# START PROCESSING THE CWRITER, RUN PROCESSING FUNCTION ON IT
                elif (MDP.W_WORKER == header):# CHECK MDP PROTOCOL AGAINST CREADER TO CHECK THAT CREADER LINKED TO SOCKET
                    self.process_creader(sender, msg)# START PROCESSING THE CWRITER, RUN PROCESSING FUNCTION ON IT
                else:# INVALIDATE MESSAGE IF IT DIN'T COME FROM A CREADER OR A CWRITER, OR WAS INVALIDLY CONSTRUCTED
                    logging.error("E: invalid message:")
                    dump(msg)
            self.purge_creaders()# RUN FUNCTION TO CHECK FOR REMOVED/DISCONNECTED CREADERS AND DELETE THEM AND THEIR SESSIONS
            self.send_heartbeats()# RUN FUNCTION FOR SENDING HEARTBEATS TO CREADERS THAT ARE IN ACTIVE SESSIONS LIST

    def mediate(self):
        """Main broker work happens here"""
        while True:
            try:
                items = self.poller.poll(self.HEARTBEAT_INTERVAL)
            except KeyboardInterrupt:
                break # Interrupted
            if items:
                msg = self.socket.recv_multipart()
                if self.verbose:
                    logging.info("I: received message:")
                    dump(msg)

                sender = msg.pop(0)
                empty = msg.pop(0)
                assert empty == ''
                header = msg.pop(0)

                if (MDP.C_CLIENT == header):
                    self.process_client(sender, msg)
                elif (MDP.W_WORKER == header):
                    self.process_worker(sender, msg)
                else:
                    logging.error("E: invalid message:")
                    dump(msg)

            self.purge_workers()
            self.send_heartbeats()

def main():
    verbose = '-v' in sys.argv
    
    ctx = zmq.Context()
    # Prepare server socket with predictable identity
    bind_endpoint = "tcp://*:5555"
    connect_endpoint = "tcp://localhost:5555"
    server = ctx.socket(zmq.ROUTER)
    server.identity = connect_endpoint
    server.bind(bind_endpoint)
    print "I: service is ready at", bind_endpoint
    
    while True:
        try:
            request = server.recv_multipart()
        except:
            break # Interrupted
        # Frame 0: identity of client
        # Frame 1: PING, or client control frame
        # Frame 2: request body
        address, control = request[:2]
        reply = [address, control]
        if control == "PING":
            reply[1] = "PONG"
        else:
            reply.append("OK")
        if verbose:
            dump(reply)
        server.send_multipart(reply)
    print "W: interrupted"

    def send(self, service, request):
        if not isinstance(request, list):
            request = [request]

        # Prefix request with protocol frames
        # Frame 0: empty (REQ emulation)
        # Frame 1: "MDPCxy" (six bytes, MDP/Client x.y)
        # Frame 2: Service name (printable string)
        
        request = ['', MDP.C_CLIENT, service] + request
        if self.verbose:
            logging.warn("I: send request to '%s' service: ", service)
            dump(request)
        self.client.send_multipart(request)

	def send_to_sbroker(self, command, option=None, msg=None):# FUNCTION IS CALLED FOR SENDING MESSAGES TO SBROKER
		if msg is None:# CHECK IF MESSAGE IS PROVIED TO THE FUNCTION
			msg = []# IF NOT THEN SET MESSAGE TO EMPTY LIST
		elif not isinstance(msg, list):# CHECK THAT MESSAGE THAT HAS BEEN PROVIED IS TYPE LIST
			msg = [msg]# IF NOT THEN MAKE PROVIED MESSAGE INTO A LIST

		if option:# IF OPTION IS PROVIED THEN REWRAP THE MESSAGE BY PLACING OPTION FIRST:
			msg = [option] + msg# NOW THE MESSAGE LOOKS LIKE THIS: [[OPTION],[MESSAGE]]

		msg = ['', MDP.W_WORKER, command] + msg# REWRAP THE MESSAGE AGAIN WITH EMPTY DELIMITER, CREADER ID AND COMMAND:
		if self.verbose:# ['', MDP.W_WORKER, COMMAND, [OPTION], [MESSAGE]]
			logging.info("I: sending %s to broker\n", command)
			dump(msg)
		self.creader.send_multipart(msg)# SEND THE MESSAGE TO THE SOCKET, FOR THE SBROKER TO PROCESS

    def send(self, service, request):
        """Send request to broker and get reply by hook or crook.

        Takes ownership of request message and destroys it when sent.
        Returns the reply message or None if there was no reply.
        """
        if not isinstance(request, list):
            request = [request]
        request = [MDP.C_CLIENT, service] + request
        if self.verbose:
            logging.warn("I: send request to '%s' service: ", service)
            dump(request)
        reply = None

        retries = self.retries
        while retries > 0:
            self.client.send_multipart(request)
            try:
                items = self.poller.poll(self.timeout)
            except KeyboardInterrupt:
                break # interrupted

            if items:
                msg = self.client.recv_multipart()
                if self.verbose:
                    logging.info("I: received reply:")
                    dump(msg)

                # Don't try to handle errors, just assert noisily
                assert len(msg) >= 3

                header = msg.pop(0)
                assert MDP.C_CLIENT == header

                reply_service = msg.pop(0)
                assert service == reply_service

                reply = msg
                break
            else:
                if retries:
                    logging.warn("W: no reply, reconnecting...")
                    self.reconnect_to_broker()
                else:
                    logging.warn("W: permanent error, abandoning")
                    break
                retries -= 1

        return reply

    def send_to_broker(self, command, option=None, msg=None):
        """Send message to broker.
        If no msg is provided, creates one internally
        """
        if msg is None:
            msg = []
        elif not isinstance(msg, list):
            msg = [msg]

        if option:
            msg = [option] + msg

        msg = ['', MDP.W_WORKER, command] + msg
        if self.verbose:
            logging.info("I: sending %s to broker", command)
            dump(msg)
        self.worker.send_multipart(msg)

    def send_to_creader(self, creader, command, option, msg=None, rtype=None):
        if rtype is None:#CHECK IF THERE IS A VALID VALUE PASSED TO THE rype VARIABLE, IF NOT THEN
            rtype = ['0']# ASSIGN 0 AS VALUE, MEANING NO REPLY NEEDED FROM THIS REQUEST, THIS IS USED FOR GETTING SESSIONS LIST !!!!
        if msg is None:# CHECK IF THERE IS A VALID MESSAGE BEING PASSED TO THE msg VARIABLE, IF NOT THEN:
            msg = []# TURN msg VARIABLE INTO A LIST
        elif not isinstance(msg, list):# ELSE IF, msg IS NOT AN INSTANCE OF CLASS LIST THEN:
            msg = [msg]# TURN MESSAGE msg VARIABLE INTO A LIST
        #print "send_to_creader function received message: %s for: \n%s\n" % (msg,creader)#!!!!!!!!!!!!!!!
        if option is not None:# CHECK IF OPTION VARIABLE HAS BEEN PASSED, IF NOT:
            msg = [option] + msg# REWRAP THE msg INTO: [OPTION, MESSAGE]
        msg = [creader.address, '', MDP.W_WORKER, command] + msg + rtype# REWRAP msg INTO: [CREADER.ADDRESS, '', CLASS, COMMAND, MESSAGE, REPLY(true/false)]

        if self.verbose:# IF VERBOSE IS TRUE THEN:
            logging.info("I: sending %r to creader", command)# LOG OUTPUT MESSAGE
            dump(msg)# DUMP MESSAGE # print "A.SENT TO CREADER ADDRESS %s\nB.this message: %s\nC.reply was set:%s\n" % (creader, msg, rtype)
        
        self.socket.send_multipart(msg)# SEND MESSAGE

    def process_worker(self, sender, msg):
        """Process message sent to us by a worker."""
        assert len(msg) >= 1 # At least, command

        command = msg.pop(0)

        worker_ready = hexlify(sender) in self.workers

        worker = self.require_worker(sender)

        if (MDP.W_READY == command):
            assert len(msg) >= 1 # At least, a service name
            service = msg.pop(0)
            # Not first command in session or Reserved service name
            if (worker_ready or service.startswith(self.INTERNAL_SERVICE_PREFIX)):
                self.delete_worker(worker, True)
            else:
                # Attach worker to service and mark as idle
                worker.service = self.require_service(service)
                self.worker_waiting(worker)

        elif (MDP.W_REPLY == command):
            if (worker_ready):
                # Remove & save client return envelope and insert the
                # protocol header and service name, then rewrap envelope.
                client = msg.pop(0)
                empty = msg.pop(0) # ?
                msg = [client, '', MDP.C_CLIENT, worker.service.name] + msg
                self.socket.send_multipart(msg)
                self.worker_waiting(worker)
            else:
                self.delete_worker(worker, True)

        elif (MDP.W_HEARTBEAT == command):
            if (worker_ready):
                worker.expiry = time.time() + 1e-3*self.HEARTBEAT_EXPIRY
            else:
                self.delete_worker(worker, True)

        elif (MDP.W_DISCONNECT == command):
            self.delete_worker(worker, False)
        else:
            logging.error("E: invalid message:")
            dump(msg)

    def send_to_worker(self, worker, command, option, msg=None):
        """Send message to worker.
        If message is provided, sends that message.
        """

        if msg is None:
            msg = []
        elif not isinstance(msg, list):
            msg = [msg]

        # Stack routing and protocol envelopes to start of message
        # and routing envelope
        if option is not None:
            msg = [option] + msg
        msg = [worker.address, '', MDP.W_WORKER, command] + msg

        if self.verbose:
            logging.info("I: sending %r to worker", command)
            dump(msg)

        self.socket.send_multipart(msg)

    def recv(self):
        try:
            items = self.poller.poll(self.timeout)
        except KeyboardInterrupt:
            return

        if items:
            msg = self.client.recv_multipart()
            if self.verbose:
                logging.info("I: received reply:")
                dump(msg)

            assert len(msg) >= 4

            empty = msg.pop(0)
            header = msg.pop(0)
            assert MDP.C_CLIENT == header

            service = msg.pop(0)
            return msg
        else:
            logging.warn("W: permanent error, abandoning request")

		def uSession_mngr(self):
			while True: # starting session loop
				try:
					items = self.poller.poll(self.HEARTBEAT_INTERVAL)
				except KeyboardInterrupt:
					print "Interrupted with keypress"
					break# Interrupotion
				if items:# check if something came in on the polling socket
					msg = self.socket.recv_multipart()# assign that something to msg variable
					if self.verbose:
						logging.info("I: received message from connected Node")
						dump(msg)

					sender = msg.pop(0)# get the node that sent the message
					empty = msg.pop(0)#  empty delimiter frame of the message
					assert empty == ''# check if message is formatted correctly
					header = msg.pop(0) # get the node class that sent the message
					if (NP.N_NODE == header):# check the node against node protocol
						self.uNodeProcessing(sender, msg)# add node that sent the message to sessions
					else:
						logging.error("E: invalid message to sessions thread")
					self.delete_dead_uNodes()
					self.send_heartbeats_to_uNodes()

    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)