package client import ( "errors" "fmt" "git.bvbej.com/bvbej/base-golang/pkg/websocket/client/service" "git.bvbej.com/bvbej/base-golang/pkg/websocket/codec" _ "git.bvbej.com/bvbej/base-golang/pkg/websocket/codec/json" _ "git.bvbej.com/bvbej/base-golang/pkg/websocket/codec/protobuf" "git.bvbej.com/bvbej/base-golang/tool" "github.com/gorilla/websocket" "go.uber.org/zap" "net/http" "net/url" "reflect" "sync/atomic" "time" ) const ( writeWait = 20 * time.Second pongWait = 60 * time.Second reconnectWait = 3 * time.Second pingPeriod = (pongWait * 9) / 10 maxFrameMessageLen = 16 * 1024 maxSendBuffer = 32 ) var ( _ Client = (*client)(nil) ErrBrokenPipe = errors.New("send to broken pipe") ErrBufferPoolExceed = errors.New("send buffer exceed") ) type Client interface { readLoop() writeLoop() ping() onReceive(msg []byte) error onSend(msg []byte) error connect() error Send(router string, data any) error Connect(requestHeader http.Header) error OnReceiveError() <-chan error OnReconnect(f func()) } type client struct { url url.URL requestHeader http.Header logger *zap.Logger session *service.Session isConnected *atomic.Bool routerCodec codec.Codec send chan []byte handlers map[string]*service.Handler // 注册的方法列表 onReceiveChan chan error pingTicker *time.Ticker onReconnect func() } func New(logger *zap.Logger, url url.URL, decoder string, handlers interface{}) (Client, error) { if !tool.InArray(url.Scheme, []string{"ws", "wss"}) { return nil, errors.New(`param: scheme not supported`) } routerCodec := codec.GetCodec(decoder) if routerCodec == nil { return nil, errors.New(`param: codec not supported`) } components := service.RegisterHandler(handlers) if len(components) == 0 { return nil, errors.New(`param: handlers unqualified`) } c := &client{ logger: logger, isConnected: new(atomic.Bool), routerCodec: routerCodec, url: url, send: make(chan []byte, maxSendBuffer), handlers: components, onReceiveChan: make(chan error, maxSendBuffer), pingTicker: time.NewTicker(pingPeriod), } return c, nil } func (c *client) readLoop() { _ = c.session.Conn.SetReadDeadline(time.Now().Add(pongWait)) c.session.Conn.SetPongHandler(func(string) error { _ = c.session.Conn.SetReadDeadline(time.Now().Add(pongWait)) return nil }) for { _, data, err := c.session.Conn.ReadMessage() if err != nil { c.isConnected.Store(false) for c.connect() != nil { time.Sleep(reconnectWait) } if c.onReconnect != nil { c.onReconnect() } continue } err = c.onReceive(data) if err != nil { c.onReceiveChan <- err } } } func (c *client) writeLoop() { for { msg := <-c.send _ = c.session.Conn.SetWriteDeadline(time.Now().Add(writeWait)) if err := c.session.Conn.WriteMessage(websocket.BinaryMessage, msg); err != nil { continue } } } func (c *client) ping() { for range c.pingTicker.C { _ = c.session.Conn.SetWriteDeadline(time.Now().Add(writeWait)) if err := c.session.Conn.WriteMessage(websocket.PingMessage, nil); err != nil { for c.connect() != nil { time.Sleep(reconnectWait) } } } } func (c *client) connect() error { conn, _, err := websocket.DefaultDialer.Dial(c.url.String(), c.requestHeader) if err != nil { return fmt.Errorf("dial: %s", err) } c.session = service.NewSession(conn) c.isConnected.Store(true) return nil } func (c *client) onReceive(msg []byte) error { _, msgPack, err := c.routerCodec.Unmarshal(msg) if err != nil { return fmt.Errorf("onreceive: %v", err) } router, ok := msgPack.Router.(string) if !ok { return fmt.Errorf("onreceive: invalid router:%v", msgPack.Router) } s, ok := c.handlers[router] if !ok { return fmt.Errorf("onreceive: function not registed router:%s err:%v", msgPack.Router, err) } if msgPack.Err != nil { return fmt.Errorf("%s:%s", router, msgPack.Err) } var args = []reflect.Value{s.Receiver, reflect.ValueOf(c.session), reflect.ValueOf(msgPack.DataPtr)} s.Method.Func.Call(args) return nil } func (c *client) onSend(msg []byte) (err error) { defer func() { if e := recover(); e != nil { err = ErrBrokenPipe } }() if !c.isConnected.Load() { return ErrBrokenPipe } if len(c.send) >= maxSendBuffer { return ErrBufferPoolExceed } if len(msg) > maxFrameMessageLen { return } c.send <- msg return nil } func (c *client) Connect(requestHeader http.Header) error { c.requestHeader = requestHeader err := c.connect() if err != nil { return err } go c.ping() go c.writeLoop() go c.readLoop() return nil } func (c *client) Send(router string, data any) error { rb, err := c.routerCodec.Marshal(router, data, nil) if err != nil { return fmt.Errorf("service: %v", err) } return c.onSend(rb) } func (c *client) OnReceiveError() <-chan error { return c.onReceiveChan } func (c *client) OnReconnect(f func()) { c.onReconnect = f }