fix: migrate proto to external repo, fix all test failures

- .gitignore: remove stale internal/gen/ entries
- cmd/proto-compat-check: use go mod download instead of local proto/ path
- internal/admin: fix contract test path, add api-surface.json, fix pagination expectations
- internal/controller: add TLS test data certificates
- internal/infrastructure: add client.Reader to NewWithOptions, use InfrastructureListeners in gatewayServicePorts
- internal/status: add ListenerSet parent index to scope HTTPRoute queries
- internal/translator: add TLS test data certificates

Author: mahmut-Abi

.gitignore

@@ -5,12 +5,7 @@ dist/
 .vscode/
 coverage/
 tmp/
-internal/gen/
-!internal/gen/
-!internal/gen/gateway/
-!internal/gen/gateway/control/
-!internal/gen/gateway/control/v1/
-!internal/gen/gateway/control/v1/*.go
+
 .DS_Store
 build_push.sh
 .worktrees/

cmd/proto-compat-check/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -15,67 +16,63 @@ import (
 	"github.com/nantian-gw/gateway/internal/protocompat"
 )
 
-const protoPath = "proto/gateway/control/v1/control.proto"
+const (
+	protoModule  = "github.com/nantian-gw/proto"
+	protoRelPath = "gateway/control/v1/control.proto"
+)
 
 func main() {
 	var (
-		repoRootFlag = flag.String("repo-root", "", "repository root directory")
-		baseRefFlag  = flag.String("base-ref", "", "git ref to compare against")
+		baseVersionFlag = flag.String("base-version", "", "proto module version to compare against (required)")
+		repoRootFlag    = flag.String("repo-root", "", "gateway repository root directory")
 	)
 	flag.Parse()
 
+	baseVersion := strings.TrimSpace(*baseVersionFlag)
+	if baseVersion == "" {
+		fatalf("--base-version is required (e.g. v0.1.0 or a pseudo-version)")
+	}
+
 	repoRoot, err := resolveRepoRoot(*repoRootFlag)
 	if err != nil {
 		fatalf("resolve repo root: %v", err)
 	}
 
-	baseRef := strings.TrimSpace(*baseRefFlag)
-	if baseRef == "" {
-		baseRef, err = detectBaseRef(repoRoot)
-		if err != nil {
-			fatalf("detect base ref: %v", err)
-		}
-	}
-
-	tempDir, err := os.MkdirTemp("", "aeg-proto-compat-*")
+	currentProtoDir, err := moduleDir(repoRoot, protoModule+"@latest")
 	if err != nil {
-		fatalf("create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	baseProtoRoot := filepath.Join(tempDir, "base-proto")
-	baseProtoPath := filepath.Join(baseProtoRoot, "gateway/control/v1/control.proto")
-	if err := os.MkdirAll(filepath.Dir(baseProtoPath), 0o755); err != nil {
-		fatalf("prepare temp proto tree: %v", err)
+		fatalf("resolve current proto module: %v", err)
 	}
 
-	baseProto, err := gitShow(repoRoot, fmt.Sprintf("%s:%s", baseRef, protoPath))
+	baseProtoDir, err := moduleDir(repoRoot, protoModule+"@"+baseVersion)
 	if err != nil {
-		fatalf("load base proto from %s: %v", baseRef, err)
-	}
-	if err := os.WriteFile(baseProtoPath, baseProto, 0o644); err != nil {
-		fatalf("write temp base proto: %v", err)
+		fatalf("resolve base proto module (%s): %v", baseVersion, err)
 	}
 
 	protocInclude, err := findProtocInclude()
 	if err != nil {
 		fatalf("locate protoc include: %v", err)
 	}
 
+	tempDir, err := os.MkdirTemp("", "proto-compat-*")
+	if err != nil {
+		fatalf("create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
 	currentDescriptorPath := filepath.Join(tempDir, "current.pb")
 	baseDescriptorPath := filepath.Join(tempDir, "base.pb")
 
 	if err := compileDescriptor(
-		filepath.Join(repoRoot, "proto"),
-		filepath.Join(repoRoot, protoPath),
+		currentProtoDir,
+		filepath.Join(currentProtoDir, protoRelPath),
 		protocInclude,
 		currentDescriptorPath,
 	); err != nil {
 		fatalf("compile current proto descriptor: %v", err)
 	}
 	if err := compileDescriptor(
-		baseProtoRoot,
-		filepath.Join(baseProtoRoot, "gateway/control/v1/control.proto"),
+		baseProtoDir,
+		filepath.Join(baseProtoDir, protoRelPath),
 		protocInclude,
 		baseDescriptorPath,
 	); err != nil {
@@ -101,102 +98,75 @@ func main() {
 	}
 
 	result := protocompat.CompareFiles(baseFile, currentFile)
-
-	fmt.Printf("[proto-compat] base ref: %s\n", baseRef)
-	fmt.Printf("[proto-compat] target: %s\n", protoPath)
-	for _, warning := range result.Warnings {
-		fmt.Printf("[proto-compat] warning: %s: %s\n", warning.Path, warning.Message)
-	}
 	if !result.OK() {
-		for _, finding := range result.Errors {
-			fmt.Printf("[proto-compat] error: %s: %s\n", finding.Path, finding.Message)
+		fmt.Println("Backward-incompatible changes detected:")
+		for _, f := range result.Errors {
+			fmt.Printf("  ERROR: %s: %s\n", f.Path, f.Message)
 		}
-		os.Exit(1)
 	}
-
-	fmt.Println("[proto-compat] compatibility check passed")
-}
-
-func resolveRepoRoot(explicit string) (string, error) {
-	if strings.TrimSpace(explicit) != "" {
-		return filepath.Abs(explicit)
+	for _, f := range result.Warnings {
+		fmt.Printf("  WARNING: %s: %s\n", f.Path, f.Message)
 	}
 
-	current, err := os.Getwd()
-	if err != nil {
-		return "", err
-	}
-
-	for {
-		if _, statErr := os.Stat(filepath.Join(current, ".git")); statErr == nil {
-			return current, nil
-		}
-		parent := filepath.Dir(current)
-		if parent == current {
-			return "", errors.New("could not find .git directory from current working directory")
-		}
-		current = parent
+	if !result.OK() {
+		os.Exit(1)
 	}
+	fmt.Println("Proto is backward compatible.")
 }
 
-func detectBaseRef(repoRoot string) (string, error) {
-	if tag, err := gitOutput(repoRoot, "describe", "--tags", "--abbrev=0", "--match", "v*"); err == nil {
-		return strings.TrimSpace(tag), nil
-	}
+type moduleInfo struct {
+	Dir string `json:"Dir"`
+}
 
-	headParent, err := gitOutput(repoRoot, "rev-parse", "--verify", "HEAD^")
+func moduleDir(repoRoot, moduleQuery string) (string, error) {
+	download := exec.Command("go", "mod", "download", "-json", moduleQuery)
+	download.Dir = repoRoot
+	download.Stderr = os.Stderr
+	downloadOutput, err := download.Output()
 	if err != nil {
-		return "", errors.New("no release tag and no parent commit available for proto compatibility check")
+		return "", fmt.Errorf("go mod download %s: %w", moduleQuery, err)
 	}
-	return strings.TrimSpace(headParent), nil
-}
 
-func gitShow(repoRoot, object string) ([]byte, error) {
-	cmd := exec.Command("git", "-C", repoRoot, "show", object)
-	output, err := cmd.Output()
-	if err != nil {
-		return nil, err
+	var info moduleInfo
+	if err := json.Unmarshal(downloadOutput, &info); err != nil {
+		return "", fmt.Errorf("parse go mod download output: %w", err)
+	}
+	if info.Dir == "" {
+		return "", fmt.Errorf("module %s: Dir is empty", moduleQuery)
 	}
-	return output, nil
+	return info.Dir, nil
 }
 
-func gitOutput(repoRoot string, args ...string) (string, error) {
-	cmd := exec.Command("git", append([]string{"-C", repoRoot}, args...)...)
-	output, err := cmd.Output()
+func resolveRepoRoot(flag string) (string, error) {
+	if flag != "" {
+		return flag, nil
+	}
+	cmd := exec.Command("git", "rev-parse", "--show-toplevel")
+	cmd.Stderr = os.Stderr
+	out, err := cmd.Output()
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("find git root: %w", err)
 	}
-	return string(output), nil
+	return strings.TrimSpace(string(out)), nil
 }
 
 func findProtocInclude() (string, error) {
-	if include := strings.TrimSpace(os.Getenv("PROTOC_INCLUDE")); include != "" {
-		if wellKnownTypeExists(include) {
-			return include, nil
-		}
-		return "", fmt.Errorf("PROTOC_INCLUDE does not contain google/protobuf well-known types: %s", include)
+	if env := os.Getenv("PROTOC_INCLUDE"); env != "" {
+		return env, nil
 	}
 
-	protocPath, err := exec.LookPath("protoc")
-	if err != nil {
-		return "", errors.New("protoc not found in PATH")
-	}
-	protocRoot := filepath.Dir(filepath.Dir(protocPath))
-
-	candidates := []string{
-		filepath.Join(protocRoot, "include"),
+	searchRoots := []string{
 		"/usr/local/include",
 		"/usr/include",
-		"/opt/homebrew/include",
-		"/opt/local/include",
+		filepath.Join(os.Getenv("HOME"), ".local/include"),
 	}
-	for _, candidate := range candidates {
-		if wellKnownTypeExists(candidate) {
-			return candidate, nil
+
+	for _, root := range searchRoots {
+		if wellKnownTypeExists(root) {
+			return root, nil
 		}
 	}
 
-	searchRoots := []string{"/usr/local", "/usr", "/opt/homebrew", "/opt/local"}
 	for _, root := range searchRoots {
 		candidate, err := findWellKnownType(root)
 		if err != nil {
@@ -277,4 +247,4 @@ func findDescriptorFile(set *descriptorpb.FileDescriptorSet, name string) (*desc
 func fatalf(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, "[proto-compat] "+format+"\n", args...)
 	os.Exit(1)
-}
+}