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
