Golang rpc.ServerCodec類代碼示例

// readRequest reads a single request from a connection.
func (s *Server) readRequest(codec rpc.ServerCodec, authHook func(proto.Message, bool) error) (
	req rpc.Request, m method, args proto.Message, err error) {
	if err = codec.ReadRequestHeader(&req); err != nil {
		return
	}

	s.mu.RLock()
	var ok bool
	m, ok = s.methods[req.ServiceMethod]
	s.mu.RUnlock()

	// If we found the method, construct a request protobuf and parse into it.
	// If not, consume and discard the input by passing nil to ReadRequestBody.
	if ok {
		args = reflect.New(m.reqType.Elem()).Interface().(proto.Message)
	}
	if err = codec.ReadRequestBody(args); err != nil {
		return
	}
	if args == nil {
		return
	}
	err = authHook(args, m.public)
	return
}

// readRequest reads a single request from a connection.
func (s *Server) readRequest(codec rpc.ServerCodec, authHook func(proto.Message, bool) error) (rpc.Request, method, proto.Message, error) {
	var req rpc.Request
	if err := codec.ReadRequestHeader(&req); err != nil {
		return req, method{}, nil, err
	}

	s.mu.RLock()
	m, ok := s.methods[req.ServiceMethod]
	s.mu.RUnlock()

	// If we found the method, construct a request protobuf, parse into
	// it, and authenticate it.
	if ok {
		args := reflect.New(m.reqType.Elem()).Interface().(proto.Message)

		if err := codec.ReadRequestBody(args); err != nil {
			return req, m, args, err
		}

		return req, m, args, authHook(args, m.public)
	}

	// If not, consume and discard the input by passing nil to ReadRequestBody.
	return req, m, nil, codec.ReadRequestBody(nil)
}

func (s *ServerImpl) sendResponse(sending *sync.Mutex, req *rpc.Request, resp *rpc.Response, reply interface{}, codec rpc.ServerCodec, errmsg string) {
	resp.ServiceMethod = req.ServiceMethod
	if errmsg != "" {
		resp.Error = errmsg
		reply = invalidRequest
	}
	resp.Seq = req.Seq
	sending.Lock()
	defer sending.Unlock()
	err := codec.WriteResponse(resp, reply)
	if err != nil {
		log.Println("rpc: writing response:", err)
	}
}

// sendResponses sends a stream of responses on a connection, and
// exits when the channel is closed.
func (s *Server) sendResponses(codec rpc.ServerCodec, responses <-chan serverResponse) {
	for resp := range responses {
		rpcResp := rpc.Response{
			ServiceMethod: resp.req.ServiceMethod,
			Seq:           resp.req.Seq,
		}
		if resp.err != nil {
			rpcResp.Error = resp.err.Error()
		}
		if err := codec.WriteResponse(&rpcResp, resp.reply); err != nil {
			log.Warningf("rpc: write response failed: %s", err)
			// TODO(bdarnell): what to do at this point? close the connection?
			// net/rpc just swallows the error.
		}
	}
}