// 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.
}
}
}