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