code review 4889043: rpc: implement ServeRequest to synchronously serve a si...

src/pkg/rpc/server.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 /*
         Package rpc provides access to the exported methods of an object across a
         network or other I/O connection.  A server registers an object, making it visible
         as a service with the name of the type of the object.  After registration, exported
         methods of the object will be accessible remotely.  A server may register multiple
         objects (services) of different types but it is an error to register multiple
@@ skipping 396 matching lines @@
                                 server.sendResponse(sending, req, invalidRequest, codec, err.String())
                                 server.freeRequest(req)
                         }
                         continue
                 }
                 go service.call(server, sending, mtype, req, argv, replyv, codec)
         }
         codec.Close()
 }
 
-// ServeSingle is like ServeCodec but synchronously serves a single request
-// without launching a goroutine. It does not close the codec upon completion.
-func (server *Server) ServeSingle(codec ServerCodec) os.Error {
+// ServeRequest is like ServeCodec but synchronously serves a single request.
+// It does not close the codec upon completion.
+func (server *Server) ServeRequest(codec ServerCodec) os.Error {
         sending := new(sync.Mutex)
         service, mtype, req, argv, replyv, err := server.readRequest(codec)
         if err != nil {
                 if err == os.EOF || err == io.ErrUnexpectedEOF {
                         return err
                 }
                 // send a response if we actually managed to read a header.
                 if req != nil {
                         server.sendResponse(sending, req, invalidRequest, codec, err.String())
                         server.freeRequest(req)
@@ skipping 153 matching lines @@
 func ServeConn(conn io.ReadWriteCloser) {
         DefaultServer.ServeConn(conn)
 }
 
 // ServeCodec is like ServeConn but uses the specified codec to
 // decode requests and encode responses.
 func ServeCodec(codec ServerCodec) {
         DefaultServer.ServeCodec(codec)
 }
 
-// ServeSingle is like ServeCodec but synchronously serves a single request
-// without launching a goroutine. It does not close the codec upon completion.
-func ServeSingle(codec ServerCodec) os.Error {
-        return DefaultServer.ServeSingle(codec)
+// ServeRequest is like ServeCodec but synchronously serves a single request.
+// It does not close the codec upon completion.
+func ServeRequest(codec ServerCodec) os.Error {
+        return DefaultServer.ServeRequest(codec)
 }
 
 // Accept accepts connections on the listener and serves requests
 // to DefaultServer for each incoming connection.··
 // Accept blocks; the caller typically invokes it in a go statement.
 func Accept(lis net.Listener) { DefaultServer.Accept(lis) }
 
 // Can connect to RPC service using HTTP CONNECT to rpcPath.
 var connected = "200 Connected to Go RPC"
 
@@ skipping 21 matching lines @@
         http.Handle(rpcPath, server)
         http.Handle(debugPath, debugHTTP{server})
 }
 
 // HandleHTTP registers an HTTP handler for RPC messages to DefaultServer
 // on DefaultRPCPath and a debugging handler on DefaultDebugPath.
 // It is still necessary to invoke http.Serve(), typically in a go statement.
 func HandleHTTP() {
         DefaultServer.HandleHTTP(DefaultRPCPath, DefaultDebugPath)
 }