code: def onMessageReceived(self, method_frame, properties, body):
          
          # if UUID is not in headers, just ack the message and ignore it
          if "UUID" not in properties.headers:
              self.process_exception(
                  e=ValueError("No UUID provided, message ignored."),
                  uuid="",
                  routing_key=self.parseKey(method_frame),
                  body=body
              )
              return True  # ack message
  
          key = self.parseKey(method_frame)
          uuid = properties.headers["UUID"]
          try:
              result = self.react_fn(
                  serializers.deserialize(body, self.globals),
                  self.get_sendback(uuid, key)
              )
  
              print "sending response", key
  
              self.sendResponse(
                  serializers.serialize(result),
                  uuid,
                  key
              )
          except Exception, e:
              self.process_exception(
                  e=e,
                  uuid=uuid,
                  routing_key=key,
                  body=str(e),
                  tb=traceback.format_exc().strip()
              )
  
          return True
docs: React to received message - deserialize it, add it to users reaction
          function stored in ``self.react_fn`` and send back result.
  
          If `Exception` is thrown during process, it is sent back instead of
          message.
  
          Note:
              In case of `Exception`, response message doesn't have useful `body`,
              but in headers is stored following (string) parameters:
  
              - ``exception``, where the Exception's message is stored
              - ``exception_type``, where ``e.__class__`` is stored
              - ``exception_name``, where ``e.__class__.__name__`` is stored
              - ``traceback`` where the full traceback is stored (contains line
                number)
  
              This allows you to react to unexpected cases at the other end of
              the AMQP communication.