@automattic/vip 4.1.4 → 4.1.6

package/internal/wpstream/e2e_test.go

@@ -1,178 +0,0 @@
-//go:build wpstream_e2e
-
-package wpstream
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"net"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-// startFixtureServer spawns the Node socket.io fixture on a free port and waits
-// for "LISTENING". Requires Node 22. Env knobs configure behavior.
-func startFixtureServer(t *testing.T, env map[string]string) (apiHost string) {
-	t.Helper()
-	port := freePort(t)
-	cmd := exec.Command("node", "internal/wpstream/testdata/fixture-server.js")
-	cmd.Dir = repoRoot(t) // module root (dir containing go.mod)
-	cmd.Env = append(envSlice(env), "PORT="+strconv.Itoa(port))
-	stdout, _ := cmd.StdoutPipe()
-	cmd.Stderr = nil
-	if err := cmd.Start(); err != nil {
-		t.Skipf("node not available: %v", err)
-	}
-	t.Cleanup(func() { _ = cmd.Process.Kill() })
-
-	sc := bufio.NewScanner(stdout)
-	ready := make(chan struct{})
-	go func() {
-		for sc.Scan() {
-			if strings.Contains(sc.Text(), "LISTENING") {
-				close(ready)
-				return
-			}
-		}
-	}()
-	select {
-	case <-ready:
-	case <-time.After(10 * time.Second):
-		t.Fatal("fixture server did not start")
-	}
-	return "http://127.0.0.1:" + strconv.Itoa(port)
-}
-
-// freePort finds an available TCP port on localhost.
-func freePort(t *testing.T) int {
-	t.Helper()
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("freePort: %v", err)
-	}
-	port := l.Addr().(*net.TCPAddr).Port
-	_ = l.Close()
-	return port
-}
-
-// repoRoot walks up from the test's working dir until it finds a directory
-// containing go.mod (the module root).
-func repoRoot(t *testing.T) string {
-	t.Helper()
-	dir, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("repoRoot: Getwd: %v", err)
-	}
-	for {
-		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
-			return dir
-		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			t.Fatal("repoRoot: go.mod not found")
-		}
-		dir = parent
-	}
-}
-
-// envSlice starts from os.Environ() and appends k=v for each map entry.
-func envSlice(env map[string]string) []string {
-	base := os.Environ()
-	for k, v := range env {
-		base = append(base, k+"="+v)
-	}
-	return base
-}
-
-func TestE2EHappyPathStdoutAndExit(t *testing.T) {
-	apiHost := startFixtureServer(t, map[string]string{
-		"SCRIPT_STDOUT": "hello from wp-cli\n",
-		"EXIT_CODE":     "0",
-	})
-	var out bytes.Buffer
-	res, err := Run(context.Background(), Options{
-		APIHost: apiHost, Token: "test-token",
-		GUID: "g", InputToken: "t",
-		Stdin: strings.NewReader(""), Stdout: &out, Stderr: &out,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.ExitCode != 0 {
-		t.Errorf("exit = %d", res.ExitCode)
-	}
-	if !strings.Contains(out.String(), "hello from wp-cli") {
-		t.Errorf("stdout = %q", out.String())
-	}
-}
-
-func TestE2ENonZeroExit(t *testing.T) {
-	apiHost := startFixtureServer(t, map[string]string{
-		"SCRIPT_STDOUT": "boom\n", "EXIT_CODE": "3", "EXIT_MESSAGE": "failed",
-	})
-	var out bytes.Buffer
-	res, err := Run(context.Background(), Options{APIHost: apiHost, Token: "t", GUID: "g", InputToken: "t",
-		Stdin: strings.NewReader(""), Stdout: &out, Stderr: &out})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.ExitCode != 3 {
-		t.Errorf("exit = %d, want 3", res.ExitCode)
-	}
-}
-
-func TestE2EOffsetResumeAfterKill(t *testing.T) {
-	apiHost := startFixtureServer(t, map[string]string{
-		"SCRIPT_STDOUT": "0123456789ABCDEF", "KILL_AFTER": "8", "EXIT_CODE": "0",
-	})
-	var out bytes.Buffer
-	res, err := Run(context.Background(), Options{APIHost: apiHost, Token: "t", GUID: "g", InputToken: "t",
-		Stdin: strings.NewReader(""), Stdout: &out, Stderr: &out})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.ExitCode != 0 {
-		t.Errorf("exit = %d", res.ExitCode)
-	}
-	if out.String() != "0123456789ABCDEF" {
-		t.Errorf("resumed stdout = %q, want full payload once", out.String())
-	}
-}
-
-// TestE2EOffsetResumeMultipleKills verifies that the reconnect loop handles
-// MORE THAN ONE disconnect correctly (C1 fix). The fixture kills the connection
-// twice: after 8 bytes on the first attempt (offset=0→8), and after 8 bytes
-// on the second attempt (offset=8→16). The third attempt delivers the remaining
-// 8 bytes (offset=16→24) and emits exit 0. The full 24-byte payload must appear
-// in Stdout exactly once.
-func TestE2EOffsetResumeMultipleKills(t *testing.T) {
-	apiHost := startFixtureServer(t, map[string]string{
-		"SCRIPT_STDOUT": "0123456789ABCDEFGHIJKLMN",
-		"KILL_AFTER":    "8",
-		"KILL_TIMES":    "2",
-		"EXIT_CODE":     "0",
-	})
-	var out bytes.Buffer
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-	res, err := Run(ctx, Options{
-		APIHost: apiHost, Token: "t", GUID: "g", InputToken: "t",
-		Stdin: strings.NewReader(""), Stdout: &out, Stderr: &out,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.ExitCode != 0 {
-		t.Errorf("exit = %d, want 0", res.ExitCode)
-	}
-	const want = "0123456789ABCDEFGHIJKLMN"
-	if out.String() != want {
-		t.Errorf("stdout = %q, want %q", out.String(), want)
-	}
-}

package/internal/wpstream/engineio.go

@@ -1,291 +0,0 @@
-// Package wpstream is a hand-rolled Engine.IO v4 + Socket.IO v4 +
-// socket.io-stream client. It ports the socket.io transport used by
-// src/bin/vip-wp.js for the wpcliStrategy=websocket WP-CLI strategy.
-//
-// engineio.go is the bottom layer: the Engine.IO v4 transport. It does the
-// HTTP long-poll handshake, upgrades to WebSocket, answers server pings, and
-// exposes a packet-level duplex to the Socket.IO codec above it.
-package wpstream
-
-import (
-	"context"
-	"encoding/json/v2"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/coder/websocket"
-
-	"github.com/Automattic/vip/internal/httpproxy"
-)
-
-// Engine.IO v4 packet type chars (engine.io-parser commons.js).
-const (
-	eioOpen    = '0'
-	eioClose   = '1'
-	eioPing    = '2'
-	eioPong    = '3'
-	eioMessage = '4'
-	eioUpgrade = '5'
-	eioNoop    = '6'
-)
-
-// Packet is one Engine.IO packet. For text packets Type is the type char and
-// Data is the payload after it. For raw binary frames (socket.io attachments)
-// Binary is true, Type is eioMessage by convention, and Data holds the bytes.
-type Packet struct {
-	Type   byte
-	Data   []byte
-	Binary bool
-}
-
-// DialOptions configure the Engine.IO connection.
-type DialOptions struct {
-	BaseURL string      // e.g. https://api.wpvip.com (no trailing /socket.io/)
-	Header  http.Header // extraHeaders carried on BOTH transports (Bearer token)
-	Client  *http.Client
-}
-
-type openPacket struct {
-	SID          string   `json:"sid"`
-	Upgrades     []string `json:"upgrades"`
-	PingInterval int      `json:"pingInterval"`
-	PingTimeout  int      `json:"pingTimeout"`
-}
-
-// Engine is a connected Engine.IO transport (after the websocket upgrade).
-// A background read loop dispatches incoming frames: pings are answered
-// immediately, non-ping packets are queued on recvCh for Read callers.
-type Engine struct {
-	ws           *websocket.Conn
-	sid          string
-	pingInterval time.Duration
-	pingTimeout  time.Duration
-
-	recvCh chan Packet
-	errCh  chan error // closed / first error from the read loop
-
-	mu         sync.Mutex
-	closeOnce  sync.Once
-	closed     chan struct{}
-	readCancel context.CancelFunc // cancels the readLoop context (I1)
-}
-
-func (e *Engine) SID() string { return e.sid }
-
-// Dial performs the polling handshake then upgrades to WebSocket.
-func Dial(ctx context.Context, opts DialOptions) (*Engine, error) {
-	client := opts.Client
-	if client == nil {
-		// vip-wp.js:539 passes createProxyAgent(API_HOST) to the socket.io
-		// client, so this transport is proxied on Node too — but by Node's
-		// policy, not http.DefaultTransport's. See internal/httpproxy.
-		client = httpproxy.Client()
-	}
-
-	// 1. Polling handshake: GET /socket.io/?EIO=4&transport=polling
-	open, err := pollingHandshake(ctx, client, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	// 2. WebSocket upgrade with sid.
-	wsURL := buildURL(opts.BaseURL, "websocket", open.SID)
-	c, _, err := websocket.Dial(ctx, wsURL, &websocket.DialOptions{
-		HTTPClient: client,
-		HTTPHeader: opts.Header,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("wpstream: websocket dial: %w", err)
-	}
-	c.SetReadLimit(-1) // server controls payload size; no client cap
-
-	// 3. Probe: send "2probe", expect "3probe", send "5".
-	if err := c.Write(ctx, websocket.MessageText, []byte("2probe")); err != nil {
-		return nil, err
-	}
-	_, resp, err := c.Read(ctx)
-	if err != nil || string(resp) != "3probe" {
-		return nil, fmt.Errorf("wpstream: bad probe reply %q (%v)", resp, err)
-	}
-	if err := c.Write(ctx, websocket.MessageText, []byte{eioUpgrade}); err != nil {
-		return nil, err
-	}
-
-	// I1: derive a cancelable context so Close() can stop readLoop.
-	readCtx, readCancel := context.WithCancel(context.Background())
-
-	eng := &Engine{
-		ws:           c,
-		sid:          open.SID,
-		pingInterval: time.Duration(open.PingInterval) * time.Millisecond,
-		pingTimeout:  time.Duration(open.PingTimeout) * time.Millisecond,
-		recvCh:       make(chan Packet, 64),
-		errCh:        make(chan error, 1),
-		closed:       make(chan struct{}),
-		readCancel:   readCancel,
-	}
-	go eng.readLoop(readCtx)
-	return eng, nil
-}
-
-// readLoop is the single goroutine that owns the websocket read side.
-// It answers server pings immediately (serialized through the write mutex)
-// and queues all other packets onto recvCh.
-// I1: ctx is derived from a cancelable context created in Dial; Close() cancels
-// it, which unblocks e.ws.Read and terminates the goroutine cleanly.
-func (e *Engine) readLoop(ctx context.Context) {
-	defer close(e.errCh)
-	for {
-		typ, data, err := e.ws.Read(ctx)
-		if err != nil {
-			select {
-			case e.errCh <- err:
-			default:
-			}
-			return
-		}
-		if typ == websocket.MessageBinary {
-			select {
-			case e.recvCh <- Packet{Type: eioMessage, Data: data, Binary: true}:
-			case <-e.closed:
-				return
-			}
-			continue
-		}
-		if len(data) == 0 {
-			continue
-		}
-		switch data[0] {
-		case eioPing:
-			// Server-initiated heartbeat: reply with pong immediately.
-			_ = e.write(context.Background(), websocket.MessageText, []byte{eioPong})
-		case eioNoop:
-			// skip
-		case eioClose:
-			select {
-			case e.errCh <- io.EOF:
-			default:
-			}
-			return
-		default:
-			select {
-			case e.recvCh <- Packet{Type: data[0], Data: data[1:]}:
-			case <-e.closed:
-				return
-			}
-		}
-	}
-}
-
-func pollingHandshake(ctx context.Context, client *http.Client, opts DialOptions) (*openPacket, error) {
-	u := buildURL(opts.BaseURL, "polling", "")
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
-	if err != nil {
-		return nil, err
-	}
-	for k, vs := range opts.Header {
-		for _, v := range vs {
-			req.Header.Add(k, v)
-		}
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("wpstream: polling handshake: %w", err)
-	}
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-	// First packet of the (possibly \x1e-joined) payload is the open packet.
-	first := body
-	if i := strings.IndexByte(string(body), '\x1e'); i >= 0 {
-		first = body[:i]
-	}
-	if len(first) == 0 || first[0] != eioOpen {
-		return nil, fmt.Errorf("wpstream: expected open packet, got %q", first)
-	}
-	var op openPacket
-	if err := json.Unmarshal(first[1:], &op); err != nil {
-		return nil, fmt.Errorf("wpstream: parse open packet: %w", err)
-	}
-	return &op, nil
-}
-
-// buildURL constructs <base>/socket.io/?EIO=4&transport=<t>[&sid=<sid>]
-// with ws/wss scheme for the websocket transport.
-func buildURL(base, transport, sid string) string {
-	u, _ := url.Parse(base)
-	u.Path = strings.TrimRight(u.Path, "/") + "/socket.io/"
-	if transport == "websocket" {
-		switch u.Scheme {
-		case "https":
-			u.Scheme = "wss"
-		case "http":
-			u.Scheme = "ws"
-		}
-	}
-	q := u.Query()
-	q.Set("EIO", "4")
-	q.Set("transport", transport)
-	if sid != "" {
-		q.Set("sid", sid)
-	}
-	u.RawQuery = q.Encode()
-	return u.String()
-}
-
-// Read returns the next non-heartbeat packet. Blocks until a packet arrives,
-// the context is cancelled, or the connection is closed.
-func (e *Engine) Read(ctx context.Context) (Packet, error) {
-	select {
-	case pkt, ok := <-e.recvCh:
-		if !ok {
-			return Packet{}, errClosed
-		}
-		return pkt, nil
-	case err, ok := <-e.errCh:
-		if !ok {
-			return Packet{}, errClosed
-		}
-		return Packet{}, err
-	case <-ctx.Done():
-		return Packet{}, ctx.Err()
-	case <-e.closed:
-		return Packet{}, errClosed
-	}
-}
-
-// WriteMessage sends a Socket.IO message packet ("4" + payload).
-func (e *Engine) WriteMessage(ctx context.Context, payload []byte) error {
-	frame := append([]byte{eioMessage}, payload...)
-	return e.write(ctx, websocket.MessageText, frame)
-}
-
-// WriteBinary sends a raw binary attachment frame (EIO4: no type prefix).
-func (e *Engine) WriteBinary(ctx context.Context, data []byte) error {
-	return e.write(ctx, websocket.MessageBinary, data)
-}
-
-func (e *Engine) write(ctx context.Context, typ websocket.MessageType, data []byte) error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	return e.ws.Write(ctx, typ, data)
-}
-
-func (e *Engine) Close() error {
-	e.closeOnce.Do(func() {
-		// I1: cancel the readLoop context so ws.Read unblocks immediately.
-		e.readCancel()
-		close(e.closed)
-	})
-	return e.ws.Close(websocket.StatusNormalClosure, "")
-}
-
-var errClosed = errors.New("wpstream: engine closed")

package/internal/wpstream/engineio_test.go

@@ -1,82 +0,0 @@
-package wpstream
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/coder/websocket"
-)
-
-// fakeEIOServer serves the EIO4 polling handshake then accepts a websocket
-// upgrade, completes the 2probe/5 dance, and sends one message packet.
-func fakeEIOServer(t *testing.T) *httptest.Server {
-	t.Helper()
-	mux := http.NewServeMux()
-	mux.HandleFunc("/socket.io/", func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Query().Get("transport") == "polling" {
-			// Open packet: type '0' + JSON handshake.
-			w.Header().Set("Content-Type", "text/plain; charset=UTF-8")
-			_, _ = w.Write([]byte(`0{"sid":"abc","upgrades":["websocket"],"pingInterval":300,"pingTimeout":200,"maxPayload":1000000}`))
-			return
-		}
-		// websocket transport
-		c, err := websocket.Accept(w, r, nil)
-		if err != nil {
-			return
-		}
-		defer c.Close(websocket.StatusNormalClosure, "")
-		ctx := r.Context()
-		// Expect "2probe", reply "3probe".
-		_, probe, _ := c.Read(ctx)
-		if string(probe) != "2probe" {
-			t.Errorf("probe = %q", probe)
-		}
-		_ = c.Write(ctx, websocket.MessageText, []byte("3probe"))
-		// Expect "5" (upgrade).
-		_, up, _ := c.Read(ctx)
-		if string(up) != "5" {
-			t.Errorf("upgrade = %q", up)
-		}
-		// Send one message packet "4hello".
-		_ = c.Write(ctx, websocket.MessageText, []byte("4hello"))
-		// Then a server ping "2"; expect pong "3".
-		_ = c.Write(ctx, websocket.MessageText, []byte("2"))
-		_, pong, _ := c.Read(ctx)
-		if string(pong) != "3" {
-			t.Errorf("pong = %q", pong)
-		}
-		time.Sleep(20 * time.Millisecond)
-	})
-	srv := httptest.NewServer(mux)
-	t.Cleanup(srv.Close)
-	return srv
-}
-
-func TestEngineIOHandshakeAndUpgrade(t *testing.T) {
-	srv := fakeEIOServer(t)
-	eng, err := Dial(context.Background(), DialOptions{
-		BaseURL: srv.URL,
-		Header:  http.Header{"Authorization": {"Bearer tok"}},
-	})
-	if err != nil {
-		t.Fatalf("Dial: %v", err)
-	}
-	defer eng.Close()
-
-	if eng.SID() != "abc" {
-		t.Errorf("sid = %q, want abc", eng.SID())
-	}
-	pkt, err := eng.Read(context.Background())
-	if err != nil {
-		t.Fatalf("Read: %v", err)
-	}
-	if pkt.Type != '4' || string(pkt.Data) != "hello" {
-		t.Errorf("pkt = %c%q", pkt.Type, pkt.Data)
-	}
-	// The transport must auto-answer the server ping with a pong (asserted
-	// server-side). Give the heartbeat goroutine a moment.
-	time.Sleep(30 * time.Millisecond)
-}