166 lines
3.4 KiB
Go
166 lines
3.4 KiB
Go
package websocket
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
json_dataModels "github.com/tecamino/tecamino-json_data/models"
|
|
)
|
|
|
|
type Client struct {
|
|
conn *websocket.Conn
|
|
writeMu sync.Mutex
|
|
OnMessage func(data []byte)
|
|
OnOpen func()
|
|
OnClose func(code int, reason string)
|
|
OnError func(err error)
|
|
OnPing func()
|
|
OnPong func()
|
|
timeout time.Duration
|
|
}
|
|
|
|
// Connect to websocket server
|
|
// ip: ip address of server
|
|
func NewClient(ip, id string, port uint) (*Client, error) {
|
|
url := fmt.Sprintf("ws://%s:%d/ws?id=%s", ip, port, id)
|
|
c := &Client{}
|
|
|
|
dialer := websocket.DefaultDialer
|
|
conn, resp, err := dialer.Dial(url, nil)
|
|
if err != nil {
|
|
if c.OnError != nil {
|
|
c.OnError(err)
|
|
}
|
|
return nil, fmt.Errorf("dial error %v (status %v)", err, resp)
|
|
}
|
|
c.conn = conn
|
|
|
|
// Setup control handlers
|
|
c.conn.SetPingHandler(func(appData string) error {
|
|
if c.OnPing != nil {
|
|
c.OnPing()
|
|
}
|
|
return c.conn.WriteMessage(websocket.PongMessage, nil)
|
|
})
|
|
c.conn.SetPongHandler(func(appData string) error {
|
|
c.conn.SetReadDeadline(time.Now().Add(c.timeout))
|
|
if c.OnPong != nil {
|
|
c.OnPong()
|
|
}
|
|
return nil
|
|
})
|
|
c.conn.SetCloseHandler(func(code int, text string) error {
|
|
if c.OnClose != nil {
|
|
c.OnClose(code, text)
|
|
}
|
|
return nil
|
|
})
|
|
|
|
if c.OnOpen != nil {
|
|
c.OnOpen()
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
func (c *Client) Connect(timeout uint) {
|
|
if timeout > 0 {
|
|
fmt.Println(1234, timeout)
|
|
c.timeout = time.Duration(timeout) * time.Second
|
|
}
|
|
|
|
go c.pingLoop()
|
|
|
|
c.conn.SetReadDeadline(time.Now().Add(c.timeout))
|
|
go func() {
|
|
|
|
for {
|
|
msgType, msg, err := c.conn.ReadMessage()
|
|
if err != nil {
|
|
if websocket.IsCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
|
|
log.Println("WebSocket closed:", err)
|
|
}
|
|
if c.OnError != nil {
|
|
c.OnError(fmt.Errorf("read error: %w", err))
|
|
}
|
|
return
|
|
}
|
|
switch msgType {
|
|
case websocket.TextMessage, websocket.BinaryMessage:
|
|
if c.OnMessage != nil {
|
|
c.OnMessage(msg)
|
|
}
|
|
default:
|
|
log.Printf("Unhandled message type: %d", msgType)
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (c *Client) pingLoop() {
|
|
interval := c.timeout / 2
|
|
if interval <= 0 {
|
|
interval = 5 * time.Second
|
|
}
|
|
ticker := time.NewTicker(interval)
|
|
defer ticker.Stop()
|
|
|
|
for range ticker.C {
|
|
if err := c.Write(websocket.PingMessage, nil); err != nil {
|
|
if c.OnError != nil {
|
|
c.OnError(fmt.Errorf("ping error: %w", err))
|
|
}
|
|
return
|
|
}
|
|
if c.OnPing != nil {
|
|
c.OnPing()
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *Client) Write(msgType int, data []byte) error {
|
|
c.writeMu.Lock()
|
|
defer c.writeMu.Unlock()
|
|
|
|
c.conn.SetWriteDeadline(time.Now().Add(c.timeout))
|
|
|
|
if err := c.conn.WriteMessage(msgType, data); err != nil {
|
|
if c.OnError != nil {
|
|
c.OnError(err)
|
|
}
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Close connection to websocket server
|
|
func (c *Client) Close(code int, reason string) {
|
|
if c.conn != nil {
|
|
if c.OnClose != nil {
|
|
c.OnClose(code, reason)
|
|
}
|
|
c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(code, reason))
|
|
c.conn.Close()
|
|
}
|
|
}
|
|
|
|
func (c *Client) SendData(data any) error {
|
|
c.conn.SetWriteDeadline(time.Now().Add(c.timeout))
|
|
if err := c.conn.WriteJSON(data); err != nil {
|
|
if c.OnError != nil {
|
|
c.OnError(err)
|
|
}
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Client) ReadJsonData(data []byte) (json_dataModels.Response, error) {
|
|
var resp json_dataModels.Response
|
|
err := json.Unmarshal(data, &resp)
|
|
return resp, err
|
|
}
|