feat: initial commit

reach/client/socketio/client.go

@@ -0,0 +1,137 @@
+package socketio
+
+import (
+	"sync"
+
+	gosocketio "forge.cadoles.com/Pyxis/golang-socketio"
+	"forge.cadoles.com/Pyxis/golang-socketio/transport"
+	"github.com/pkg/errors"
+)
+
+type Channel = gosocketio.Channel
+
+const (
+	OnDisconnection = gosocketio.OnDisconnection
+	OnConnection    = gosocketio.OnConnection
+	OnError         = gosocketio.OnError
+)
+
+type Client struct {
+	conn     *gosocketio.Client
+	mutex    sync.RWMutex
+	endpoint string
+	opts     *Options
+}
+
+func (c *Client) Connect() error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	var err error
+	var wg sync.WaitGroup
+
+	wg.Add(1)
+
+	transport := &transport.WebsocketTransport{
+		PingInterval:   c.opts.PingInterval,
+		PingTimeout:    c.opts.PingTimeout,
+		ReceiveTimeout: c.opts.ReceiveTimeout,
+		SendTimeout:    c.opts.SendTimeout,
+		BufferSize:     c.opts.BufferSize,
+	}
+
+	conn, err := gosocketio.Dial(c.endpoint, transport)
+	if err != nil {
+		return errors.Wrap(err, "error while connecting to endpoint")
+	}
+
+	c.conn = nil
+
+	cleanup := func() {
+		conn.Off(gosocketio.OnError)
+		conn.Off(gosocketio.OnConnection)
+	}
+
+	err = conn.On(gosocketio.OnConnection, func(h *Channel) {
+		cleanup()
+		wg.Done()
+	})
+	if err != nil {
+		return errors.Wrap(err, "error while attaching to connection event")
+	}
+
+	err = conn.On(gosocketio.OnError, func(h *Channel) {
+		cleanup()
+		err = errors.Errorf("an unknown error occured")
+		wg.Done()
+	})
+	if err != nil {
+		return errors.Wrap(err, "error while attaching to error event")
+	}
+
+	wg.Wait()
+
+	c.conn = conn
+
+	return err
+}
+
+func (c *Client) Close() {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	if c.conn == nil {
+		return
+	}
+	c.conn.Close()
+	c.conn = nil
+}
+
+func (c *Client) Alive() bool {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	if c.conn == nil {
+		return false
+	}
+
+	return c.conn.IsAlive()
+}
+
+// Emit a new event with the given data
+func (c *Client) Emit(event string, data any) error {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	if err := c.conn.Emit(event, data); err != nil {
+		return errors.Wrapf(err, "error while emitting '%s' event", event)
+	}
+	return nil
+}
+
+type Handler func(ch *Channel, data any)
+
+// On binds and event handler to the given event
+func (c *Client) On(event string, handler Handler) error {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	return c.conn.On(event, handler)
+}
+
+// Off remove the handler bound to the given event
+func (c *Client) Off(event string) {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+
+	c.conn.Off(event)
+}
+
+func NewClient(endpoint string, funcs ...OptionFunc) *Client {
+	opts := NewOptions(funcs...)
+	client := &Client{
+		endpoint: endpoint,
+		opts:     opts,
+	}
+	return client
+}