'Process a broadcast message.  This is called for all cells
that touch this message.
The message is sent to all cells in the certain direction and
the creator of this message has the option of whether or not
to process it locally as well.
If responses from all cells are required, each hop creates an
eventlet queue and waits for responses from its immediate
neighbor cells.  All responses are then aggregated into a
single list and are returned to the neighbor cell until the
source is reached.
When the source is reached, a list of Response instances are
returned to the caller.
All exceptions for processing the message across the whole
routing path are caught and encoded within the Response and
returned to the caller.  It is possible to get a mix of
successful responses and failure responses.  The caller is
responsible for dealing with this.'

def process(self):

    try:
        next_hops = self._get_next_hops()
    except Exception:
        exc_info = sys.exc_info()
        LOG.exception('Error    locating    next    hops    for    message')
        return self._send_response_from_exception(exc_info)
    if (not self.need_response):
        if self.run_locally:
            self._process_locally()
        self._send_to_cells(next_hops)
        return
    try:
        self._setup_response_queue()
        self._send_to_cells(next_hops)
    except Exception:
        exc_info = sys.exc_info()
        LOG.exception('Error    sending    message    to    next    hops.')
        self._cleanup_response_queue()
        return self._send_response_from_exception(exc_info)
    if self.run_locally:
        local_response = self._process_locally()
    else:
        local_response = None
    try:
        remote_responses = self._wait_for_json_responses(num_responses=len(next_hops))
    except Exception:
        exc_info = sys.exc_info()
        LOG.exception('Error    waiting    for    responses    from    neighbor    cells')
        return self._send_response_from_exception(exc_info)
    if local_response:
        remote_responses.append(local_response.to_json())
    return self._send_json_responses(remote_responses)
