Add WebSocket API

nhooyr · nhooyr · commit bc1defe8c649 · 2019-09-21T13:53:03.000-05:00
Closes #121
diff --git a/accept.go b/accept.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/accept_test.go b/accept_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/ci/wasm.sh b/ci/wasm.sh
@@ -6,6 +6,5 @@ cd "$(git rev-parse --show-toplevel)"
 
 GOOS=js GOARCH=wasm go vet ./...
 go install golang.org/x/lint/golint
-# Get passing later.
-#GOOS=js GOARCH=wasm golint -set_exit_status ./...
-GOOS=js GOARCH=wasm go test ./internal/wsjs
+GOOS=js GOARCH=wasm golint -set_exit_status ./...
+GOOS=js GOARCH=wasm go test -race ./internal/wsjs
diff --git a/dial.go b/dial.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/dial_test.go b/dial_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/doc.go b/doc.go
@@ -1,3 +1,5 @@
+// +build !js
+
 // Package websocket is a minimal and idiomatic implementation of the WebSocket protocol.
 //
 // https://tools.ietf.org/html/rfc6455
diff --git a/example_echo_test.go b/example_echo_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket_test
 
 import (
diff --git a/example_test.go b/example_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket_test
 
 import (
diff --git a/export_test.go b/export_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/header.go b/header.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/header_test.go b/header_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/internal/wsjs/wsjs.go b/internal/wsjs/wsjs.go
@@ -5,7 +5,6 @@
 package wsjs
 
 import (
-	"context"
 	"syscall/js"
 )
 
@@ -26,17 +25,17 @@ func handleJSError(err *error, onErr func()) {
 	}
 }
 
-func New(ctx context.Context, url string, protocols []string) (c *WebSocket, err error) {
+func New(url string, protocols []string) (c WebSocket, err error) {
 	defer handleJSError(&err, func() {
-		c = nil
+		c = WebSocket{}
 	})
 
 	jsProtocols := make([]interface{}, len(protocols))
 	for i, p := range protocols {
 		jsProtocols[i] = p
 	}
 
-	c = &WebSocket{
+	c = WebSocket{
 		v: js.Global().Get("WebSocket").New(url, jsProtocols),
 	}
 
@@ -57,19 +56,25 @@ type WebSocket struct {
 	v js.Value
 }
 
-func (c *WebSocket) setBinaryType(typ string) {
+func (c WebSocket) setBinaryType(typ string) {
 	c.v.Set("binaryType", string(typ))
 }
 
-func (c *WebSocket) BufferedAmount() uint32 {
+func (c WebSocket) BufferedAmount() uint32 {
 	return uint32(c.v.Get("bufferedAmount").Int())
 }
 
-func (c *WebSocket) addEventListener(eventType string, fn func(e js.Value)) {
-	c.v.Call("addEventListener", eventType, js.FuncOf(func(this js.Value, args []js.Value) interface{} {
+func (c WebSocket) addEventListener(eventType string, fn func(e js.Value)) func() {
+	f := js.FuncOf(func(this js.Value, args []js.Value) interface{} {
 		fn(args[0])
 		return nil
-	}))
+	})
+	c.v.Call("addEventListener", eventType, f)
+
+	return func() {
+		c.v.Call("removeEventListener", eventType, f)
+		f.Release()
+	}
 }
 
 type CloseEvent struct {
@@ -78,8 +83,8 @@ type CloseEvent struct {
 	WasClean bool
 }
 
-func (c *WebSocket) OnClose(fn func(CloseEvent)) {
-	c.addEventListener("close", func(e js.Value) {
+func (c WebSocket) OnClose(fn func(CloseEvent)) (remove func()) {
+	return c.addEventListener("close", func(e js.Value) {
 		ce := CloseEvent{
 			Code:     uint16(e.Get("code").Int()),
 			Reason:   e.Get("reason").String(),
@@ -89,23 +94,23 @@ func (c *WebSocket) OnClose(fn func(CloseEvent)) {
 	})
 }
 
-func (c *WebSocket) OnError(fn func(e js.Value)) {
-	c.addEventListener("error", fn)
+func (c WebSocket) OnError(fn func(e js.Value)) (remove func()) {
+	return c.addEventListener("error", fn)
 }
 
 type MessageEvent struct {
-	Data []byte
+	Data interface{}
 	// There are more types to the interface but we don't use them.
 	// See https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent
 }
 
-func (c *WebSocket) OnMessage(fn func(m MessageEvent)) {
-	c.addEventListener("message", func(e js.Value) {
-		var data []byte
+func (c WebSocket) OnMessage(fn func(m MessageEvent)) (remove func()) {
+	return c.addEventListener("message", func(e js.Value) {
+		var data interface{}
 
 		arrayBuffer := e.Get("data")
 		if arrayBuffer.Type() == js.TypeString {
-			data = []byte(arrayBuffer.String())
+			data = arrayBuffer.String()
 		} else {
 			data = extractArrayBuffer(arrayBuffer)
 		}
@@ -119,23 +124,23 @@ func (c *WebSocket) OnMessage(fn func(m MessageEvent)) {
 	})
 }
 
-func (c *WebSocket) OnOpen(fn func(e js.Value)) {
-	c.addEventListener("open", fn)
+func (c WebSocket) OnOpen(fn func(e js.Value)) (remove func()) {
+	return c.addEventListener("open", fn)
 }
 
-func (c *WebSocket) Close(code int, reason string) (err error) {
+func (c WebSocket) Close(code int, reason string) (err error) {
 	defer handleJSError(&err, nil)
 	c.v.Call("close", code, reason)
 	return err
 }
 
-func (c *WebSocket) SendText(v string) (err error) {
+func (c WebSocket) SendText(v string) (err error) {
 	defer handleJSError(&err, nil)
 	c.v.Call("send", v)
 	return err
 }
 
-func (c *WebSocket) SendBytes(v []byte) (err error) {
+func (c WebSocket) SendBytes(v []byte) (err error) {
 	defer handleJSError(&err, nil)
 	c.v.Call("send", uint8Array(v))
 	return err
diff --git a/netconn.go b/netconn.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/opcode.go b/opcode.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 // opcode represents a WebSocket Opcode.
diff --git a/websocket.go b/websocket.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/websocket_autobahn_python_test.go b/websocket_autobahn_python_test.go
@@ -1,6 +1,7 @@
 // This file contains the old autobahn test suite tests that use the
-// python binary. The approach is very clunky and slow so new tests
+// python binary. The approach is clunky and slow so new tests
 // have been written in pure Go in websocket_test.go.
+// These have been kept for correctness purposes and are occasionally ran.
 // +build autobahn-python
 
 package websocket_test
diff --git a/websocket_bench_test.go b/websocket_bench_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket_test
 
 import (
diff --git a/websocket_js.go b/websocket_js.go
@@ -0,0 +1,139 @@
+package websocket
+
+import (
+	"context"
+	"fmt"
+	"golang.org/x/xerrors"
+	"net/http"
+	"nhooyr.io/websocket/internal/wsjs"
+	"reflect"
+	"syscall/js"
+)
+
+type Conn struct {
+	ws wsjs.WebSocket
+
+	closed   chan struct{}
+	closeErr CloseError
+
+	releases []func()
+
+	read chan wsjs.MessageEvent
+}
+
+func (c *Conn) init() {
+	c.closed = make(chan struct{})
+	c.read = make(chan wsjs.MessageEvent, 1)
+
+	c.appendRelease(c.ws.OnClose(func(e wsjs.CloseEvent) {
+		c.closeErr = makeCloseError(e)
+		c.release()
+		close(c.closed)
+	}))
+
+	c.appendRelease(c.ws.OnMessage(func(e wsjs.MessageEvent) {
+		c.read <- e
+	}))
+}
+
+func (c *Conn) appendRelease(r func()) {
+	c.releases = append(c.releases, r)
+}
+
+func (c *Conn) release() {
+	for _, r := range c.releases {
+		r()
+	}
+}
+
+func (c *Conn) Read(ctx context.Context) (_ MessageType, _ []byte, err error) {
+	defer errdWrap(&err, "failed to read")
+
+	var me wsjs.MessageEvent
+	select {
+	case <-ctx.Done():
+		return 0, nil, ctx.Err()
+	case me = <-c.read:
+
+	}
+	switch p := me.Data.(type) {
+	case string:
+		return MessageText, []byte(p), nil
+	case []byte:
+		return MessageBinary, p, nil
+	default:
+		panic("websocket: unexpected data type from wsjs OnMessage: " + reflect.TypeOf(me.Data).String())
+	}
+}
+
+func (c *Conn) Write(ctx context.Context, typ MessageType, p []byte) error {
+	switch typ {
+	case MessageBinary:
+		c.ws.SendBytes(p)
+	case MessageText:
+		c.ws.SendText(string(p))
+	}
+	return nil
+}
+
+func (c *Conn) Close(code StatusCode, reason string) error {
+	err := c.ws.Close(int(code), reason)
+	if err != nil {
+		return xerrors.Errorf("failed to close websocket: %w", err)
+	}
+	return nil
+}
+
+func (c *Conn) Subprotocol() string {
+	return c.ws.Protocol
+}
+
+// DialOptions represents the options available to pass to Dial.
+type DialOptions struct {
+	// Subprotocols lists the subprotocols to negotiate with the server.
+	Subprotocols []string
+}
+
+func Dial(ctx context.Context, url string, opts *DialOptions) (_ *Conn, _ *http.Response, err error) {
+	defer errdWrap(&err, "failed to dial")
+
+	ws, err := wsjs.New(url, opts.Subprotocols)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := &Conn{
+		ws: ws,
+	}
+	c.init()
+
+	opench := make(chan struct{})
+	releaseOpen := ws.OnOpen(func(e js.Value) {
+		close(opench)
+	})
+	defer releaseOpen()
+
+	select {
+	case <-ctx.Done():
+		return nil, nil, ctx.Err()
+	case <-opench:
+	case <-c.closed:
+		return c, nil, c.closeErr
+	}
+
+	// Have to return a non nil response as the normal API does that.
+	return c, &http.Response{}, nil
+}
+
+func makeCloseError(e wsjs.CloseEvent) CloseError {
+	return CloseError{
+		Code:   StatusCode(e.Code),
+		Reason: e.Reason,
+	}
+}
+
+func errdWrap(errp *error, f string, args ...interface{}) {
+	if *errp != nil {
+		*errp = fmt.Errorf(f+": %w", append(args, *errp))
+	}
+}
diff --git a/websocket_test.go b/websocket_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket_test
 
 import (
diff --git a/xor.go b/xor.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (
diff --git a/xor_test.go b/xor_test.go
@@ -1,3 +1,5 @@
+// +build !js
+
 package websocket
 
 import (

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// +build !js`
	`2`	`+`
`1`	`3`	`package websocket`
`2`	`4`
`3`	`5`	`import (`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// +build !js`
	`2`	`+`
`1`	`3`	`// Package websocket is a minimal and idiomatic implementation of the WebSocket protocol.`
`2`	`4`	`//`
`3`	`5`	`// https://tools.ietf.org/html/rfc6455`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// +build !js`
	`2`	`+`
`1`	`3`	`package websocket_test`
`2`	`4`
`3`	`5`	`import (`