docs: def Execute(self, message):
      """This function parses the RDFValue from the server.
  
      The Run method will be called with the specified RDFValue.
  
      Args:
        message:     The GrrMessage that we are called to process.
  
      Returns:
         Upon return a callback will be called on the server to register
         the end of the function and pass back exceptions.
      Raises:
         RuntimeError: The arguments from the server do not match the expected
                       rdf type.
      """
      self.message = message
      if message:
        self.require_fastpoll = message.require_fastpoll
  
      args = None
      try:
        if self.message.args_rdf_name:
          if not self.in_rdfvalue:
            raise RuntimeError("Did not expect arguments, got %s." %
                               self.message.args_rdf_name)
  
          if self.in_rdfvalue.__name__ != self.message.args_rdf_name:
            raise RuntimeError(
                "Unexpected arg type %s != %s." %
                (self.message.args_rdf_name, self.in_rdfvalue.__name__))
  
          args = self.message.payload
  
        # Only allow authenticated messages in the client
        if self._authentication_required and (
            self.message.auth_state !=
            rdf_flows.GrrMessage.AuthorizationState.AUTHENTICATED):
          raise RuntimeError("Message for %s was not Authenticated." %
                             self.message.name)
  
        self.cpu_start = self.proc.cpu_times()
        self.cpu_limit = self.message.cpu_limit
  
        if getattr(flags.FLAGS, "debug_client_actions", False):
          pdb.set_trace()
  
        try:
          self.Run(args)
  
        # Ensure we always add CPU usage even if an exception occurred.
        finally:
          used = self.proc.cpu_times()
          self.cpu_used = (used.user - self.cpu_start.user,
                           used.system - self.cpu_start.system)
  
      except NetworkBytesExceededError as e:
        self.SetStatus(rdf_flows.GrrStatus.ReturnedStatus.NETWORK_LIMIT_EXCEEDED,
                       "%r: %s" % (e, e), traceback.format_exc())
  
      # We want to report back all errors and map Python exceptions to
      # Grr Errors.
      except Exception as e:  # pylint: disable=broad-except
        self.SetStatus(rdf_flows.GrrStatus.ReturnedStatus.GENERIC_ERROR,
                       "%r: %s" % (e, e), traceback.format_exc())
  
        if flags.FLAGS.pdb_post_mortem:
          self.DisableNanny()
          pdb.post_mortem()
  
      if self.status.status != rdf_flows.GrrStatus.ReturnedStatus.OK:
        logging.info("Job Error (%s): %s", self.__class__.__name__,
                     self.status.error_message)
  
        if self.status.backtrace:
          logging.debug(self.status.backtrace)
  
      if self.cpu_used:
        self.status.cpu_time_used.user_cpu_time = self.cpu_used[0]
        self.status.cpu_time_used.system_cpu_time = self.cpu_used[1]
  
      # This returns the error status of the Actions to the flow.
      self.SendReply(self.status, message_type=rdf_flows.GrrMessage.Type.STATUS)
  
      self._RunGC()