docs: def SendReply(self,
                  rdf_value=None,
                  request_id=None,
                  response_id=None,
                  session_id="W:0",
                  message_type=None,
                  name=None,
                  require_fastpoll=None,
                  ttl=None,
                  blocking=True,
                  task_id=None):
      """Send the protobuf to the server.
  
      Args:
        rdf_value: The RDFvalue to return.
        request_id: The id of the request this is a response to.
        response_id: The id of this response.
        session_id: The session id of the flow.
        message_type: The contents of this message, MESSAGE, STATUS or
          RDF_VALUE.
        name: The name of the client action that sends this response.
        require_fastpoll: If set, this will set the client to fastpoll mode after
          sending this message.
        ttl: The time to live of this message.
        blocking: If the output queue is full, block until there is space.
        task_id: The task ID that the request was queued at. We send this back to
          the server so it can de-queue the request.
  
      Raises:
        RuntimeError: An object other than an RDFValue was passed for sending.
      """
      if not isinstance(rdf_value, rdfvalue.RDFValue):
        raise RuntimeError("Sending objects other than RDFValues not supported.")
  
      message = rdf_flows.GrrMessage(
          session_id=session_id,
          task_id=task_id,
          name=name,
          response_id=response_id,
          request_id=request_id,
          require_fastpoll=require_fastpoll,
          ttl=ttl,
          type=message_type)
  
      if rdf_value is not None:
        message.payload = rdf_value
  
      serialized_message = message.SerializeToString()
  
      self.ChargeBytesToSession(session_id, len(serialized_message))
  
      if message.type == rdf_flows.GrrMessage.Type.STATUS:
        rdf_value.network_bytes_sent = self.sent_bytes_per_flow[session_id]
        del self.sent_bytes_per_flow[session_id]
        message.payload = rdf_value
  
      try:
        self.QueueResponse(message, blocking=blocking)
      except queue.Full:
        # In the case of a non blocking send, we reraise the exception to notify
        # the caller that something went wrong.
        if not blocking:
          raise
  
        # There is nothing we can do about it here - we just lose the message and
        # keep going.
        logging.info("Queue is full, dropping messages.")