加入网络层

Server/common/net/grpc/grpc_conn/conn.go

@@ -0,0 +1,41 @@
+package grpc_conn
+
+import (
+	"common/log"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/keepalive"
+	"time"
+)
+
+type GrpcConnection struct {
+	sid  string
+	conn *grpc.ClientConn
+}
+
+func NewGrpcConnection(sid, address string) (*GrpcConnection, error) {
+	p := &GrpcConnection{
+		sid: sid,
+	}
+	conn, err := grpc.Dial(
+		address,
+		grpc.WithInsecure(),
+		grpc.WithKeepaliveParams(
+			keepalive.ClientParameters{
+				Time:                30 * time.Second, // 保活探测包发送的时间间隔
+				Timeout:             10 * time.Second, // 保活探测包的超时时间
+				PermitWithoutStream: true,
+			},
+		),
+		//grpc.WithStatsHandler(&StatsHandler{}),
+	)
+	if err != nil {
+		log.Errorf("create grpc err: %v, sid: %v, addr: %v", err, sid, address)
+		return nil, err
+	}
+	p.conn = conn
+	return p, nil
+}
+
+func (g *GrpcConnection) GetConnection() *grpc.ClientConn {
+	return g.conn
+}

Server/common/net/grpc/grpc_conn/conn_mgr.go

@@ -0,0 +1,62 @@
+package grpc_conn
+
+import (
+	"common/log"
+	"fmt"
+	"google.golang.org/grpc"
+	"math/rand"
+)
+
+type GrpcConnectionMgr struct {
+	poolM map[string]*GrpcConnection
+	poolS []*GrpcConnection
+}
+
+func NewGrpcConnectionMgr() *GrpcConnectionMgr {
+	return &GrpcConnectionMgr{
+		poolM: make(map[string]*GrpcConnection),
+		poolS: make([]*GrpcConnection, 0),
+	}
+}
+
+func (p *GrpcConnectionMgr) Store(sid, addr string) {
+	pool, err := NewGrpcConnection(sid, addr)
+	if err != nil {
+		log.Errorf("create grpc err: %v, sid: %v, addr: %v", err, sid, addr)
+		return
+	}
+	p.poolM[sid] = pool
+	p.poolS = append(p.poolS, pool)
+}
+
+func (p *GrpcConnectionMgr) Delete(sid string) int {
+	delete(p.poolM, sid)
+	for i, pool := range p.poolS {
+		if pool.sid == sid {
+			p.poolS = append(p.poolS[:i], p.poolS[i+1:]...)
+			break
+		}
+	}
+	return len(p.poolS)
+}
+
+func (p *GrpcConnectionMgr) Load(sid ...string) (*grpc.ClientConn, error) {
+	var pool *GrpcConnection
+	if len(sid) > 0 && len(sid[0]) > 0 {
+		pool = p.poolM[sid[0]]
+	} else {
+		pool = p.poolS[rand.Intn(len(p.poolS))]
+	}
+	if pool == nil {
+		return nil, fmt.Errorf("cannot find connection")
+	}
+	return pool.GetConnection(), nil
+}
+
+func (p *GrpcConnectionMgr) LoadAll() map[string]*grpc.ClientConn {
+	sidM := make(map[string]*grpc.ClientConn)
+	for sid, pool := range p.poolM {
+		sidM[sid] = pool.GetConnection()
+	}
+	return sidM
+}

Server/common/net/grpc/grpc_conn/stats.go

@@ -0,0 +1,45 @@
+package grpc_conn
+
+import (
+	"context"
+	"fmt"
+	"google.golang.org/grpc/stats"
+)
+
+// 1. 实现 stats.Handler 接口
+type StatsHandler struct{}
+
+func (h *StatsHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
+	// 给 RPC 调用打标签（例如记录方法名）
+	return context.WithValue(ctx, "rpc_method", info.FullMethodName)
+}
+
+func (h *StatsHandler) HandleRPC(ctx context.Context, s stats.RPCStats) {
+	// 处理 RPC 统计信息
+	switch t := s.(type) {
+	case *stats.Begin:
+		fmt.Printf("RPC started: %s\n", ctx.Value("rpc_method"))
+	case *stats.End:
+		fmt.Printf("RPC finished: %s (duration: %v)\n",
+			ctx.Value("rpc_method"), t.EndTime.Sub(t.BeginTime))
+	case *stats.InPayload:
+		fmt.Printf("Received %d bytes\n", t.WireLength)
+	case *stats.OutPayload:
+		fmt.Printf("Sent %d bytes\n", t.WireLength)
+	}
+}
+
+func (h *StatsHandler) TagConn(ctx context.Context, info *stats.ConnTagInfo) context.Context {
+	// 给连接打标签
+	return ctx
+}
+
+func (h *StatsHandler) HandleConn(ctx context.Context, s stats.ConnStats) {
+	// 处理连接事件
+	switch s.(type) {
+	case *stats.ConnBegin:
+		fmt.Println("Connection established")
+	case *stats.ConnEnd:
+		fmt.Println("Connection closed")
+	}
+}

Server/common/net/grpc/service/client_gateway.go

@@ -0,0 +1,24 @@
+package service
+
+import (
+	"common/discover"
+	"common/discover/common"
+	"common/proto/gen/grpc_pb"
+)
+
+func GatewayNewClient(sid ...string) (grpc_pb.GatewayClient, error) {
+	c, err := discover.FindServer(common.KeyDiscoverGateway, sid...)
+	if err != nil {
+		return nil, err
+	}
+	return grpc_pb.NewGatewayClient(c), nil
+}
+
+func GatewayNewBroadcastClient() map[string]grpc_pb.GatewayClient {
+	clientM := make(map[string]grpc_pb.GatewayClient)
+	connM := discover.FindServerAll(common.KeyDiscoverGateway)
+	for sid, conn := range connM {
+		clientM[sid] = grpc_pb.NewGatewayClient(conn)
+	}
+	return clientM
+}

Server/common/net/grpc/service/service.go

@@ -0,0 +1,85 @@
+package service
+
+import (
+	"common/discover"
+	"common/log"
+	"common/utils"
+	"context"
+	"fmt"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/keepalive"
+	"net"
+	"sync"
+	"time"
+)
+
+type IService interface {
+	Init(addr string, port int)
+	Close()
+}
+
+type Base struct {
+	Target  string
+	SID     string
+	Serve   *grpc.Server
+	EtcdTTL int64
+	OnInit  func(serve *grpc.Server)
+	OnClose func()
+
+	wg *sync.WaitGroup
+}
+
+func (s *Base) Init(addr string, port int) {
+	s.wg = &sync.WaitGroup{}
+	s.wg.Add(1)
+	s.SID = utils.SnowflakeInstance().Generate().String()
+	go func() {
+		defer s.wg.Done()
+		defer s.OnClose()
+		defer discover.UnRegisterGrpcServer(s.SID)
+
+		// 监听端口
+		lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+		if err != nil {
+			log.Errorf("%v ListenPort err: %v", s.Target, err)
+			return
+		}
+
+		s.Serve = grpc.NewServer(
+			grpc.UnaryInterceptor(
+				func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
+					defer func() {
+						if r := recover(); r != nil {
+							log.Errorf("server Panic: %v", r)
+						}
+					}()
+					resp, err = handler(ctx, req)
+					return
+				},
+			),
+			grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
+				MinTime:             20 * time.Second,
+				PermitWithoutStream: true,
+			}),
+		)
+		s.OnInit(s.Serve)
+
+		// 服务注册
+		if err = discover.RegisterGrpcServer(s.Target, s.SID, fmt.Sprintf("%v:%d", addr, port), s.EtcdTTL); err != nil {
+			log.Errorf("%v RegisterGrpcServer err: %v", s.Target, err)
+			return
+		}
+		if err = s.Serve.Serve(lis); err != nil {
+			log.Errorf("%v Serve err: %v", s.Target, err)
+			return
+		}
+		log.Infof("%v server stop.", s.Target)
+	}()
+}
+
+func (s *Base) Close() {
+	if s.Serve != nil {
+		s.Serve.Stop()
+		s.wg.Wait()
+	}
+}