refactor(sidecarassets): rename internal/sidecar to internal/sidecarassets

internal/sidecarassets/embed.go

@@ -0,0 +1,48 @@
+package sidecarassets
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// EmbeddedSize returns the size in bytes of the embedded JAR.
+func EmbeddedSize() int { return len(embeddedJAR) }
+
+// EmbeddedSHA256 returns the hex-encoded SHA-256 of the embedded JAR.
+func EmbeddedSHA256() string {
+	sum := sha256.Sum256(embeddedJAR)
+	return hex.EncodeToString(sum[:])
+}
+
+// Extract writes the embedded JAR to a deterministic path inside dir,
+// alongside a .sha256 file. If the destination already exists with a
+// matching checksum, no rewrite happens. Returns the JAR path.
+func Extract(dir string) (string, error) {
+	if len(embeddedJAR) == 0 {
+		return "", errors.New("sidecar: binary built without -tags withsidecar; rebuild with `make sanderling`")
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return "", fmt.Errorf("mkdir %s: %w", dir, err)
+	}
+	jarPath := filepath.Join(dir, "sanderling-sidecar.jar")
+	checksumPath := jarPath + ".sha256"
+	checksum := EmbeddedSHA256()
+
+	if existing, err := os.ReadFile(checksumPath); err == nil && string(existing) == checksum {
+		if _, err := os.Stat(jarPath); err == nil {
+			return jarPath, nil
+		}
+	}
+
+	if err := os.WriteFile(jarPath, embeddedJAR, 0o644); err != nil {
+		return "", fmt.Errorf("write %s: %w", jarPath, err)
+	}
+	if err := os.WriteFile(checksumPath, []byte(checksum), 0o644); err != nil {
+		return "", fmt.Errorf("write checksum: %w", err)
+	}
+	return jarPath, nil
+}

internal/sidecarassets/embed_real.go

@@ -0,0 +1,12 @@
+//go:build withsidecar
+
+package sidecarassets
+
+import _ "embed"
+
+//go:embed assets/sidecar-all.jar
+var embeddedJAR []byte
+
+// IsPlaceholder reports whether the binary was built without the real
+// sidecar JAR embedded. -tags withsidecar builds always return false.
+func IsPlaceholder() bool { return false }

internal/sidecarassets/embed_stub.go

@@ -0,0 +1,10 @@
+//go:build !withsidecar
+
+package sidecarassets
+
+var embeddedJAR []byte
+
+// IsPlaceholder reports whether the binary was built without the real
+// sidecar JAR embedded. Build with `make sanderling` (which passes
+// -tags withsidecar) to embed the real fat JAR.
+func IsPlaceholder() bool { return true }

internal/sidecarassets/embed_withsidecar_test.go

@@ -0,0 +1,90 @@
+//go:build withsidecar
+
+package sidecarassets
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestEmbeddedNonZero(t *testing.T) {
+	if EmbeddedSize() == 0 {
+		t.Errorf("expected embedded JAR to be non-empty")
+	}
+	if IsPlaceholder() {
+		t.Errorf("withsidecar build should not be a placeholder")
+	}
+}
+
+func TestExtract_WritesJARAndChecksum(t *testing.T) {
+	directory := t.TempDir()
+	path, err := Extract(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if path != filepath.Join(directory, "sanderling-sidecar.jar") {
+		t.Errorf("unexpected path: %s", path)
+	}
+	body, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if EmbeddedSize() != len(body) {
+		t.Errorf("size mismatch: embedded=%d, written=%d", EmbeddedSize(), len(body))
+	}
+	sum := sha256.Sum256(body)
+	if hex.EncodeToString(sum[:]) != EmbeddedSHA256() {
+		t.Errorf("hash mismatch")
+	}
+	checksum, err := os.ReadFile(path + ".sha256")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(checksum) != EmbeddedSHA256() {
+		t.Errorf("checksum file content wrong: %q", checksum)
+	}
+}
+
+func TestExtract_ReusesIdenticalFile(t *testing.T) {
+	directory := t.TempDir()
+	path, err := Extract(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	originalStat, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	originalModTime := originalStat.ModTime()
+
+	if _, err := Extract(directory); err != nil {
+		t.Fatal(err)
+	}
+	secondStat, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !secondStat.ModTime().Equal(originalModTime) {
+		t.Errorf("second extract should not have rewritten the file")
+	}
+}
+
+func TestExtract_RewritesIfChecksumMissing(t *testing.T) {
+	directory := t.TempDir()
+	path, err := Extract(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Remove(path + ".sha256"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Extract(directory); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(path + ".sha256"); err != nil {
+		t.Errorf("checksum should have been written: %v", err)
+	}
+}