example: load_balancing

Show how to configure RR

Author: menghanl

Diff for: examples/features/load_balancing/README.md

@@ -0,0 +1,68 @@
+# Load balancing
+
+This examples shows how `ClientConn` can pick different load balancing policies.
+
+## Try it
+
+```
+go run server/main.go
+```
+
+```
+go run client/main.go
+```
+
+## Explanation
+
+Two helloworld servers are serving on ":50051" and ":50052". They will include
+their serving address in the response. So the server on ":50051" will reply to
+the RPC with `hello lb (from :50051)`.
+
+Two clients are created, to connect to both of these servers (they get both
+server addresses from the name resolver).
+
+### pick_first
+
+The first client is configured to use `pick_first`. `pick_first` tries to
+connect to the first address, uses it for all RPCs if it connects, or try the
+next address if it fails (and keep doing that until one connection is
+successful). Because of this, all the RPCs will be sent to the same backend. The
+responses received all show the same backend address.
+
+```
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50051)
+```
+
+### round_robin
+
+The second client is configured to use `round_robin`. `round_robin` connects to
+all the addresses it sees, and sends an RPC to each backend one at a time in
+order. E.g. the first RPC will be sent to backend-1, the second RPC will be be
+sent to backend-2, and the third RPC will be be sent to backend-1 again.
+
+```
+hello lb (from :50051)
+hello lb (from :50051)
+hello lb (from :50052)
+hello lb (from :50051)
+hello lb (from :50052)
+hello lb (from :50051)
+hello lb (from :50052)
+hello lb (from :50051)
+hello lb (from :50052)
+hello lb (from :50051)
+```
+
+Note that it's possible to see two continues RPC sent to the same backend.
+That's because `round_robin` only picks the connections ready for RPCs. So if
+one of the two connections is not ready for some reason, all RPCs will be sent
+to the ready connection.

Diff for: examples/features/load_balancing/client/main.go

@@ -0,0 +1,114 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"google.golang.org/grpc"
+	hwpb "google.golang.org/grpc/examples/helloworld/helloworld"
+	"google.golang.org/grpc/resolver"
+)
+
+const splitScheme = "split"
+
+var addrs = []string{"localhost:50051", "localhost:50052"}
+
+type splitResolverBuilder struct{}
+
+func (*splitResolverBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOption) (resolver.Resolver, error) {
+	r := &splitResolver{target: target, cc: cc}
+	r.start()
+	return r, nil
+}
+func (*splitResolverBuilder) Scheme() string { return splitScheme }
+
+type splitResolver struct {
+	target resolver.Target
+	cc     resolver.ClientConn
+}
+
+func (r *splitResolver) start() {
+	splitted := strings.Split(r.target.Endpoint, ",")
+	addrs := make([]resolver.Address, len(splitted), len(splitted))
+	for i, s := range splitted {
+		addrs[i] = resolver.Address{Addr: s}
+	}
+	r.cc.NewAddress(addrs)
+}
+func (*splitResolver) ResolveNow(o resolver.ResolveNowOption) {}
+func (*splitResolver) Close()                                 {}
+
+func init() { resolver.Register(&splitResolverBuilder{}) }
+
+///////////////////////////////////////////////////////////////////////
+
+// callSayHello calls SayHello on c with the given name, and prints the
+// response.
+func callSayHello(c hwpb.GreeterClient, name string) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	r, err := c.SayHello(ctx, &hwpb.HelloRequest{Name: name})
+	if err != nil {
+		log.Fatalf("could not greet: %v", err)
+	}
+	fmt.Println(r.Message)
+}
+
+func makeRPCs(cc *grpc.ClientConn, n int) {
+	hwc := hwpb.NewGreeterClient(cc)
+	for i := 0; i < n; i++ {
+		callSayHello(hwc, "lb")
+	}
+}
+
+func main() {
+	pickfirstConn, err := grpc.Dial(
+		fmt.Sprintf("%s:///%s", splitScheme, strings.Join(addrs, ",")),
+		// grpc.WithBalancerName("pick_first"), // "pick_first" is the default, so this DialOption is not necessary.
+		grpc.WithInsecure(),
+	)
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	defer pickfirstConn.Close()
+
+	fmt.Println("--- calling helloworld.Greeter/SayHello with pick_first ---")
+	makeRPCs(pickfirstConn, 10)
+
+	fmt.Println()
+
+	// Make another ClientConn with round_robin policy.
+	roundrobinConn, err := grpc.Dial(
+		fmt.Sprintf("%s:///%s", splitScheme, strings.Join(addrs, ",")),
+		grpc.WithBalancerName("round_robin"), // This sets the initial balancing policy.
+		grpc.WithInsecure(),
+	)
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	defer roundrobinConn.Close()
+
+	fmt.Println("--- calling helloworld.Greeter/SayHello with round_robin ---")
+	makeRPCs(roundrobinConn, 10)
+}

Diff for: examples/features/load_balancing/server/main.go

@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net"
+	"sync"
+
+	"google.golang.org/grpc"
+	hwpb "google.golang.org/grpc/examples/helloworld/helloworld"
+)
+
+var (
+	addrs = []string{":50051", ":50052"}
+)
+
+// hwServer is used to implement helloworld.GreeterServer.
+type hwServer struct {
+	addr string
+}
+
+// SayHello implements helloworld.GreeterServer
+func (s *hwServer) SayHello(ctx context.Context, in *hwpb.HelloRequest) (*hwpb.HelloReply, error) {
+	return &hwpb.HelloReply{Message: fmt.Sprintf("hello %s (from %s)", in.Name, s.addr)}, nil
+}
+
+func startServer(addr string) {
+	lis, err := net.Listen("tcp", addr)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	s := grpc.NewServer()
+	hwpb.RegisterGreeterServer(s, &hwServer{addr: addr})
+	log.Printf("serving on %s\n", addr)
+	if err := s.Serve(lis); err != nil {
+		log.Fatalf("failed to serve: %v", err)
+	}
+}
+
+func main() {
+	var wg sync.WaitGroup
+	for _, addr := range addrs {
+		wg.Add(1)
+		go func(addr string) {
+			defer wg.Done()
+			startServer(addr)
+		}(addr)
+	}
+	wg.Wait()
+}