chore(controller-sdk-go): remove gorilla websocket

Author: duanhongyi

api/apps.go

@@ -37,3 +37,10 @@ type AppRunResponse struct {
 	Output     string `json:"output"`
 	ReturnCode int    `json:"exit_code"`
 }
+
+// AppLogsRequest is the definition of websocket /v2/apps/<app id>/logs
+type AppLogsRequest struct {
+	Lines   int  `json:"lines"`
+	Follow  bool `json:"follow"`
+	Timeout int  `json:"timeout"`
+}

api/ps.go

@@ -24,6 +24,13 @@ func (p PodsList) Len() int           { return len(p) }
 func (p PodsList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 func (p PodsList) Less(i, j int) bool { return p[i].Name < p[j].Name }
 
+// Command defines a command of app exec.
+type Command struct {
+	Tty     bool     `json:"tty"`
+	Stdin   bool     `json:"stdin"`
+	Command []string `json:"command"`
+}
+
 // PodType holds pods of the same type.
 type PodType struct {
 	Type     string

apps/apps.go

@@ -10,7 +10,7 @@ import (
 
 	drycc "github.com/drycc/controller-sdk-go"
 	"github.com/drycc/controller-sdk-go/api"
-	"github.com/gorilla/websocket"
+	"golang.org/x/net/websocket"
 )
 
 // ErrNoLogs is returned when logs are missing from an app.
@@ -89,29 +89,31 @@ func Get(c *drycc.Client, appID string) (api.App, error) {
 
 // Logs retrieves logs from an app. The number of log lines fetched can be set by the lines
 // argument. Setting lines = -1 will retrieve all app logs.
-func Logs(c *drycc.Client, appID string, lines int, follow bool, timeout int) (*websocket.Conn, error) {
+func Logs(c *drycc.Client, appID string, request api.AppLogsRequest) (*websocket.Conn, error) {
 	scheme := "ws"
 	if c.ControllerURL.Scheme == "https" {
 		scheme = "wss"
 	}
 	path := fmt.Sprintf("v2/apps/%s/logs", appID)
 	endpoint := url.URL{Scheme: scheme, Host: c.ControllerURL.Host, Path: path}
-	conn, _, err := websocket.DefaultDialer.Dial(
-		endpoint.String(),
-		http.Header{
-			"User-Agent":           {c.UserAgent},
-			"Authorization":        {"token " + c.Token},
-			"X-Drycc-Builder-Auth": {c.HooksToken},
-		},
-	)
+
+	config, err := websocket.NewConfig(endpoint.String(), c.ControllerURL.String())
+	if err != nil {
+		return nil, err
+	}
+	config.Header = http.Header{
+		"User-Agent":           {c.UserAgent},
+		"Authorization":        {"token " + c.Token},
+		"X-Drycc-Builder-Auth": {c.HooksToken},
+	}
+	conn, err := websocket.DialConfig(config)
+	if err != nil {
+		return nil, err
+	}
+	err = websocket.JSON.Send(conn, request)
 	if err != nil {
 		return nil, err
 	}
-
-	conn.WriteMessage(
-		websocket.TextMessage,
-		[]byte(fmt.Sprintf(`{"lines": %d, "timeout": %d, "follow": %v}`, lines, timeout, follow)),
-	)
 	return conn, nil
 }
 

apps/apps_test.go

@@ -1,18 +1,18 @@
 package apps
 
 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
+	"sync"
 	"testing"
 
 	drycc "github.com/drycc/controller-sdk-go"
 	"github.com/drycc/controller-sdk-go/api"
-	"github.com/gorilla/websocket"
+	"golang.org/x/net/websocket"
 )
 
 const appFixture string = `
@@ -46,19 +46,11 @@ const appCreateExpected string = `{"id":"example-go"}`
 const appRunExpected string = `{"command":"echo hi"}`
 const appTransferExpected string = `{"owner":"test"}`
 
-var upgrader = websocket.Upgrader{} // use default options
-
 type fakeHTTPServer struct {
 	createID        bool
 	createWithoutID bool
 }
 
-type fakeLogReqMessage struct {
-	Lines   int  `json:"lines"`
-	Timeout int  `json:"timeout"`
-	Follow  bool `json:"follow"`
-}
-
 func (f *fakeHTTPServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 	res.Header().Add("DRYCC_API_VERSION", drycc.APIVersion)
 
@@ -105,28 +97,6 @@ func (f *fakeHTTPServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
 		return
 	}
 
-	// The entire log message is prefixed and suffixed with a few characters (not entirely sure why)
-	// We mimic those here
-	if req.URL.Path == "/v2/apps/example-go/logs" {
-		c, err := upgrader.Upgrade(res, req, nil)
-		if err != nil {
-			log.Print("upgrade:", err)
-			return
-		}
-		defer c.Close()
-		_, message, err := c.ReadMessage()
-		if err != nil {
-			log.Print("upgrade:", err)
-			return
-		}
-		reqJSON := fakeLogReqMessage{}
-		json.Unmarshal([]byte(message), &reqJSON)
-		for i := 0; i < reqJSON.Lines; i++ {
-			c.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf("test %d", i)))
-		}
-		return
-	}
-
 	if req.URL.Path == "/v2/apps/example-go/run" && req.Method == "POST" {
 		body, err := io.ReadAll(req.Body)
 
@@ -317,26 +287,39 @@ func TestAppsList(t *testing.T) {
 
 func TestAppsLogs(t *testing.T) {
 	t.Parallel()
-
-	handler := fakeHTTPServer{}
-	server := httptest.NewServer(&handler)
-	defer server.Close()
-
-	drycc, err := drycc.New(false, server.URL, "abc")
+	var once sync.Once
+	var addr string
+	once.Do(func() {
+		http.Handle(
+			"/v2/apps/example-go/logs",
+			websocket.Handler(func(conn *websocket.Conn) {
+				io.Copy(conn, conn)
+			}),
+		)
+		server := httptest.NewServer(nil)
+		addr = server.Listener.Addr().String()
+		log.Print("Test WebSocket server listening on ", addr)
+	})
+	drycc, err := drycc.New(false, addr, "abc")
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	conn, err := Logs(drycc, "example-go", 1, false, 300)
+	expected := api.AppLogsRequest{
+		Lines:   1,
+		Follow:  false,
+		Timeout: 300,
+	}
+	conn, err := Logs(drycc, "example-go", expected)
 	if err != nil {
 		t.Fatal(err)
 	}
-	_, message, err := conn.ReadMessage()
+	var actual api.AppLogsRequest
+	err = websocket.JSON.Receive(conn, &actual)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if string(message) != "test 0" {
-		t.Errorf("Expected %s, Got %s", "test 0", message)
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("Expected: %v, Got %v", expected, actual)
 	}
 }
 

drycc.go

@@ -55,8 +55,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
-
-	"github.com/goware/urlx"
+	"strings"
 )
 
 // Client oversees the interaction between the drycc and controller
@@ -117,9 +116,11 @@ func IsErrAPIMismatch(err error) bool {
 // verifySSL determines whether or not to verify SSL connections.
 // This should be true unless you know the controller is using untrusted SSL keys.
 func New(verifySSL bool, controllerURL string, token string) (*Client, error) {
-	// urlx, unlike the native url library, uses sane defaults when URL parsing,
 	// preventing issues like missing schemes.
-	u, err := urlx.Parse(controllerURL)
+	if !strings.HasPrefix(controllerURL, "http://") && !strings.HasPrefix(controllerURL, "https://") {
+		controllerURL = "http://" + controllerURL
+	}
+	u, err := url.Parse(controllerURL)
 	if err != nil {
 		return nil, err
 	}

errors_test.go

@@ -31,9 +31,9 @@ func (m *mockReadCloser) Read(msg []byte) (int, error) {
 
 	copy(msg, []byte(m.msg))
 
-	len := len(m.msg)
+	size := len(m.msg)
 	m.msg = ""
-	return len, nil
+	return size, nil
 }
 
 func readCloser(msg string) *mockReadCloser {

go.mod

@@ -2,14 +2,4 @@ module github.com/drycc/controller-sdk-go
 
 go 1.20
 
-require (
-	github.com/gorilla/websocket v1.5.0
-	github.com/goware/urlx v0.3.2
-)
-
-require (
-	github.com/PuerkitoBio/purell v1.1.1 // indirect
-	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
-	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/text v0.7.0 // indirect
-)
+require golang.org/x/net v0.12.0

go.sum

@@ -1,14 +1,2 @@
-github.com/PuerkitoBio/purell v1.1.1 h1:WEQqlqaGbrPkxLJWfBwQmfEAE1Z7ONdDLqrN38tNFfI=
-github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
-github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV/sSk/8dngufqelfh6jnri85riMAaF/M=
-github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
-github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
-github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/goware/urlx v0.3.2 h1:gdoo4kBHlkqZNaf6XlQ12LGtQOmpKJrR04Rc3RnpJEo=
-github.com/goware/urlx v0.3.2/go.mod h1:h8uwbJy68o+tQXCGZNa9D73WN8n0r9OBae5bUnLcgjw=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
+golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=

ps/ps.go

@@ -10,7 +10,7 @@ import (
 
 	drycc "github.com/drycc/controller-sdk-go"
 	"github.com/drycc/controller-sdk-go/api"
-	"github.com/gorilla/websocket"
+	"golang.org/x/net/websocket"
 )
 
 // List lists an app's processes.
@@ -30,32 +30,27 @@ func List(c *drycc.Client, appID string, results int) (api.PodsList, int, error)
 }
 
 // Exec a command in a container.
-func Exec(c *drycc.Client, app, pod string, tty, stdin bool, command []string) (*websocket.Conn, error) {
+func Exec(c *drycc.Client, app, pod string, command api.Command) (*websocket.Conn, error) {
 	scheme := "ws"
 	if c.ControllerURL.Scheme == "https" {
 		scheme = "wss"
 	}
 	path := fmt.Sprintf("v2/apps/%s/pods/%s/exec/", app, pod)
-	endpoint := url.URL{Scheme: scheme, Host: c.ControllerURL.Host, Path: path}
-	conn, _, err := websocket.DefaultDialer.Dial(
-		endpoint.String(),
-		http.Header{
-			"User-Agent":           {c.UserAgent},
-			"Authorization":        {"token " + c.Token},
-			"X-Drycc-Builder-Auth": {c.HooksToken},
-		},
-	)
+	u := url.URL{Scheme: scheme, Host: c.ControllerURL.Host, Path: path}
+	config, err := websocket.NewConfig(u.String(), c.ControllerURL.String())
 	if err != nil {
 		return nil, err
 	}
-	data, err := json.Marshal(&command)
+	config.Header = http.Header{
+		"User-Agent":           {c.UserAgent},
+		"Authorization":        {"token " + c.Token},
+		"X-Drycc-Builder-Auth": {c.HooksToken},
+	}
+	conn, err := websocket.DialConfig(config)
 	if err != nil {
 		return nil, err
 	}
-	conn.WriteMessage(
-		websocket.TextMessage,
-		[]byte(fmt.Sprintf(`{"tty": %t, "stdin": %t, "command": %s}`, tty, stdin, data)),
-	)
+	websocket.JSON.Send(conn, command)
 	return conn, nil
 }