class RpcChannel(object): """Abstract interface for an RPC channel. An RpcChannel represents a communication line to a service which can be used to call that service's methods. The service may be running on another machine. Normally, you should not use an RpcChannel directly, but instead construct a stub {@link Service} wrapping it. Example: Example: RpcChannel channel = rpcImpl.Channel("remotehost.example.com:1234") RpcController controller = rpcImpl.Controller() MyService service = MyService_Stub(channel) service.MyMethod(controller, request, callback) """ def __init__(self, exchange, response_queue, request_routing_key, max_retries=3, timeout_ms=5000): self.exchange = exchange self.response_queue = response_queue self.request_routing_key = request_routing_key self.messagebus = MessageBus() self.max_retries = max_retries # maximum number of times to retry on RPC timeout. -1 indicates infinite retries self.timeout_ms = timeout_ms # Set to -1 for no timeout self.polling_interval = 0.01 # in seconds self.sync_sequence_number = 0 self.messagebus.exchange_declare(exchange, 'direct') #self.messagebus.queue_delete(queue=response_queue) # clear it in case there are backed up messages (EDIT: it *should* autodelete) self.messagebus.queue_declare(queue=response_queue, auto_delete=True) self.messagebus.queue_purge(response_queue) self.messagebus.queue_bind(response_queue, exchange, routing_key=response_queue) logger.debug("Response queue '%s' is bound to key '%s' on exchange '%s'" % (response_queue, response_queue, exchange)) def CallMethod(self, method_descriptor, rpc_controller, request, response_class, done): """Calls the method identified by the descriptor. Call the given method of the remote service. The signature of this procedure looks the same as Service.CallMethod(), but the requirements are less strict in one important way: the request object doesn't have to be of any specific class as long as its descriptor is method.input_type. """ rpc_controller.Reset() self.sync_sequence_number += 1 wrapped_request_bytes = protocols.pack(protocols.RpcRequestWrapper, { 'requestor': self.response_queue, 'method': method_descriptor.name, 'payload': request.SerializeToString(), 'sequence_number': self.sync_sequence_number } ) #print ' '.join([hex(ord(c))[2:] for c in request.SerializeToString()]) #print ' '.join([hex(ord(c))[2:] for c in request_wrapper]) retries = 0 while True: # begin retry loop if self.max_retries > -1 and retries > self.max_retries: rpc_controller.SetFailed("Too many retries. (Max was %d)" % self.max_retries) #if done: # done(None) # raise RPCFailure("Too many retries") return None # Still not too sure about this whole return None on failure business if retries > 0: logger.info("Retrying (%d)." % retries) logger.debug("About to publish to exchange '%s' with key '%s'" % (self.exchange, self.request_routing_key)) self.messagebus.basic_publish(amqp.Message(wrapped_request_bytes), exchange=self.exchange, routing_key=self.request_routing_key) # Wait for a response logger.debug("Waiting for a response on queue '%s'" % self.response_queue) timeout_flag = False sync_ok = False t0 = time.time() # begin sync loop while not sync_ok: # begin response loop response = None while not response: delta_t = time.time() - t0 if self.timeout_ms >= 0 and delta_t * 1000.0 > self.timeout_ms: timeout_flag = True break response = self.messagebus.basic_get(self.response_queue, no_ack=True) # returns a message or None if not response: time.sleep(self.polling_interval) # polling interval # end response loop #self.messagebus.basic_ack(response.delivery_tag) if timeout_flag: logger.warning("RPC method '%s' timed out," % method_descriptor.name) retries += 1 break # from the sync loop out to retry loop. resets timer logger.info("Got a response in %s secs" % str(time.time() - t0)) response_wrapper = protocols.unpack(protocols.RpcResponseWrapper, response.body) if response_wrapper.sequence_number == self.sync_sequence_number: logger.debug("Sync OK!") sync_ok = True break # from the sync loop else: sync_delta = self.sync_sequence_number - response_wrapper.sequence_number logger.warning("Message sync error. Sync delta: %d" % sync_delta) logger.debug("Expected %d but got %d" % (self.sync_sequence_number, response_wrapper.sequence_number)) if sync_delta > 0: logger.warning("Trying to catch up.") t0 = time.time() # reset the timeout clock continue # to "while not sync_ok" elif sync_delta < 0: logger.error("The message queue is ahead of us! Purging.") purged = self.messagebus.queue_purge(queue=self.response_queue) # clear the response queue and try again logger.error("Purged %d messages from %s" % (purged, self.response_queue)) time.sleep(0.1) retries += 1 break #end sync loop if timeout_flag: continue # jump to the top of the retry loop if sync_ok: break # from the retry loop if response_wrapper.error: logger.error("RPC response error: %s" % response_wrapper.error_string) rpc_controller.SetFailed(response_wrapper.error) #if done: # done(None) raise RPCFailure("RPC response error: %s" % response_wrapper.error_string) response = protocols.unpack(response_class, response_wrapper.payload) logger.debug("Response is: %s" % str(response)) if done: done(response) return response