Port envd from e2b with internalized shared packages and Connect RPC

- Copy envd source from e2b-dev/infra, internalize shared dependencies into envd/internal/shared/ (keys, filesystem, id, smap, utils) - Switch from gRPC to Connect RPC for all envd services - Update module paths to git.omukk.dev/wrenn/{sandbox,sandbox/envd} - Add proto specs (process, filesystem) with buf-based code generation - Implement full envd: process exec, filesystem ops, port forwarding, cgroup management, MMDS integration, and HTTP API - Update main module dependencies (firecracker SDK, pgx, goose, etc.) - Remove placeholder .gitkeep files replaced by real implementations
2026-03-09 21:03:19 +06:00
parent bd78cc068c
commit a3898d68fb
99 changed files with 17185 additions and 24 deletions
--- a/envd/internal/api/encoding_test.go
+++ b/envd/internal/api/encoding_test.go
@ -0,0 +1,494 @@
+package api
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsSupportedEncoding(t *testing.T) {
+	t.Parallel()
+
+	t.Run("gzip is supported", func(t *testing.T) {
+		t.Parallel()
+		assert.True(t, isSupportedEncoding("gzip"))
+	})
+
+	t.Run("GZIP is supported (case-insensitive)", func(t *testing.T) {
+		t.Parallel()
+		assert.True(t, isSupportedEncoding("GZIP"))
+	})
+
+	t.Run("Gzip is supported (case-insensitive)", func(t *testing.T) {
+		t.Parallel()
+		assert.True(t, isSupportedEncoding("Gzip"))
+	})
+
+	t.Run("br is not supported", func(t *testing.T) {
+		t.Parallel()
+		assert.False(t, isSupportedEncoding("br"))
+	})
+
+	t.Run("deflate is not supported", func(t *testing.T) {
+		t.Parallel()
+		assert.False(t, isSupportedEncoding("deflate"))
+	})
+}
+
+func TestParseEncodingWithQuality(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns encoding with default quality 1.0", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("gzip")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 1.0, eq.quality, 0.001)
+	})
+
+	t.Run("parses quality value", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("gzip;q=0.5")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 0.5, eq.quality, 0.001)
+	})
+
+	t.Run("parses quality value with whitespace", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("gzip ; q=0.8")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 0.8, eq.quality, 0.001)
+	})
+
+	t.Run("handles q=0", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("gzip;q=0")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 0.0, eq.quality, 0.001)
+	})
+
+	t.Run("handles invalid quality value", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("gzip;q=invalid")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 1.0, eq.quality, 0.001) // defaults to 1.0 on parse error
+	})
+
+	t.Run("trims whitespace from encoding", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("  gzip  ")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 1.0, eq.quality, 0.001)
+	})
+
+	t.Run("normalizes encoding to lowercase", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("GZIP")
+		assert.Equal(t, "gzip", eq.encoding)
+	})
+
+	t.Run("normalizes mixed case encoding", func(t *testing.T) {
+		t.Parallel()
+		eq := parseEncodingWithQuality("Gzip;q=0.5")
+		assert.Equal(t, "gzip", eq.encoding)
+		assert.InDelta(t, 0.5, eq.quality, 0.001)
+	})
+}
+
+func TestParseEncoding(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns encoding as-is", func(t *testing.T) {
+		t.Parallel()
+		assert.Equal(t, "gzip", parseEncoding("gzip"))
+	})
+
+	t.Run("trims whitespace", func(t *testing.T) {
+		t.Parallel()
+		assert.Equal(t, "gzip", parseEncoding("  gzip  "))
+	})
+
+	t.Run("strips quality value", func(t *testing.T) {
+		t.Parallel()
+		assert.Equal(t, "gzip", parseEncoding("gzip;q=1.0"))
+	})
+
+	t.Run("strips quality value with whitespace", func(t *testing.T) {
+		t.Parallel()
+		assert.Equal(t, "gzip", parseEncoding("gzip ; q=0.5"))
+	})
+}
+
+func TestParseContentEncoding(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns identity when no header", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+
+		encoding, err := parseContentEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("returns gzip when Content-Encoding is gzip", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+		req.Header.Set("Content-Encoding", "gzip")
+
+		encoding, err := parseContentEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns gzip when Content-Encoding is GZIP (case-insensitive)", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+		req.Header.Set("Content-Encoding", "GZIP")
+
+		encoding, err := parseContentEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns gzip when Content-Encoding is Gzip (case-insensitive)", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+		req.Header.Set("Content-Encoding", "Gzip")
+
+		encoding, err := parseContentEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns identity for identity encoding", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+		req.Header.Set("Content-Encoding", "identity")
+
+		encoding, err := parseContentEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("returns error for unsupported encoding", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+		req.Header.Set("Content-Encoding", "br")
+
+		_, err := parseContentEncoding(req)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "unsupported Content-Encoding")
+		assert.Contains(t, err.Error(), "supported: [gzip]")
+	})
+
+	t.Run("handles gzip with quality value", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", nil)
+		req.Header.Set("Content-Encoding", "gzip;q=1.0")
+
+		encoding, err := parseContentEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+}
+
+func TestParseAcceptEncoding(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns identity when no header", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("returns gzip when Accept-Encoding is gzip", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "gzip")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns gzip when Accept-Encoding is GZIP (case-insensitive)", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "GZIP")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns gzip when gzip is among multiple encodings", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "deflate, gzip, br")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns gzip with quality value", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "gzip;q=1.0")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns identity for identity encoding", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "identity")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("returns identity for wildcard encoding", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "*")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("falls back to identity for unsupported encoding only", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "br")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("falls back to identity when only unsupported encodings", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "deflate, br")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("selects gzip when it has highest quality", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "br;q=0.5, gzip;q=1.0, deflate;q=0.8")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("selects gzip even with lower quality when others unsupported", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "br;q=1.0, gzip;q=0.5")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding)
+	})
+
+	t.Run("returns identity when it has higher quality than gzip", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "gzip;q=0.5, identity;q=1.0")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("skips encoding with q=0", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "gzip;q=0, identity")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("falls back to identity when gzip rejected and no other supported", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "gzip;q=0, br")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("returns error when identity explicitly rejected and no supported encoding", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "br, identity;q=0")
+
+		_, err := parseAcceptEncoding(req)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "no acceptable encoding found")
+	})
+
+	t.Run("returns gzip for wildcard when identity rejected", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "*, identity;q=0")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, "gzip", encoding) // wildcard with identity rejected returns supported encoding
+	})
+
+	t.Run("returns error when wildcard rejected and no explicit identity", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "*;q=0")
+
+		_, err := parseAcceptEncoding(req)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "no acceptable encoding found")
+	})
+
+	t.Run("returns identity when wildcard rejected but identity explicitly accepted", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "*;q=0, identity")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingIdentity, encoding)
+	})
+
+	t.Run("returns gzip when wildcard rejected but gzip explicitly accepted", func(t *testing.T) {
+		t.Parallel()
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "/test", nil)
+		req.Header.Set("Accept-Encoding", "*;q=0, gzip")
+
+		encoding, err := parseAcceptEncoding(req)
+		require.NoError(t, err)
+		assert.Equal(t, EncodingGzip, encoding)
+	})
+}
+
+func TestGetDecompressedBody(t *testing.T) {
+	t.Parallel()
+
+	t.Run("returns original body when no Content-Encoding header", func(t *testing.T) {
+		t.Parallel()
+		content := []byte("test content")
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", bytes.NewReader(content))
+
+		body, err := getDecompressedBody(req)
+		require.NoError(t, err)
+		assert.Equal(t, req.Body, body, "should return original body")
+
+		data, err := io.ReadAll(body)
+		require.NoError(t, err)
+		assert.Equal(t, content, data)
+	})
+
+	t.Run("decompresses gzip body when Content-Encoding is gzip", func(t *testing.T) {
+		t.Parallel()
+		originalContent := []byte("test content to compress")
+
+		var compressed bytes.Buffer
+		gw := gzip.NewWriter(&compressed)
+		_, err := gw.Write(originalContent)
+		require.NoError(t, err)
+		err = gw.Close()
+		require.NoError(t, err)
+
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", bytes.NewReader(compressed.Bytes()))
+		req.Header.Set("Content-Encoding", "gzip")
+
+		body, err := getDecompressedBody(req)
+		require.NoError(t, err)
+		defer body.Close()
+
+		assert.NotEqual(t, req.Body, body, "should return a new gzip reader")
+
+		data, err := io.ReadAll(body)
+		require.NoError(t, err)
+		assert.Equal(t, originalContent, data)
+	})
+
+	t.Run("returns error for invalid gzip data", func(t *testing.T) {
+		t.Parallel()
+		invalidGzip := []byte("this is not gzip data")
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", bytes.NewReader(invalidGzip))
+		req.Header.Set("Content-Encoding", "gzip")
+
+		_, err := getDecompressedBody(req)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "failed to create gzip reader")
+	})
+
+	t.Run("returns original body for identity encoding", func(t *testing.T) {
+		t.Parallel()
+		content := []byte("test content")
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", bytes.NewReader(content))
+		req.Header.Set("Content-Encoding", "identity")
+
+		body, err := getDecompressedBody(req)
+		require.NoError(t, err)
+		assert.Equal(t, req.Body, body, "should return original body")
+
+		data, err := io.ReadAll(body)
+		require.NoError(t, err)
+		assert.Equal(t, content, data)
+	})
+
+	t.Run("returns error for unsupported encoding", func(t *testing.T) {
+		t.Parallel()
+		content := []byte("test content")
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", bytes.NewReader(content))
+		req.Header.Set("Content-Encoding", "br")
+
+		_, err := getDecompressedBody(req)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "unsupported Content-Encoding")
+	})
+
+	t.Run("handles gzip with quality value", func(t *testing.T) {
+		t.Parallel()
+		originalContent := []byte("test content to compress")
+
+		var compressed bytes.Buffer
+		gw := gzip.NewWriter(&compressed)
+		_, err := gw.Write(originalContent)
+		require.NoError(t, err)
+		err = gw.Close()
+		require.NoError(t, err)
+
+		req, _ := http.NewRequestWithContext(t.Context(), http.MethodPost, "/test", bytes.NewReader(compressed.Bytes()))
+		req.Header.Set("Content-Encoding", "gzip;q=1.0")
+
+		body, err := getDecompressedBody(req)
+		require.NoError(t, err)
+		defer body.Close()
+
+		data, err := io.ReadAll(body)
+		require.NoError(t, err)
+		assert.Equal(t, originalContent, data)
+	})
+}