feat 初次提交

net/grpc/grpc_conn/conn.go

@@ -0,0 +1,42 @@
+package grpc_conn
+
+import (
+	"common/log"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/keepalive"
+	"time"
+)
+
+type GrpcConnection struct {
+	sid  int64
+	conn *grpc.ClientConn
+}
+
+func NewGrpcConnection(sid int64, address string) (*GrpcConnection, error) {
+	p := &GrpcConnection{
+		sid: sid,
+	}
+	conn, err := grpc.NewClient(
+		address,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		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
+}

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[int64]*GrpcConnection
+	poolS []*GrpcConnection
+}
+
+func NewGrpcConnectionMgr() *GrpcConnectionMgr {
+	return &GrpcConnectionMgr{
+		poolM: make(map[int64]*GrpcConnection),
+		poolS: make([]*GrpcConnection, 0),
+	}
+}
+
+func (p *GrpcConnectionMgr) Store(sid int64, 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 int64) 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 ...int64) (*grpc.ClientConn, error) {
+	var pool *GrpcConnection
+	if len(sid) > 0 && 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[int64]*grpc.ClientConn {
+	sidM := make(map[int64]*grpc.ClientConn)
+	for sid, pool := range p.poolM {
+		sidM[sid] = pool.GetConnection()
+	}
+	return sidM
+}

net/grpc/resolver/conn.go

@@ -0,0 +1,30 @@
+package resolver
+
+import (
+	"common/log"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/keepalive"
+	"time"
+)
+
+func NewGrpcConnection(target string) (*grpc.ClientConn, error) {
+	cc, err := grpc.NewClient(
+		target,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultServiceConfig(`{"loadBalancingConfig": [{"round_robin": {}}]}`),
+		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, target: %v", err, target)
+		return nil, err
+	}
+	return cc, nil
+}

net/grpc/resolver/etcd_resolver.go

@@ -0,0 +1,84 @@
+package resolver
+
+import (
+	"common/db/etcd"
+	"common/discover/common"
+	"common/log"
+	"context"
+	"go.etcd.io/etcd/client/v3"
+	"google.golang.org/grpc/resolver"
+	"strings"
+)
+
+const etcdSchema = "etcd"
+
+func init() {
+	resolver.Register(&etcdBuilder{})
+}
+
+type etcdBuilder struct{}
+
+func (*etcdBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
+	serviceName := strings.TrimPrefix(target.URL.Path, "/")
+	r := &etcdResolver{
+		serviceName: serviceName,
+		cc:          cc,
+	}
+	r.start()
+	return r, nil
+}
+
+func (*etcdBuilder) Scheme() string { return etcdSchema }
+
+type etcdResolver struct {
+	serviceName string
+	cc          resolver.ClientConn
+	ctx         context.Context
+	cancel      context.CancelFunc
+}
+
+func (r *etcdResolver) start() {
+	r.ctx, r.cancel = context.WithCancel(context.Background())
+	r.update()
+	go r.watch()
+}
+
+func (r *etcdResolver) getPrefix() string {
+	return common.KeyDiscoverService + "/" + r.serviceName
+}
+
+func (r *etcdResolver) update() {
+	resp, err := etcd.GetClient().Get(r.getPrefix(), clientv3.WithPrefix())
+	if err != nil {
+		log.Errorf("etcd resolver get error: %v", err)
+		return
+	}
+
+	var addrArray []resolver.Address
+	for _, kv := range resp.Kvs {
+		addr := string(kv.Value)
+		if addr != "" {
+			addrArray = append(addrArray, resolver.Address{Addr: addr})
+		}
+	}
+
+	_ = r.cc.UpdateState(resolver.State{Addresses: addrArray})
+}
+
+func (r *etcdResolver) watch() {
+	watchCh := etcd.GetClient().Watch(r.getPrefix(), clientv3.WithPrefix())
+	for w := range watchCh {
+		if w.Err() != nil {
+			continue
+		}
+		r.update()
+	}
+}
+
+func (r *etcdResolver) ResolveNow(resolver.ResolveNowOptions) {
+	r.update()
+}
+
+func (r *etcdResolver) Close() {
+	r.cancel()
+}

net/grpc/resolver/resolver_mgr.go

@@ -0,0 +1,35 @@
+package resolver
+
+import (
+	"google.golang.org/grpc"
+	"sync"
+)
+
+var (
+	mu   = sync.RWMutex{}
+	conn = make(map[string]*grpc.ClientConn)
+)
+
+func GetGrpcClientConn(target string) (*grpc.ClientConn, error) {
+	mu.RLock()
+	if c, ok := conn[target]; ok && c != nil {
+		mu.RUnlock()
+		return c, nil
+	}
+	mu.RUnlock()
+
+	mu.Lock()
+	defer mu.Unlock()
+
+	if c, ok := conn[target]; ok && c != nil {
+		return c, nil
+	}
+
+	newConn, err := NewGrpcConnection(target)
+	if err != nil {
+		return nil, err
+	}
+
+	conn[target] = newConn
+	return newConn, nil
+}

net/grpc/service/client_gateway.go

@@ -0,0 +1,24 @@
+package service
+
+import (
+	"common/discover"
+	"common/discover/common"
+	"common/proto/ss/grpc_pb"
+)
+
+func GatewayNewClient(sid ...int64) (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[int64]grpc_pb.GatewayClient {
+	clientM := make(map[int64]grpc_pb.GatewayClient)
+	connM := discover.FindServerAll(common.KeyDiscoverGateway)
+	for sid, conn := range connM {
+		clientM[sid] = grpc_pb.NewGatewayClient(conn)
+	}
+	return clientM
+}

net/grpc/service/client_scene.go

@@ -0,0 +1,33 @@
+package service
+
+import (
+	"common/discover"
+	"common/discover/common"
+	"common/net/grpc/resolver"
+	"common/proto/ss/grpc_pb"
+)
+
+func SceneNewClient(sid ...int64) (grpc_pb.SceneClient, error) {
+	c, err := discover.FindServer(common.KeyDiscoverScene, sid...)
+	if err != nil {
+		return nil, err
+	}
+	return grpc_pb.NewSceneClient(c), nil
+}
+
+func SceneNewClientLB() (grpc_pb.SceneClient, error) {
+	c, err := resolver.GetGrpcClientConn("etcd:///" + common.KeyDiscoverServiceNameScene)
+	if err != nil {
+		return nil, err
+	}
+	return grpc_pb.NewSceneClient(c), nil
+}
+
+func SceneNewBroadcastClient() map[int64]grpc_pb.SceneClient {
+	clientM := make(map[int64]grpc_pb.SceneClient)
+	connM := discover.FindServerAll(common.KeyDiscoverScene)
+	for sid, conn := range connM {
+		clientM[sid] = grpc_pb.NewSceneClient(conn)
+	}
+	return clientM
+}

net/grpc/service/client_user.go

@@ -0,0 +1,24 @@
+package service
+
+import (
+	"common/discover"
+	"common/discover/common"
+	"common/net/grpc/resolver"
+	"common/proto/ss/grpc_pb"
+)
+
+func UserNewClient(sid ...int64) (grpc_pb.UserClient, error) {
+	c, err := discover.FindServer(common.KeyDiscoverUser, sid...)
+	if err != nil {
+		return nil, err
+	}
+	return grpc_pb.NewUserClient(c), nil
+}
+
+func UserNewClientLB() (grpc_pb.UserClient, error) {
+	c, err := resolver.GetGrpcClientConn("etcd:///" + common.KeyDiscoverServiceNameUser)
+	if err != nil {
+		return nil, err
+	}
+	return grpc_pb.NewUserClient(c), nil
+}

net/grpc/service/service.go

@@ -0,0 +1,88 @@
+package service
+
+import (
+	"common/discover"
+	"common/log"
+	"common/utils"
+	"context"
+	"fmt"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/keepalive"
+	"google.golang.org/grpc/status"
+	"net"
+	"sync"
+	"time"
+)
+
+type IService interface {
+	Init(addr string, port int32)
+	Close()
+}
+
+type Base struct {
+	Target  string
+	SID     int64
+	Serve   *grpc.Server
+	EtcdTTL int64
+	OnInit  func(serve *grpc.Server)
+	OnClose func()
+
+	wg *sync.WaitGroup
+}
+
+func (s *Base) Init(addr string, port int32) {
+	s.wg = &sync.WaitGroup{}
+	s.wg.Add(1)
+	s.SID = utils.SnowflakeInstance().Generate().Int64()
+	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)
+							err = status.Error(codes.Internal, fmt.Sprintf("%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()
+	}
+}

net/http/http_resp/code.go

@@ -0,0 +1,47 @@
+package http_resp
+
+import (
+	"common/proto/ss/ss_common"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+var (
+	OK            = NewCode(0, "OK")
+	Failed        = NewCode(1, "Failed")
+	TokenInvalid  = NewCode(2, "Token无效")
+	ParamError    = NewCode(1001, "参数错误")
+	NameEmpty     = NewCode(1002, "名称不能为空")
+	NameDuplicate = NewCode(1003, "名称或编号不能重复")
+	ListEmpty     = NewCode(1004, "列表不能为空")
+	RepeatCommit  = NewCode(1005, "请勿重复提交")
+)
+
+type Code struct {
+	code  int
+	error string
+}
+
+func NewCode(code int, error string) *Code {
+	return &Code{
+		code:  code,
+		error: error,
+	}
+}
+
+func (c *Code) Code() int {
+	return c.code
+}
+
+func (c *Code) Error() string {
+	return c.error
+}
+
+func (c *Code) Wrap() error {
+	st := status.New(codes.Unknown, c.Error())
+	st, _ = st.WithDetails(&ss_common.ErrorInfo{
+		Code: int32(c.Code()),
+		Msg:  c.Error(),
+	})
+	return st.Err()
+}

net/http/http_resp/response.go

@@ -0,0 +1,47 @@
+package http_resp
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type RespJsonData struct {
+	Code int         `json:"code"`
+	Msg  string      `json:"msg"`
+	Data interface{} `json:"data,omitempty"`
+}
+
+func Success(data interface{}) *RespJsonData {
+	return &RespJsonData{
+		Code: OK.Code(),
+		Msg:  OK.Error(),
+		Data: data,
+	}
+}
+
+func Error(code *Code) *RespJsonData {
+	return &RespJsonData{
+		Code: code.Code(),
+		Msg:  code.Error(),
+	}
+}
+
+func JsonOK(c *gin.Context, data *RespJsonData) {
+	c.JSON(http.StatusOK, data)
+}
+
+func JsonBadRequest(c *gin.Context) {
+	c.JSON(http.StatusBadRequest, Error(ParamError))
+}
+
+func JsonMethodNotAllowed(c *gin.Context) {
+	c.JSON(http.StatusMethodNotAllowed, Error(NewCode(Failed.Code(), "Method Not Allowed")))
+}
+
+func JsonNotFound(c *gin.Context) {
+	c.JSON(http.StatusNotFound, Error(NewCode(Failed.Code(), "Endpoint Not Found")))
+}
+
+func AbortUnauthorized(c *gin.Context) {
+	c.AbortWithStatusJSON(http.StatusUnauthorized, Error(NewCode(Failed.Code(), "Invalid Authorization")))
+}

net/socket/server.go

@@ -0,0 +1,48 @@
+package socket
+
+import (
+	"time"
+)
+
+type Action int
+
+const (
+	// None indicates that no action should occur following an event.
+	None Action = iota
+	// Close closes the connection.
+	Close
+	// Shutdown shutdowns the engine.
+	Shutdown
+)
+
+type OpCode byte
+
+const (
+	OpContinuation OpCode = 0x0
+	OpText         OpCode = 0x1
+	OpBinary       OpCode = 0x2
+	OpClose        OpCode = 0x8
+	OpPing         OpCode = 0x9
+	OpPong         OpCode = 0xa
+)
+
+// ISocketServer 由应用层实现
+type ISocketServer interface {
+	OnOpen(ISocketConn) ([]byte, Action)                               // 开启连接
+	OnHandShake(ISocketConn, []byte, func(ISocketConn, []byte)) Action // 开始握手
+	OnMessage(ISocketConn, []byte) Action                              // 收到消息
+	OnPong(ISocketConn)
+	OnClose(ISocketConn, error) Action // 关闭连接
+	OnTick() (time.Duration, Action)
+}
+
+// ISocketConn 由网络层实现
+type ISocketConn interface {
+	GetParam(key string) interface{}
+	SetParam(key string, values interface{})
+	RemoteAddr() string
+	Ping() error // 需要隔一段时间调用一下，建议20s
+	Write(data []byte) error
+	Close() error
+	IsClose() bool
+}

net/socket/websocket/websocket.go

@@ -0,0 +1,187 @@
+package websocket
+
+import (
+	"bytes"
+	"common/net/socket"
+	"context"
+	"github.com/panjf2000/gnet/v2"
+	"github.com/panjf2000/gnet/v2/pkg/logging"
+	"sync"
+	"time"
+)
+
+// WSServer 实现GNet库接口
+type WSServer struct {
+	eng            gnet.Engine
+	i              socket.ISocketServer
+	logger         logging.Logger // 日志
+	upgradeTimeout time.Duration  // 升级超时时间
+	unUpgradeConn  sync.Map
+}
+
+func NewWSServer(i socket.ISocketServer, logger logging.Logger, upgradeTimeout time.Duration) *WSServer {
+	if i == nil {
+		return nil
+	}
+	return &WSServer{
+		i:              i,
+		logger:         logger,
+		upgradeTimeout: upgradeTimeout,
+		unUpgradeConn:  sync.Map{},
+	}
+}
+
+func (s *WSServer) Run(addr string, multicore bool, numEventLoop int, tcpNoDelay gnet.TCPSocketOpt, readBufferCap, writeBufferCap int, lockOSThread bool, reusePort, ticker bool, logger logging.Logger) error {
+	return gnet.Run(
+		s,
+		addr,
+		gnet.WithMulticore(multicore),
+		gnet.WithNumEventLoop(numEventLoop),
+		gnet.WithTCPNoDelay(tcpNoDelay),
+		gnet.WithReadBufferCap(readBufferCap),
+		gnet.WithWriteBufferCap(writeBufferCap),
+		gnet.WithLockOSThread(lockOSThread),
+		gnet.WithReusePort(reusePort),
+		gnet.WithTicker(ticker),
+		gnet.WithLogger(logger),
+	)
+}
+
+func (s *WSServer) Stop() error {
+	return s.eng.Stop(context.Background())
+}
+
+func (s *WSServer) OnBoot(eng gnet.Engine) gnet.Action {
+	s.eng = eng
+	return gnet.None
+}
+
+func (s *WSServer) OnShutdown(_ gnet.Engine) {
+}
+
+func (s *WSServer) OnOpen(c gnet.Conn) ([]byte, gnet.Action) {
+	ws := &WSConn{
+		Conn:      c,
+		isUpgrade: false,
+		openTime:  time.Now().Unix(),
+		buf:       bytes.Buffer{},
+		logger:    s.logger,
+		wsMessageBuf: wsMessageBuf{
+			curHeader: nil,
+			cachedBuf: bytes.Buffer{},
+		},
+		param:      make(map[string]interface{}),
+		remoteAddr: c.RemoteAddr().String(),
+	}
+	c.SetContext(ws)
+	s.unUpgradeConn.Store(c.RemoteAddr().String(), ws)
+	d, a := s.i.OnOpen(ws)
+	return d, (gnet.Action)(a)
+}
+
+// OnClose fires when a connection has been closed.
+// The parameter err is the last known connection error.
+func (s *WSServer) OnClose(c gnet.Conn, err error) (action gnet.Action) {
+	s.unUpgradeConn.Delete(c.RemoteAddr().String())
+	ws, ok := c.Context().(*WSConn)
+	if ok {
+		ws.isClose = true
+		ws.logger.Warnf("connection close, err: %v", err)
+		return gnet.Action(s.i.OnClose(ws, err))
+	}
+	return
+}
+
+// OnTraffic fires when a local socket receives data from the peer.
+func (s *WSServer) OnTraffic(c gnet.Conn) gnet.Action {
+	ws := c.Context().(*WSConn)
+	if action := ws.readBytesBuf(c); action != gnet.None {
+		return action
+	}
+
+	if !ws.isUpgrade {
+		data, action := ws.upgrade()
+		if len(data) > 0 {
+			s.unUpgradeConn.Delete(c.RemoteAddr().String())
+			action = gnet.Action(s.i.OnHandShake(ws, data, s.OnHandShakeFinish))
+		}
+		return action
+	}
+
+	if msg, err := ws.readWsMessages(); err != nil {
+		ws.logger.Errorf("read ws messages err: %v", err)
+		return gnet.Close
+	} else if msg != nil {
+		for _, m := range msg {
+			if socket.OpCode(m.OpCode) == socket.OpPong {
+				s.i.OnPong(ws)
+				continue
+			}
+			if socket.OpCode(m.OpCode) == socket.OpClose {
+				return gnet.Close
+			}
+			if socket.OpCode(m.OpCode) == socket.OpPing {
+				continue
+			}
+			a := s.i.OnMessage(ws, m.Payload)
+			if gnet.Action(a) != gnet.None {
+				return gnet.Action(a)
+			}
+		}
+	}
+	return gnet.None
+}
+
+// OnTick fires immediately after the engine starts and will fire again
+// following the duration specified by the delay return value.
+func (s *WSServer) OnTick() (delay time.Duration, action gnet.Action) {
+	now := time.Now().Unix()
+
+	delConn := make([]string, 0)
+	s.unUpgradeConn.Range(func(key, value interface{}) bool {
+		k, ok := key.(string)
+		if !ok {
+			return true
+		}
+
+		v, ok := value.(*WSConn)
+		if !ok {
+			return true
+		}
+		if now-v.openTime >= int64(s.upgradeTimeout.Seconds()) {
+			delConn = append(delConn, k)
+		}
+		return true
+	})
+
+	for _, k := range delConn {
+		wsConn, _ := s.unUpgradeConn.LoadAndDelete(k)
+		if wsConn == nil {
+			continue
+		}
+
+		v, ok := wsConn.(*WSConn)
+		if !ok {
+			continue
+		}
+		if err := v.Close(); err != nil {
+			v.logger.Errorf("upgrade ws time out close socket error: %v", err)
+		}
+	}
+	d, a := s.i.OnTick()
+	delay = d
+	action = gnet.Action(a)
+
+	return
+}
+
+// OnHandShakeFinish 握手完成
+func (s *WSServer) OnHandShakeFinish(conn socket.ISocketConn, hsResp []byte) {
+	ws := conn.(*WSConn)
+	if err := ws.Conn.AsyncWrite(hsResp, nil); err != nil {
+		ws.logger.Errorf("OnHandShakeFinish err: %v", err)
+		if err = ws.Close(); err != nil {
+			ws.logger.Errorf("OnHandShakeFinish Close error: %v", err)
+		}
+	}
+}

net/socket/websocket/wsconn.go

@@ -0,0 +1,202 @@
+package websocket
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"github.com/gobwas/ws"
+	"github.com/gobwas/ws/wsutil"
+	"github.com/panjf2000/gnet/v2"
+	"github.com/panjf2000/gnet/v2/pkg/logging"
+	"io"
+	"net/url"
+)
+
+// WSConn 实现ISocketConn接口
+type WSConn struct {
+	gnet.Conn
+	buf         bytes.Buffer
+	logger      logging.Logger
+	isUpgrade   bool   // 是否已经升级
+	upgradeResp []byte // 升级响应
+	isClose     bool
+	param       map[string]interface{}
+	openTime    int64  // 开启连接的时间
+	remoteAddr  string // 远程ID地址
+	wsMessageBuf
+}
+
+type wsMessageBuf struct {
+	curHeader *ws.Header
+	cachedBuf bytes.Buffer
+}
+
+type readWrite struct {
+	io.Reader
+	io.Writer
+}
+
+func (w *WSConn) readBytesBuf(c gnet.Conn) gnet.Action {
+	size := c.InboundBuffered()
+	if size <= 0 {
+		return gnet.None
+	}
+	buf := make([]byte, size)
+
+	read, err := c.Read(buf)
+	if err != nil {
+		if w.logger != nil {
+			w.logger.Errorf("ws read bytes buf error", err)
+		}
+		return gnet.Close
+	}
+
+	if read < size {
+		if w.logger != nil {
+			w.logger.Errorf("read bytes len err! size: %d read: %d", size, read)
+		}
+		return gnet.Close
+	}
+	w.buf.Write(buf)
+	return gnet.None
+}
+
+func (w *WSConn) upgrade() (data []byte, action gnet.Action) {
+	buf := &w.buf
+	tmpReader := bytes.NewReader(buf.Bytes())
+	oldLen := tmpReader.Len()
+	result := &bytes.Buffer{}
+	tempWriter := bufio.NewWriter(result)
+
+	var err error = nil
+	up := ws.Upgrader{
+		OnRequest: w.OnRequest,
+	}
+	_, err = up.Upgrade(readWrite{tmpReader, tempWriter})
+	skipN := oldLen - tmpReader.Len()
+	if err != nil {
+		if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) { //数据不完整
+			return
+		}
+		buf.Next(skipN)
+		if w.logger != nil {
+			w.logger.Errorf("ws upgrade err: %v", err.Error())
+		}
+
+		action = gnet.Close
+		return
+	}
+	buf.Next(skipN)
+	//if w.logger != nil {
+	//	w.logger.Infof("ws upgrade success conn upgrade websocket protocol!")
+	//}
+	_ = tempWriter.Flush()
+	data = result.Bytes()
+	w.isUpgrade = true
+	return
+}
+
+func (w *WSConn) readWsMessages() (messages []wsutil.Message, err error) {
+	in := &w.buf
+	for {
+		if w.curHeader == nil {
+			if in.Len() < ws.MinHeaderSize { //头长度至少是2
+				return
+			}
+			var head ws.Header
+			//有可能不完整，构建新的 reader 读取 head 读取成功才实际对 in 进行读操作
+			tmpReader := bytes.NewReader(in.Bytes())
+			oldLen := tmpReader.Len()
+			head, err = ws.ReadHeader(tmpReader)
+			skipN := oldLen - tmpReader.Len()
+			if err != nil {
+				if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) { //数据不完整
+					return messages, nil
+				}
+				in.Next(skipN)
+				return nil, err
+			}
+			_, err = io.CopyN(&w.cachedBuf, in, int64(skipN))
+			if err != nil {
+				return
+			}
+
+			w.curHeader = &head
+		}
+		dataLen := (int)(w.curHeader.Length)
+		if dataLen > 0 {
+			if in.Len() >= dataLen {
+				_, err = io.CopyN(&w.cachedBuf, in, int64(dataLen))
+				if err != nil {
+					return
+				}
+			} else { //数据不完整
+				if w.logger != nil {
+					w.logger.Debugf("ws read ws message incomplete data", in.Len(), dataLen)
+				}
+				return
+			}
+		}
+		if w.curHeader.Fin { //当前 header 已经是一个完整消息
+			messages, err = wsutil.ReadClientMessage(&w.cachedBuf, messages)
+			if err != nil {
+				return nil, err
+			}
+			w.cachedBuf.Reset()
+		}
+		w.curHeader = nil
+	}
+}
+
+func (w *WSConn) OnRequest(u []byte) error {
+	parsedURL, err := url.Parse(string(u))
+	if err != nil {
+		return err
+	}
+	for key, value := range parsedURL.Query() {
+		w.SetParam(key, value[0])
+	}
+	return nil
+}
+
+func (w *WSConn) GetParam(key string) interface{} {
+	return w.param[key]
+}
+
+func (w *WSConn) SetParam(key string, values interface{}) {
+	w.param[key] = values
+}
+
+func (w *WSConn) RemoteAddr() string {
+	return w.remoteAddr
+}
+
+func (w *WSConn) Write(data []byte) error {
+	return w.write(data, ws.OpBinary)
+}
+
+func (w *WSConn) Ping() (err error) {
+	return w.write(make([]byte, 0), ws.OpPing)
+}
+
+func (w *WSConn) Close() (err error) {
+	defer func(Conn gnet.Conn) {
+		err = Conn.Close()
+	}(w.Conn)
+	return w.write(make([]byte, 0), ws.OpClose)
+}
+
+func (w *WSConn) IsClose() bool {
+	return w.isClose
+}
+
+func (w *WSConn) write(data []byte, opCode ws.OpCode) error {
+	if w.isClose {
+		return errors.New("connection has close")
+	}
+	buf := bytes.Buffer{}
+	if err := wsutil.WriteServerMessage(&buf, opCode, data); err != nil {
+		return err
+	}
+	return w.Conn.AsyncWrite(buf.Bytes(), nil)
+}