0
0
//go:build js
package wsconn
import (
"context"
"errors"
"fmt"
"net"
"os"
"sync"
"syscall/js"
"time"
)
const (
socketConnecting = 0
socketOpen = 1
closeNormal = 1000
frameOverhead = 64
)
var socketHandlers = []string{"onopen", "onmessage", "onerror", "onclose"}
type Conn struct {
ws js.Value
ready chan struct{}
opened chan struct{}
done chan struct{}
mu sync.Mutex
err error
isOpen bool
queue [][]byte
buffered int
funcs []js.Func
released bool
}
func DialConfig(ctx context.Context, target string, cfg Config) (*Conn, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
ctor := js.Global().Get("WebSocket")
if ctor.Type() != js.TypeFunction {
return nil, errors.New("wsconn: websocket dial: this js runtime has no WebSocket")
}
ws, err := newSocket(ctor, target)
if err != nil {
return nil, fmt.Errorf("wsconn: websocket dial: %w", err)
}
c := &Conn{
ws: ws,
ready: make(chan struct{}, 1),
opened: make(chan struct{}),
done: make(chan struct{}),
}
ws.Set("binaryType", "arraybuffer")
c.handle("onopen", c.onOpen)
c.handle("onmessage", c.onMessage)
c.handle("onerror", c.onError)
c.handle("onclose", c.onClose)
timeout := cfg.handshakeTimeout()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-c.opened:
return c, nil
case <-c.done:
failure := c.failure()
_ = c.Close()
return nil, fmt.Errorf("wsconn: websocket dial: %w", failure)
case <-ctx.Done():
_ = c.Close()
return nil, ctx.Err()
case <-timer.C:
_ = c.Close()
return nil, fmt.Errorf("wsconn: websocket dial: handshake timeout after %s: %w", timeout, os.ErrDeadlineExceeded)
}
}
func newSocket(ctor js.Value, target string) (ws js.Value, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%v", r)
}
}()
return ctor.New(target), nil
}
func (c *Conn) handle(name string, fn func(js.Value)) {
f := js.FuncOf(func(_ js.Value, args []js.Value) any {
event := js.Undefined()
if len(args) > 0 {
event = args[0]
}
fn(event)
return nil
})
c.funcs = append(c.funcs, f)
c.ws.Set(name, f)
}
func (c *Conn) onOpen(js.Value) {
c.mu.Lock()
defer c.mu.Unlock()
if c.isOpen {
return
}
c.isOpen = true
close(c.opened)
}
func (c *Conn) onError(js.Value) {
c.mu.Lock()
defer c.mu.Unlock()
c.endLocked(&CloseError{Code: CloseAbnormal, Reason: "error event"})
}
func (c *Conn) onClose(event js.Value) {
closeErr := &CloseError{Code: CloseAbnormal}
if event.Type() == js.TypeObject {
if code := event.Get("code"); code.Type() == js.TypeNumber {
closeErr.Code = code.Int()
}
if reason := event.Get("reason"); reason.Type() == js.TypeString {
closeErr.Reason = reason.String()
}
closeErr.Clean = event.Get("wasClean").Truthy()
}
c.mu.Lock()
defer c.mu.Unlock()
c.endLocked(closeErr)
}
func (c *Conn) onMessage(event js.Value) {
frame, err := frameOf(event)
if err == nil {
err = c.buffer(frame)
}
if err != nil {
c.fail(err)
}
}
func (c *Conn) buffer(frame []byte) error {
c.mu.Lock()
defer c.mu.Unlock()
if c.err != nil {
return nil
}
size := len(frame) + frameOverhead
if c.buffered+size > MaxBufferedBytes {
return fmt.Errorf("wsconn: websocket read buffer is over %d bytes in %d frames", MaxBufferedBytes, len(c.queue))
}
c.queue = append(c.queue, frame)
c.buffered += size
select {
case c.ready <- struct{}{}:
default:
}
return nil
}
func frameOf(event js.Value) ([]byte, error) {
if event.Type() != js.TypeObject {
return nil, errors.New("wsconn: websocket message without an event")
}
data := event.Get("data")
switch data.Type() {
case js.TypeString:
frame := []byte(data.String())
if len(frame) > MaxFrameBytes {
return nil, frameTooBig(len(frame))
}
return frame, nil
case js.TypeObject:
size := data.Get("byteLength")
if size.Type() != js.TypeNumber {
return nil, errors.New("wsconn: websocket message is neither text nor an ArrayBuffer")
}
n := size.Int()
if n > MaxFrameBytes {
return nil, frameTooBig(n)
}
frame := make([]byte, n)
if n > 0 {
js.CopyBytesToGo(frame, js.Global().Get("Uint8Array").New(data))
}
return frame, nil
default:
return nil, errors.New("wsconn: websocket message is neither text nor an ArrayBuffer")
}
}
func frameTooBig(n int) error {
return fmt.Errorf("wsconn: websocket frame of %d bytes is over the %d byte limit", n, MaxFrameBytes)
}
func (c *Conn) endLocked(err error) bool {
if c.err != nil {
return false
}
c.err = err
close(c.done)
return true
}
func (c *Conn) fail(err error) {
c.mu.Lock()
ended := c.endLocked(err)
c.mu.Unlock()
if ended {
c.closeSocket()
}
}
func (c *Conn) closeSocket() {
defer func() { _ = recover() }()
switch c.ws.Get("readyState").Int() {
case socketConnecting, socketOpen:
c.ws.Call("close", closeNormal)
}
}
func (c *Conn) failure() error {
c.mu.Lock()
defer c.mu.Unlock()
return c.err
}
func (c *Conn) next() ([]byte, bool) {
c.mu.Lock()
defer c.mu.Unlock()
if len(c.queue) == 0 {
return nil, false
}
frame := c.queue[0]
c.queue[0] = nil
c.queue = c.queue[1:]
if len(c.queue) == 0 {
c.queue = nil
}
c.buffered -= len(frame) + frameOverhead
return frame, true
}
func (c *Conn) Read(ctx context.Context) ([]byte, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
if frame, ok := c.next(); ok {
return frame, nil
}
timer := time.NewTimer(ReadTimeout)
defer timer.Stop()
for {
select {
case <-c.ready:
if frame, ok := c.next(); ok {
return frame, nil
}
case <-c.done:
if frame, ok := c.next(); ok {
return frame, nil
}
return nil, c.failure()
case <-ctx.Done():
return nil, ctx.Err()
case <-timer.C:
c.fail(fmt.Errorf("wsconn: websocket read: no frame in %s: %w", ReadTimeout, os.ErrDeadlineExceeded))
return nil, c.failure()
}
}
}
func (c *Conn) Close() error {
c.mu.Lock()
c.endLocked(fmt.Errorf("wsconn: %w", net.ErrClosed))
if c.released {
c.mu.Unlock()
return nil
}
c.released = true
funcs := c.funcs
c.funcs = nil
c.mu.Unlock()
for _, name := range socketHandlers {
c.ws.Set(name, js.Null())
}
c.closeSocket()
for _, f := range funcs {
f.Release()
}
return nil
}