docs: def invoke_consumer(self, message):
          """Wrap the actual processor processing bits
  
          :param rejected.data.Message message: The message to process
  
          """
          # Only allow for a single message to be processed at a time
          with (yield self.consumer_lock.acquire()):
              if self.is_idle:
                  if message.channel.is_closed:
                      LOGGER.warning('Channel %s is closed on '
                                     'connection "%s", discarding '
                                     'local copy of message %s',
                                     message.channel.channel_number,
                                     message.connection,
                                     utils.message_info(message.exchange,
                                                        message.routing_key,
                                                        message.properties))
                      self.counters[self.CLOSED_ON_START] += 1
                      self.maybe_get_next_message()
                      return
  
                  self.set_state(self.STATE_PROCESSING)
                  self.delivery_time = start_time = time.time()
                  self.active_message = message
  
                  self.measurement = data.Measurement()
  
                  if message.method.redelivered:
                      self.counters[self.REDELIVERED] += 1
                      self.measurement.set_tag(self.REDELIVERED, True)
  
                  try:
                      result = yield self.consumer.execute(message,
                                                           self.measurement)
                  except Exception as error:
                      LOGGER.exception('Unhandled exception from consumer in '
                                       'process. This should not happen. %s',
                                       error)
                      result = data.MESSAGE_REQUEUE
  
                  LOGGER.debug('Finished processing message: %r', result)
                  self.on_processed(message, result, start_time)
              elif self.is_waiting_to_shutdown:
                  LOGGER.info(
                      'Requeueing pending message due to pending shutdown')
                  self.reject(message, True)
                  self.shutdown_connections()
              elif self.is_shutting_down:
                  LOGGER.info('Requeueing pending message due to shutdown')
                  self.reject(message, True)
                  self.on_ready_to_stop()
              else:
                  LOGGER.warning('Exiting invoke_consumer without processing, '
                                 'this should not happen. State: %s',
                                 self.state_description)
              self.maybe_get_next_message()