Add: hash load balance func

micro/client/app/main.go

@@ -10,10 +10,13 @@
 package main
 
 import (
+	"context"
+	"math/rand"
 	"net/http"
 	_ "net/http/pprof"
 	"os"
 	"os/signal"
+	"sync/atomic"
 	"syscall"
 	"time"
 )
@@ -22,6 +25,9 @@ import (
 	"github.com/AlexStocks/getty-examples/micro/proto"
 	"github.com/AlexStocks/getty/micro"
 	"github.com/AlexStocks/getty/rpc"
+	"github.com/AlexStocks/goext/database/filter"
+	"github.com/AlexStocks/goext/database/registry"
+	"github.com/AlexStocks/goext/log"
 	"github.com/AlexStocks/goext/net"
 	log "github.com/AlexStocks/log4go"
 	jerrors "github.com/juju/errors"
@@ -33,8 +39,13 @@ const (
 
 var (
 	client *micro.Client
+	seq    int64
 )
 
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
 ////////////////////////////////////////////////////////////////////
 // main
 ////////////////////////////////////////////////////////////////////
@@ -64,9 +75,32 @@ func initProfiling() {
 	}()
 }
 
+func LoadBalance(ctx context.Context, arr *gxfilter.ServiceArray) (*gxregistry.Service, error) {
+	var (
+		ok  bool
+		seq int64
+	)
+	if ctx == nil {
+		seq = int64(rand.Int())
+	} else if seq, ok = ctx.Value("seq").(int64); !ok {
+		return nil, jerrors.Errorf("illegal seq %#v", ctx.Value("seq"))
+	}
+
+	arrLen := len(arr.Arr)
+	if arrLen == 0 {
+		return nil, jerrors.Errorf("@arr length is 0")
+	}
+
+	service := arr.Arr[int(seq)%arrLen]
+	gxlog.CInfo("seq %d, service %#v", seq, service)
+	return service, nil
+	// return arr.Arr[seq%arrLen], nil
+	// context.WithValue(context.Background(), key, value).Value(key)
+}
+
 func initClient() {
 	var err error
-	client, err = micro.NewClient(&conf.ClientConfig, &conf.Registry)
+	client, err = micro.NewClient(&conf.ClientConfig, &conf.Registry, micro.WithServiceHash(LoadBalance))
 	if err != nil {
 		panic(jerrors.ErrorStack(err))
 	}
@@ -109,27 +143,31 @@ func initSignal() {
 
 func testJSON() {
 	ts := micro_examples.TestService{}
+	ctx := context.WithValue(context.Background(), "seq", atomic.AddInt64(&seq, 1))
 	testReq := micro_examples.TestReq{"aaa", "bbb", "ccc"}
 	testRsp := micro_examples.TestRsp{}
-	err := client.Call(nil, rpc.CodecJson, ts.Service(), ts.Version(), "Test", &testReq, &testRsp)
+	err := client.Call(ctx, rpc.CodecJson, ts.Service(), ts.Version(), "Test", &testReq,
+		&testRsp)
 	if err != nil {
 		log.Error("client.Call(Json, TestService::Test) = error:%s", jerrors.ErrorStack(err))
 		return
 	}
 	log.Info("TestService::Test(Json, param:%#v) = res:%s", testReq, testRsp)
 
+	ctx = context.WithValue(context.Background(), "seq", atomic.AddInt64(&seq, 1))
 	addReq := micro_examples.AddReq{1, 10}
 	addRsp := micro_examples.AddRsp{}
-	err = client.Call(nil, rpc.CodecJson, ts.Service(), ts.Version(), "Add", &addReq, &addRsp)
+	err = client.Call(ctx, rpc.CodecJson, ts.Service(), ts.Version(), "Add", &addReq, &addRsp)
 	if err != nil {
 		log.Error("client.Call(Json, TestService::Add) = error:%s", jerrors.ErrorStack(err))
 		return
 	}
 	log.Info("TestService::Add(Json, req:%#v) = res:%#v", addReq, addRsp)
 
+	ctx = context.WithValue(context.Background(), "seq", atomic.AddInt64(&seq, 1))
 	errReq := micro_examples.ErrReq{1}
 	errRsp := micro_examples.ErrRsp{}
-	err = client.Call(nil, rpc.CodecJson, ts.Service(), ts.Version(), "Err", &errReq, &errRsp)
+	err = client.Call(ctx, rpc.CodecJson, ts.Service(), ts.Version(), "Err", &errReq, &errRsp)
 	if err != nil {
 		// error test case, this invocation should step into this branch.
 		log.Error("client.Call(Json, TestService::Err) = error:%s", jerrors.ErrorStack(err))
@@ -140,27 +178,31 @@ func testJSON() {
 
 func testProtobuf() {
 	ts := micro_examples.TestService{}
+	ctx := context.WithValue(context.Background(), "seq", atomic.AddInt64(&seq, 1))
 	testReq := micro_examples.TestReq{"aaa", "bbb", "ccc"}
 	testRsp := micro_examples.TestRsp{}
-	err := client.Call(nil, rpc.CodecProtobuf, ts.Service(), ts.Version(), "Test", &testReq, &testRsp)
+	err := client.Call(ctx, rpc.CodecProtobuf, ts.Service(), ts.Version(), "Test", &testReq,
+		&testRsp)
 	if err != nil {
 		log.Error("client.Call(protobuf, TestService::Test) = error:%s", jerrors.ErrorStack(err))
 		return
 	}
 	log.Info("TestService::Test(protobuf, param:%#v) = res:%s", testReq, testRsp)
 
+	ctx = context.WithValue(context.Background(), "seq", atomic.AddInt64(&seq, 1))
 	addReq := micro_examples.AddReq{1, 10}
 	addRsp := micro_examples.AddRsp{}
-	err = client.Call(nil, rpc.CodecProtobuf, ts.Service(), ts.Version(), "Add", &addReq, &addRsp)
+	err = client.Call(ctx, rpc.CodecProtobuf, ts.Service(), ts.Version(), "Add", &addReq, &addRsp)
 	if err != nil {
 		log.Error("client.Call(protobuf, TestService::Add) = error:%s", jerrors.ErrorStack(err))
 		return
 	}
 	log.Info("TestService::Add(protobuf, req:%#v) = res:%#v", addReq, addRsp)
 
+	ctx = context.WithValue(context.Background(), "seq", atomic.AddInt64(&seq, 1))
 	errReq := micro_examples.ErrReq{1}
 	errRsp := micro_examples.ErrRsp{}
-	err = client.Call(nil, rpc.CodecProtobuf, ts.Service(), ts.Version(), "Err", &errReq, &errRsp)
+	err = client.Call(ctx, rpc.CodecProtobuf, ts.Service(), ts.Version(), "Err", &errReq, &errRsp)
 	if err != nil {
 		// error test case, this invocation should step into this branch.
 		log.Error("client.Call(protobuf, TestService::Err) = error:%s", jerrors.ErrorStack(err))