'Process a targeted message.  This is called for all cells
that touch this message.  If the local cell is the one that
created this message, we reply directly with a Response instance.
If the local cell is not the target, an eventlet queue is created
and we wait for the response to show up via another thread
receiving the Response back.
Responses to targeted messages are routed directly back to the
source.  No eventlet queues are created in intermediate hops.
All exceptions for processing the message across the whole
routing path are caught and encoded within the Response and
returned to the caller.'

def process(self):

    try:
        next_hop = self._get_next_hop()
    except Exception:
        exc_info = sys.exc_info()
        LOG.exception('Error    locating    next    hop    for    message')
        return self._send_response_from_exception(exc_info)
    if next_hop.is_me:
        response = self._process_locally()
        return self._send_response(response)
    if (self.need_response and self.source_is_us()):
        self._setup_response_queue()
        wait_for_response = True
    else:
        wait_for_response = False
    try:
        if (self.hop_count >= self.max_hop_count):
            raise exception.CellMaxHopCountReached(hop_count=self.hop_count)
        next_hop.send_message(self)
    except Exception:
        exc_info = sys.exc_info()
        err_str = 'Failed    to    send    message    to    cell:    %(next_hop)s'
        LOG.exception(err_str, {'next_hop': next_hop})
        self._cleanup_response_queue()
        return self._send_response_from_exception(exc_info)
    if wait_for_response:
        remote_response = self._wait_for_json_responses()[0]
        return Response.from_json(self.ctxt, remote_response)
