...
Run Format

Source file src/net/rpc/server_test.go

Documentation: net/rpc

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package rpc
     6  
     7  import (
     8  	"errors"
     9  	"fmt"
    10  	"io"
    11  	"log"
    12  	"net"
    13  	"net/http/httptest"
    14  	"reflect"
    15  	"runtime"
    16  	"strings"
    17  	"sync"
    18  	"sync/atomic"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  var (
    24  	newServer                 *Server
    25  	serverAddr, newServerAddr string
    26  	httpServerAddr            string
    27  	once, newOnce, httpOnce   sync.Once
    28  )
    29  
    30  const (
    31  	newHttpPath = "/foo"
    32  )
    33  
    34  type Args struct {
    35  	A, B int
    36  }
    37  
    38  type Reply struct {
    39  	C int
    40  }
    41  
    42  type Arith int
    43  
    44  // Some of Arith's methods have value args, some have pointer args. That's deliberate.
    45  
    46  func (t *Arith) Add(args Args, reply *Reply) error {
    47  	reply.C = args.A + args.B
    48  	return nil
    49  }
    50  
    51  func (t *Arith) Mul(args *Args, reply *Reply) error {
    52  	reply.C = args.A * args.B
    53  	return nil
    54  }
    55  
    56  func (t *Arith) Div(args Args, reply *Reply) error {
    57  	if args.B == 0 {
    58  		return errors.New("divide by zero")
    59  	}
    60  	reply.C = args.A / args.B
    61  	return nil
    62  }
    63  
    64  func (t *Arith) String(args *Args, reply *string) error {
    65  	*reply = fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
    66  	return nil
    67  }
    68  
    69  func (t *Arith) Scan(args string, reply *Reply) (err error) {
    70  	_, err = fmt.Sscan(args, &reply.C)
    71  	return
    72  }
    73  
    74  func (t *Arith) Error(args *Args, reply *Reply) error {
    75  	panic("ERROR")
    76  }
    77  
    78  func (t *Arith) SleepMilli(args *Args, reply *Reply) error {
    79  	time.Sleep(time.Duration(args.A) * time.Millisecond)
    80  	return nil
    81  }
    82  
    83  type hidden int
    84  
    85  func (t *hidden) Exported(args Args, reply *Reply) error {
    86  	reply.C = args.A + args.B
    87  	return nil
    88  }
    89  
    90  type Embed struct {
    91  	hidden
    92  }
    93  
    94  type BuiltinTypes struct{}
    95  
    96  func (BuiltinTypes) Map(args *Args, reply *map[int]int) error {
    97  	(*reply)[args.A] = args.B
    98  	return nil
    99  }
   100  
   101  func (BuiltinTypes) Slice(args *Args, reply *[]int) error {
   102  	*reply = append(*reply, args.A, args.B)
   103  	return nil
   104  }
   105  
   106  func (BuiltinTypes) Array(args *Args, reply *[2]int) error {
   107  	(*reply)[0] = args.A
   108  	(*reply)[1] = args.B
   109  	return nil
   110  }
   111  
   112  func listenTCP() (net.Listener, string) {
   113  	l, e := net.Listen("tcp", "127.0.0.1:0") // any available address
   114  	if e != nil {
   115  		log.Fatalf("net.Listen tcp :0: %v", e)
   116  	}
   117  	return l, l.Addr().String()
   118  }
   119  
   120  func startServer() {
   121  	Register(new(Arith))
   122  	Register(new(Embed))
   123  	RegisterName("net.rpc.Arith", new(Arith))
   124  	Register(BuiltinTypes{})
   125  
   126  	var l net.Listener
   127  	l, serverAddr = listenTCP()
   128  	log.Println("Test RPC server listening on", serverAddr)
   129  	go Accept(l)
   130  
   131  	HandleHTTP()
   132  	httpOnce.Do(startHttpServer)
   133  }
   134  
   135  func startNewServer() {
   136  	newServer = NewServer()
   137  	newServer.Register(new(Arith))
   138  	newServer.Register(new(Embed))
   139  	newServer.RegisterName("net.rpc.Arith", new(Arith))
   140  	newServer.RegisterName("newServer.Arith", new(Arith))
   141  
   142  	var l net.Listener
   143  	l, newServerAddr = listenTCP()
   144  	log.Println("NewServer test RPC server listening on", newServerAddr)
   145  	go newServer.Accept(l)
   146  
   147  	newServer.HandleHTTP(newHttpPath, "/bar")
   148  	httpOnce.Do(startHttpServer)
   149  }
   150  
   151  func startHttpServer() {
   152  	server := httptest.NewServer(nil)
   153  	httpServerAddr = server.Listener.Addr().String()
   154  	log.Println("Test HTTP RPC server listening on", httpServerAddr)
   155  }
   156  
   157  func TestRPC(t *testing.T) {
   158  	once.Do(startServer)
   159  	testRPC(t, serverAddr)
   160  	newOnce.Do(startNewServer)
   161  	testRPC(t, newServerAddr)
   162  	testNewServerRPC(t, newServerAddr)
   163  }
   164  
   165  func testRPC(t *testing.T, addr string) {
   166  	client, err := Dial("tcp", addr)
   167  	if err != nil {
   168  		t.Fatal("dialing", err)
   169  	}
   170  	defer client.Close()
   171  
   172  	// Synchronous calls
   173  	args := &Args{7, 8}
   174  	reply := new(Reply)
   175  	err = client.Call("Arith.Add", args, reply)
   176  	if err != nil {
   177  		t.Errorf("Add: expected no error but got string %q", err.Error())
   178  	}
   179  	if reply.C != args.A+args.B {
   180  		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   181  	}
   182  
   183  	// Methods exported from unexported embedded structs
   184  	args = &Args{7, 0}
   185  	reply = new(Reply)
   186  	err = client.Call("Embed.Exported", args, reply)
   187  	if err != nil {
   188  		t.Errorf("Add: expected no error but got string %q", err.Error())
   189  	}
   190  	if reply.C != args.A+args.B {
   191  		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   192  	}
   193  
   194  	// Nonexistent method
   195  	args = &Args{7, 0}
   196  	reply = new(Reply)
   197  	err = client.Call("Arith.BadOperation", args, reply)
   198  	// expect an error
   199  	if err == nil {
   200  		t.Error("BadOperation: expected error")
   201  	} else if !strings.HasPrefix(err.Error(), "rpc: can't find method ") {
   202  		t.Errorf("BadOperation: expected can't find method error; got %q", err)
   203  	}
   204  
   205  	// Unknown service
   206  	args = &Args{7, 8}
   207  	reply = new(Reply)
   208  	err = client.Call("Arith.Unknown", args, reply)
   209  	if err == nil {
   210  		t.Error("expected error calling unknown service")
   211  	} else if !strings.Contains(err.Error(), "method") {
   212  		t.Error("expected error about method; got", err)
   213  	}
   214  
   215  	// Out of order.
   216  	args = &Args{7, 8}
   217  	mulReply := new(Reply)
   218  	mulCall := client.Go("Arith.Mul", args, mulReply, nil)
   219  	addReply := new(Reply)
   220  	addCall := client.Go("Arith.Add", args, addReply, nil)
   221  
   222  	addCall = <-addCall.Done
   223  	if addCall.Error != nil {
   224  		t.Errorf("Add: expected no error but got string %q", addCall.Error.Error())
   225  	}
   226  	if addReply.C != args.A+args.B {
   227  		t.Errorf("Add: expected %d got %d", addReply.C, args.A+args.B)
   228  	}
   229  
   230  	mulCall = <-mulCall.Done
   231  	if mulCall.Error != nil {
   232  		t.Errorf("Mul: expected no error but got string %q", mulCall.Error.Error())
   233  	}
   234  	if mulReply.C != args.A*args.B {
   235  		t.Errorf("Mul: expected %d got %d", mulReply.C, args.A*args.B)
   236  	}
   237  
   238  	// Error test
   239  	args = &Args{7, 0}
   240  	reply = new(Reply)
   241  	err = client.Call("Arith.Div", args, reply)
   242  	// expect an error: zero divide
   243  	if err == nil {
   244  		t.Error("Div: expected error")
   245  	} else if err.Error() != "divide by zero" {
   246  		t.Error("Div: expected divide by zero error; got", err)
   247  	}
   248  
   249  	// Bad type.
   250  	reply = new(Reply)
   251  	err = client.Call("Arith.Add", reply, reply) // args, reply would be the correct thing to use
   252  	if err == nil {
   253  		t.Error("expected error calling Arith.Add with wrong arg type")
   254  	} else if !strings.Contains(err.Error(), "type") {
   255  		t.Error("expected error about type; got", err)
   256  	}
   257  
   258  	// Non-struct argument
   259  	const Val = 12345
   260  	str := fmt.Sprint(Val)
   261  	reply = new(Reply)
   262  	err = client.Call("Arith.Scan", &str, reply)
   263  	if err != nil {
   264  		t.Errorf("Scan: expected no error but got string %q", err.Error())
   265  	} else if reply.C != Val {
   266  		t.Errorf("Scan: expected %d got %d", Val, reply.C)
   267  	}
   268  
   269  	// Non-struct reply
   270  	args = &Args{27, 35}
   271  	str = ""
   272  	err = client.Call("Arith.String", args, &str)
   273  	if err != nil {
   274  		t.Errorf("String: expected no error but got string %q", err.Error())
   275  	}
   276  	expect := fmt.Sprintf("%d+%d=%d", args.A, args.B, args.A+args.B)
   277  	if str != expect {
   278  		t.Errorf("String: expected %s got %s", expect, str)
   279  	}
   280  
   281  	args = &Args{7, 8}
   282  	reply = new(Reply)
   283  	err = client.Call("Arith.Mul", args, reply)
   284  	if err != nil {
   285  		t.Errorf("Mul: expected no error but got string %q", err.Error())
   286  	}
   287  	if reply.C != args.A*args.B {
   288  		t.Errorf("Mul: expected %d got %d", reply.C, args.A*args.B)
   289  	}
   290  
   291  	// ServiceName contain "." character
   292  	args = &Args{7, 8}
   293  	reply = new(Reply)
   294  	err = client.Call("net.rpc.Arith.Add", args, reply)
   295  	if err != nil {
   296  		t.Errorf("Add: expected no error but got string %q", err.Error())
   297  	}
   298  	if reply.C != args.A+args.B {
   299  		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   300  	}
   301  }
   302  
   303  func testNewServerRPC(t *testing.T, addr string) {
   304  	client, err := Dial("tcp", addr)
   305  	if err != nil {
   306  		t.Fatal("dialing", err)
   307  	}
   308  	defer client.Close()
   309  
   310  	// Synchronous calls
   311  	args := &Args{7, 8}
   312  	reply := new(Reply)
   313  	err = client.Call("newServer.Arith.Add", args, reply)
   314  	if err != nil {
   315  		t.Errorf("Add: expected no error but got string %q", err.Error())
   316  	}
   317  	if reply.C != args.A+args.B {
   318  		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   319  	}
   320  }
   321  
   322  func TestHTTP(t *testing.T) {
   323  	once.Do(startServer)
   324  	testHTTPRPC(t, "")
   325  	newOnce.Do(startNewServer)
   326  	testHTTPRPC(t, newHttpPath)
   327  }
   328  
   329  func testHTTPRPC(t *testing.T, path string) {
   330  	var client *Client
   331  	var err error
   332  	if path == "" {
   333  		client, err = DialHTTP("tcp", httpServerAddr)
   334  	} else {
   335  		client, err = DialHTTPPath("tcp", httpServerAddr, path)
   336  	}
   337  	if err != nil {
   338  		t.Fatal("dialing", err)
   339  	}
   340  	defer client.Close()
   341  
   342  	// Synchronous calls
   343  	args := &Args{7, 8}
   344  	reply := new(Reply)
   345  	err = client.Call("Arith.Add", args, reply)
   346  	if err != nil {
   347  		t.Errorf("Add: expected no error but got string %q", err.Error())
   348  	}
   349  	if reply.C != args.A+args.B {
   350  		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   351  	}
   352  }
   353  
   354  func TestBuiltinTypes(t *testing.T) {
   355  	once.Do(startServer)
   356  
   357  	client, err := DialHTTP("tcp", httpServerAddr)
   358  	if err != nil {
   359  		t.Fatal("dialing", err)
   360  	}
   361  	defer client.Close()
   362  
   363  	// Map
   364  	args := &Args{7, 8}
   365  	replyMap := map[int]int{}
   366  	err = client.Call("BuiltinTypes.Map", args, &replyMap)
   367  	if err != nil {
   368  		t.Errorf("Map: expected no error but got string %q", err.Error())
   369  	}
   370  	if replyMap[args.A] != args.B {
   371  		t.Errorf("Map: expected %d got %d", args.B, replyMap[args.A])
   372  	}
   373  
   374  	// Slice
   375  	args = &Args{7, 8}
   376  	replySlice := []int{}
   377  	err = client.Call("BuiltinTypes.Slice", args, &replySlice)
   378  	if err != nil {
   379  		t.Errorf("Slice: expected no error but got string %q", err.Error())
   380  	}
   381  	if e := []int{args.A, args.B}; !reflect.DeepEqual(replySlice, e) {
   382  		t.Errorf("Slice: expected %v got %v", e, replySlice)
   383  	}
   384  
   385  	// Array
   386  	args = &Args{7, 8}
   387  	replyArray := [2]int{}
   388  	err = client.Call("BuiltinTypes.Array", args, &replyArray)
   389  	if err != nil {
   390  		t.Errorf("Array: expected no error but got string %q", err.Error())
   391  	}
   392  	if e := [2]int{args.A, args.B}; !reflect.DeepEqual(replyArray, e) {
   393  		t.Errorf("Array: expected %v got %v", e, replyArray)
   394  	}
   395  }
   396  
   397  // CodecEmulator provides a client-like api and a ServerCodec interface.
   398  // Can be used to test ServeRequest.
   399  type CodecEmulator struct {
   400  	server        *Server
   401  	serviceMethod string
   402  	args          *Args
   403  	reply         *Reply
   404  	err           error
   405  }
   406  
   407  func (codec *CodecEmulator) Call(serviceMethod string, args *Args, reply *Reply) error {
   408  	codec.serviceMethod = serviceMethod
   409  	codec.args = args
   410  	codec.reply = reply
   411  	codec.err = nil
   412  	var serverError error
   413  	if codec.server == nil {
   414  		serverError = ServeRequest(codec)
   415  	} else {
   416  		serverError = codec.server.ServeRequest(codec)
   417  	}
   418  	if codec.err == nil && serverError != nil {
   419  		codec.err = serverError
   420  	}
   421  	return codec.err
   422  }
   423  
   424  func (codec *CodecEmulator) ReadRequestHeader(req *Request) error {
   425  	req.ServiceMethod = codec.serviceMethod
   426  	req.Seq = 0
   427  	return nil
   428  }
   429  
   430  func (codec *CodecEmulator) ReadRequestBody(argv interface{}) error {
   431  	if codec.args == nil {
   432  		return io.ErrUnexpectedEOF
   433  	}
   434  	*(argv.(*Args)) = *codec.args
   435  	return nil
   436  }
   437  
   438  func (codec *CodecEmulator) WriteResponse(resp *Response, reply interface{}) error {
   439  	if resp.Error != "" {
   440  		codec.err = errors.New(resp.Error)
   441  	} else {
   442  		*codec.reply = *(reply.(*Reply))
   443  	}
   444  	return nil
   445  }
   446  
   447  func (codec *CodecEmulator) Close() error {
   448  	return nil
   449  }
   450  
   451  func TestServeRequest(t *testing.T) {
   452  	once.Do(startServer)
   453  	testServeRequest(t, nil)
   454  	newOnce.Do(startNewServer)
   455  	testServeRequest(t, newServer)
   456  }
   457  
   458  func testServeRequest(t *testing.T, server *Server) {
   459  	client := CodecEmulator{server: server}
   460  	defer client.Close()
   461  
   462  	args := &Args{7, 8}
   463  	reply := new(Reply)
   464  	err := client.Call("Arith.Add", args, reply)
   465  	if err != nil {
   466  		t.Errorf("Add: expected no error but got string %q", err.Error())
   467  	}
   468  	if reply.C != args.A+args.B {
   469  		t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   470  	}
   471  
   472  	err = client.Call("Arith.Add", nil, reply)
   473  	if err == nil {
   474  		t.Errorf("expected error calling Arith.Add with nil arg")
   475  	}
   476  }
   477  
   478  type ReplyNotPointer int
   479  type ArgNotPublic int
   480  type ReplyNotPublic int
   481  type NeedsPtrType int
   482  type local struct{}
   483  
   484  func (t *ReplyNotPointer) ReplyNotPointer(args *Args, reply Reply) error {
   485  	return nil
   486  }
   487  
   488  func (t *ArgNotPublic) ArgNotPublic(args *local, reply *Reply) error {
   489  	return nil
   490  }
   491  
   492  func (t *ReplyNotPublic) ReplyNotPublic(args *Args, reply *local) error {
   493  	return nil
   494  }
   495  
   496  func (t *NeedsPtrType) NeedsPtrType(args *Args, reply *Reply) error {
   497  	return nil
   498  }
   499  
   500  // Check that registration handles lots of bad methods and a type with no suitable methods.
   501  func TestRegistrationError(t *testing.T) {
   502  	err := Register(new(ReplyNotPointer))
   503  	if err == nil {
   504  		t.Error("expected error registering ReplyNotPointer")
   505  	}
   506  	err = Register(new(ArgNotPublic))
   507  	if err == nil {
   508  		t.Error("expected error registering ArgNotPublic")
   509  	}
   510  	err = Register(new(ReplyNotPublic))
   511  	if err == nil {
   512  		t.Error("expected error registering ReplyNotPublic")
   513  	}
   514  	err = Register(NeedsPtrType(0))
   515  	if err == nil {
   516  		t.Error("expected error registering NeedsPtrType")
   517  	} else if !strings.Contains(err.Error(), "pointer") {
   518  		t.Error("expected hint when registering NeedsPtrType")
   519  	}
   520  }
   521  
   522  type WriteFailCodec int
   523  
   524  func (WriteFailCodec) WriteRequest(*Request, interface{}) error {
   525  	// the panic caused by this error used to not unlock a lock.
   526  	return errors.New("fail")
   527  }
   528  
   529  func (WriteFailCodec) ReadResponseHeader(*Response) error {
   530  	select {}
   531  }
   532  
   533  func (WriteFailCodec) ReadResponseBody(interface{}) error {
   534  	select {}
   535  }
   536  
   537  func (WriteFailCodec) Close() error {
   538  	return nil
   539  }
   540  
   541  func TestSendDeadlock(t *testing.T) {
   542  	client := NewClientWithCodec(WriteFailCodec(0))
   543  	defer client.Close()
   544  
   545  	done := make(chan bool)
   546  	go func() {
   547  		testSendDeadlock(client)
   548  		testSendDeadlock(client)
   549  		done <- true
   550  	}()
   551  	select {
   552  	case <-done:
   553  		return
   554  	case <-time.After(5 * time.Second):
   555  		t.Fatal("deadlock")
   556  	}
   557  }
   558  
   559  func testSendDeadlock(client *Client) {
   560  	defer func() {
   561  		recover()
   562  	}()
   563  	args := &Args{7, 8}
   564  	reply := new(Reply)
   565  	client.Call("Arith.Add", args, reply)
   566  }
   567  
   568  func dialDirect() (*Client, error) {
   569  	return Dial("tcp", serverAddr)
   570  }
   571  
   572  func dialHTTP() (*Client, error) {
   573  	return DialHTTP("tcp", httpServerAddr)
   574  }
   575  
   576  func countMallocs(dial func() (*Client, error), t *testing.T) float64 {
   577  	once.Do(startServer)
   578  	client, err := dial()
   579  	if err != nil {
   580  		t.Fatal("error dialing", err)
   581  	}
   582  	defer client.Close()
   583  
   584  	args := &Args{7, 8}
   585  	reply := new(Reply)
   586  	return testing.AllocsPerRun(100, func() {
   587  		err := client.Call("Arith.Add", args, reply)
   588  		if err != nil {
   589  			t.Errorf("Add: expected no error but got string %q", err.Error())
   590  		}
   591  		if reply.C != args.A+args.B {
   592  			t.Errorf("Add: expected %d got %d", reply.C, args.A+args.B)
   593  		}
   594  	})
   595  }
   596  
   597  func TestCountMallocs(t *testing.T) {
   598  	if testing.Short() {
   599  		t.Skip("skipping malloc count in short mode")
   600  	}
   601  	if runtime.GOMAXPROCS(0) > 1 {
   602  		t.Skip("skipping; GOMAXPROCS>1")
   603  	}
   604  	fmt.Printf("mallocs per rpc round trip: %v\n", countMallocs(dialDirect, t))
   605  }
   606  
   607  func TestCountMallocsOverHTTP(t *testing.T) {
   608  	if testing.Short() {
   609  		t.Skip("skipping malloc count in short mode")
   610  	}
   611  	if runtime.GOMAXPROCS(0) > 1 {
   612  		t.Skip("skipping; GOMAXPROCS>1")
   613  	}
   614  	fmt.Printf("mallocs per HTTP rpc round trip: %v\n", countMallocs(dialHTTP, t))
   615  }
   616  
   617  type writeCrasher struct {
   618  	done chan bool
   619  }
   620  
   621  func (writeCrasher) Close() error {
   622  	return nil
   623  }
   624  
   625  func (w *writeCrasher) Read(p []byte) (int, error) {
   626  	<-w.done
   627  	return 0, io.EOF
   628  }
   629  
   630  func (writeCrasher) Write(p []byte) (int, error) {
   631  	return 0, errors.New("fake write failure")
   632  }
   633  
   634  func TestClientWriteError(t *testing.T) {
   635  	w := &writeCrasher{done: make(chan bool)}
   636  	c := NewClient(w)
   637  	defer c.Close()
   638  
   639  	res := false
   640  	err := c.Call("foo", 1, &res)
   641  	if err == nil {
   642  		t.Fatal("expected error")
   643  	}
   644  	if err.Error() != "fake write failure" {
   645  		t.Error("unexpected value of error:", err)
   646  	}
   647  	w.done <- true
   648  }
   649  
   650  func TestTCPClose(t *testing.T) {
   651  	once.Do(startServer)
   652  
   653  	client, err := dialHTTP()
   654  	if err != nil {
   655  		t.Fatalf("dialing: %v", err)
   656  	}
   657  	defer client.Close()
   658  
   659  	args := Args{17, 8}
   660  	var reply Reply
   661  	err = client.Call("Arith.Mul", args, &reply)
   662  	if err != nil {
   663  		t.Fatal("arith error:", err)
   664  	}
   665  	t.Logf("Arith: %d*%d=%d\n", args.A, args.B, reply)
   666  	if reply.C != args.A*args.B {
   667  		t.Errorf("Add: expected %d got %d", reply.C, args.A*args.B)
   668  	}
   669  }
   670  
   671  func TestErrorAfterClientClose(t *testing.T) {
   672  	once.Do(startServer)
   673  
   674  	client, err := dialHTTP()
   675  	if err != nil {
   676  		t.Fatalf("dialing: %v", err)
   677  	}
   678  	err = client.Close()
   679  	if err != nil {
   680  		t.Fatal("close error:", err)
   681  	}
   682  	err = client.Call("Arith.Add", &Args{7, 9}, new(Reply))
   683  	if err != ErrShutdown {
   684  		t.Errorf("Forever: expected ErrShutdown got %v", err)
   685  	}
   686  }
   687  
   688  // Tests the fix to issue 11221. Without the fix, this loops forever or crashes.
   689  func TestAcceptExitAfterListenerClose(t *testing.T) {
   690  	newServer := NewServer()
   691  	newServer.Register(new(Arith))
   692  	newServer.RegisterName("net.rpc.Arith", new(Arith))
   693  	newServer.RegisterName("newServer.Arith", new(Arith))
   694  
   695  	var l net.Listener
   696  	l, _ = listenTCP()
   697  	l.Close()
   698  	newServer.Accept(l)
   699  }
   700  
   701  func TestShutdown(t *testing.T) {
   702  	var l net.Listener
   703  	l, _ = listenTCP()
   704  	ch := make(chan net.Conn, 1)
   705  	go func() {
   706  		defer l.Close()
   707  		c, err := l.Accept()
   708  		if err != nil {
   709  			t.Error(err)
   710  		}
   711  		ch <- c
   712  	}()
   713  	c, err := net.Dial("tcp", l.Addr().String())
   714  	if err != nil {
   715  		t.Fatal(err)
   716  	}
   717  	c1 := <-ch
   718  	if c1 == nil {
   719  		t.Fatal(err)
   720  	}
   721  
   722  	newServer := NewServer()
   723  	newServer.Register(new(Arith))
   724  	go newServer.ServeConn(c1)
   725  
   726  	args := &Args{7, 8}
   727  	reply := new(Reply)
   728  	client := NewClient(c)
   729  	err = client.Call("Arith.Add", args, reply)
   730  	if err != nil {
   731  		t.Fatal(err)
   732  	}
   733  
   734  	// On an unloaded system 10ms is usually enough to fail 100% of the time
   735  	// with a broken server. On a loaded system, a broken server might incorrectly
   736  	// be reported as passing, but we're OK with that kind of flakiness.
   737  	// If the code is correct, this test will never fail, regardless of timeout.
   738  	args.A = 10 // 10 ms
   739  	done := make(chan *Call, 1)
   740  	call := client.Go("Arith.SleepMilli", args, reply, done)
   741  	c.(*net.TCPConn).CloseWrite()
   742  	<-done
   743  	if call.Error != nil {
   744  		t.Fatal(err)
   745  	}
   746  }
   747  
   748  func benchmarkEndToEnd(dial func() (*Client, error), b *testing.B) {
   749  	once.Do(startServer)
   750  	client, err := dial()
   751  	if err != nil {
   752  		b.Fatal("error dialing:", err)
   753  	}
   754  	defer client.Close()
   755  
   756  	// Synchronous calls
   757  	args := &Args{7, 8}
   758  	b.ResetTimer()
   759  
   760  	b.RunParallel(func(pb *testing.PB) {
   761  		reply := new(Reply)
   762  		for pb.Next() {
   763  			err := client.Call("Arith.Add", args, reply)
   764  			if err != nil {
   765  				b.Fatalf("rpc error: Add: expected no error but got string %q", err.Error())
   766  			}
   767  			if reply.C != args.A+args.B {
   768  				b.Fatalf("rpc error: Add: expected %d got %d", reply.C, args.A+args.B)
   769  			}
   770  		}
   771  	})
   772  }
   773  
   774  func benchmarkEndToEndAsync(dial func() (*Client, error), b *testing.B) {
   775  	if b.N == 0 {
   776  		return
   777  	}
   778  	const MaxConcurrentCalls = 100
   779  	once.Do(startServer)
   780  	client, err := dial()
   781  	if err != nil {
   782  		b.Fatal("error dialing:", err)
   783  	}
   784  	defer client.Close()
   785  
   786  	// Asynchronous calls
   787  	args := &Args{7, 8}
   788  	procs := 4 * runtime.GOMAXPROCS(-1)
   789  	send := int32(b.N)
   790  	recv := int32(b.N)
   791  	var wg sync.WaitGroup
   792  	wg.Add(procs)
   793  	gate := make(chan bool, MaxConcurrentCalls)
   794  	res := make(chan *Call, MaxConcurrentCalls)
   795  	b.ResetTimer()
   796  
   797  	for p := 0; p < procs; p++ {
   798  		go func() {
   799  			for atomic.AddInt32(&send, -1) >= 0 {
   800  				gate <- true
   801  				reply := new(Reply)
   802  				client.Go("Arith.Add", args, reply, res)
   803  			}
   804  		}()
   805  		go func() {
   806  			for call := range res {
   807  				A := call.Args.(*Args).A
   808  				B := call.Args.(*Args).B
   809  				C := call.Reply.(*Reply).C
   810  				if A+B != C {
   811  					b.Errorf("incorrect reply: Add: expected %d got %d", A+B, C)
   812  					return
   813  				}
   814  				<-gate
   815  				if atomic.AddInt32(&recv, -1) == 0 {
   816  					close(res)
   817  				}
   818  			}
   819  			wg.Done()
   820  		}()
   821  	}
   822  	wg.Wait()
   823  }
   824  
   825  func BenchmarkEndToEnd(b *testing.B) {
   826  	benchmarkEndToEnd(dialDirect, b)
   827  }
   828  
   829  func BenchmarkEndToEndHTTP(b *testing.B) {
   830  	benchmarkEndToEnd(dialHTTP, b)
   831  }
   832  
   833  func BenchmarkEndToEndAsync(b *testing.B) {
   834  	benchmarkEndToEndAsync(dialDirect, b)
   835  }
   836  
   837  func BenchmarkEndToEndAsyncHTTP(b *testing.B) {
   838  	benchmarkEndToEndAsync(dialHTTP, b)
   839  }
   840  

View as plain text