code: def receive_one_message(self):
          
          context, message = self.transport.receive_message()
          if callable(self.trace):
              self.trace('-->', context, message)
  
          # assuming protocol is threadsafe and dispatcher is theadsafe, as
          # long as its immutable
  
          def handle_message(context, message):
              try:
                  request = self.protocol.parse_request(message)
              except tinyrpc.exc.RPCError as e:
                  response = e.error_respond()
              else:
                  response = self.dispatcher.dispatch(request)
  
              # send reply
              if response is not None:
                  result = response.serialize()
                  if callable(self.trace):
                      self.trace('<--', context, result)
                  self.transport.send_reply(context, result)
  
          self._spawn(handle_message, context, message)
docs: Handle a single request.
  
          Polls the transport for a new message.
  
          After a new message has arrived :py:meth:`_spawn` is called with a handler
          function and arguments to handle the request.
  
          The handler function will try to decode the message using the supplied
          protocol, if that fails, an error response will be sent. After decoding
          the message, the dispatcher will be asked to handle the resulting
          request and the return value (either an error or a result) will be sent
          back to the client using the transport.