Add client/server exec test

- move proto docs to internal

Author: cmoog

README.md

@@ -10,13 +10,13 @@ with WebSocket so it may be used directly by a browser frontend.
 ### Client
 
 ```golang
-conn, _, err := websocket.Dial(ctx, "ws://remote.exec.addr", nil)
+ws, _, err := websocket.Dial(ctx, "ws://remote.exec.addr", nil)
 if err != nil {
   // handle error
 }
 defer conn.Close(websocket.StatusAbnormalClosure, "terminate process")
 
-executor := wsep.RemoteExecer(conn)
+executor := wsep.RemoteExecer(ws)
 process, err := executor.Start(ctx, proto.Command{
   Command: "cat",
   Args: []string{"go.mod"},
@@ -41,18 +41,18 @@ conn.Close(websocket.StatusNormalClosure, "normal closure")
 ### Server
 
 ```golang
-func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	ws, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true})
+func (s server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ws, err := websocket.Accept(w, r, nil)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
-  }
-  defer ws.Close()
-
+	}
 	err = wsep.Serve(r.Context(), ws, wsep.LocalExecer{})
 	if err != nil {
-    // handle error
+		ws.Close(websocket.StatusAbnormalClosure, "failed to serve execer")
+		return
 	}
+	ws.Close(websocket.StatusNormalClosure, "normal closure")
 }
 ```
 
@@ -86,91 +86,4 @@ streams at
        15.34 real         2.16 user         1.54 sys
 ```
 
-The same command over wush stdout (which is high performance) streams at 17MB/s. This leads me to believe
-there's a large gap we can close.
-
-## Protocol
-
-Each Message is represented as a single WebSocket message. A newline character separates a JSON header from the binary body.
-
-Some messages may omit the body.
-
-The overhead of the additional frame is 2 to 6 bytes. In high throughput cases, messages contain ~32KB of data,
-so this overhead is negligible.
-
-### Client Messages
-
-#### Start
-
-This must be the first Client message.
-
-```json
-{
-  "type": "start",
-  "command": {
-    "command": "cat",
-    "args": ["/dev/urandom"],
-    "tty": false
-  }
-}
-```
-
-#### Stdin
-
-```json
-{ "type": "stdin" }
-```
-
-and a body follows after a newline character.
-
-#### Resize
-
-```json
-{ "type": "resize", "cols": 80, "rows": 80 }
-```
-
-Only valid on tty messages.
-
-#### CloseStdin
-
-No more Stdin messages may be sent after this.
-
-```json
-{ "type": "close_stdin" }
-```
-
-### Server Messages
-
-#### Pid
-
-This is sent immediately after the command starts.
-
-```json
-{ "type": "pid", "pid": 0 }
-```
-
-#### Stdout
-
-```json
-{ "type": "stdout" }
-```
-
-and a body follows after a newline character.
-
-#### Stderr
-
-```json
-{ "type": "stderr" }
-```
-
-and a body follows after a newline character.
-
-#### ExitCode
-
-This is the last message sent by the server.
-
-```json
-{ "type": "exit_code", "code": 255 }
-```
-
-A normal closure follows.
+The same command over wush stdout (which is high performance) streams at 17MB/s.

client_test.go

@@ -2,14 +2,23 @@ package wsep
 
 import (
 	"bytes"
+	"context"
 	"io"
 	"io/ioutil"
 	"net"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"sync"
 	"testing"
+	"time"
 
 	"cdr.dev/slog/sloggers/slogtest/assert"
 	"cdr.dev/wsep/internal/proto"
 	"github.com/google/go-cmp/cmp"
+	"go.coder.com/flog"
+	"nhooyr.io/websocket"
 )
 
 func TestRemoteStdin(t *testing.T) {
@@ -41,3 +50,63 @@ func TestRemoteStdin(t *testing.T) {
 		assert.Equal(t, "stdin header", header, []byte(`{"type":"stdin"}`), bytecmp)
 	}
 }
+
+func TestExec(t *testing.T) {
+	mockServerHandler := func(w http.ResponseWriter, r *http.Request) {
+		ws, err := websocket.Accept(w, r, nil)
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+		err = Serve(r.Context(), ws, LocalExecer{})
+		if err != nil {
+			flog.Error("failed to serve execer: %v", err)
+			ws.Close(websocket.StatusAbnormalClosure, "failed to serve execer")
+			return
+		}
+		ws.Close(websocket.StatusNormalClosure, "normal closure")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+
+	server := httptest.NewServer(http.HandlerFunc(mockServerHandler))
+	defer server.Close()
+
+	ws, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(server.URL, "http"), nil)
+	assert.Success(t, "dial websocket server", err)
+	defer ws.Close(websocket.StatusAbnormalClosure, "abnormal closure")
+
+	execer := RemoteExecer(ws)
+	process, err := execer.Start(ctx, Command{
+		Command: "pwd",
+	})
+	assert.Success(t, "start process", err)
+
+	assert.Equal(t, "pid", false, process.Pid() == 0)
+
+	var wg sync.WaitGroup
+	go func() {
+		wg.Add(1)
+		defer wg.Done()
+
+		stdout, err := ioutil.ReadAll(process.Stdout())
+		assert.Success(t, "read stdout", err)
+		wd, err := os.Getwd()
+		assert.Success(t, "get real working dir", err)
+
+		assert.Equal(t, "stdout", wd, strings.TrimSuffix(string(stdout), "\n"))
+	}()
+	go func() {
+		wg.Add(1)
+		defer wg.Done()
+		stderr, err := ioutil.ReadAll(process.Stderr())
+		assert.Success(t, "read stderr", err)
+		assert.Equal(t, "len stderr", 0, len(stderr))
+	}()
+
+	err = process.Wait()
+	assert.Success(t, "wait", err)
+
+	wg.Wait()
+}

dev/server/main.go

@@ -11,22 +11,23 @@ import (
 func main() {
 	server := http.Server{
 		Addr:    ":8080",
-		Handler: server{},
+		Handler: http.HandlerFunc(serve),
 	}
 	err := server.ListenAndServe()
 	flog.Fatal("failed to listen: %v", err)
 }
 
-type server struct{}
-
-func (s server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func serve(w http.ResponseWriter, r *http.Request) {
 	ws, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true})
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 	err = wsep.Serve(r.Context(), ws, wsep.LocalExecer{})
 	if err != nil {
-		flog.Fatal("failed to serve local execer: %v", err)
+		flog.Error("failed to serve execer: %v", err)
+		ws.Close(websocket.StatusAbnormalClosure, "failed to serve execer")
+		return
 	}
+	ws.Close(websocket.StatusNormalClosure, "normal closure")
 }

internal/proto/README.md

@@ -0,0 +1,85 @@
+# Protocol
+
+Each Message is represented as a single WebSocket message. A newline character separates a JSON header from the binary body.
+
+Some messages may omit the body.
+
+The overhead of the additional frame is 2 to 6 bytes. In high throughput cases, messages contain ~32KB of data,
+so this overhead is negligible.
+
+### Client Messages
+
+#### Start
+
+This must be the first Client message.
+
+```json
+{
+  "type": "start",
+  "command": {
+    "command": "cat",
+    "args": ["/dev/urandom"],
+    "tty": false
+  }
+}
+```
+
+#### Stdin
+
+```json
+{ "type": "stdin" }
+```
+
+and a body follows after a newline character.
+
+#### Resize
+
+```json
+{ "type": "resize", "cols": 80, "rows": 80 }
+```
+
+Only valid on tty messages.
+
+#### CloseStdin
+
+No more Stdin messages may be sent after this.
+
+```json
+{ "type": "close_stdin" }
+```
+
+### Server Messages
+
+#### Pid
+
+This is sent immediately after the command starts.
+
+```json
+{ "type": "pid", "pid": 0 }
+```
+
+#### Stdout
+
+```json
+{ "type": "stdout" }
+```
+
+and a body follows after a newline character.
+
+#### Stderr
+
+```json
+{ "type": "stderr" }
+```
+
+and a body follows after a newline character.
+
+#### ExitCode
+
+This is the last message sent by the server.
+
+```json
+{ "type": "exit_code", "code": 255 }
+```
+
+A normal closure follows.