enhance(upstream): proxy target parsing from multiple configs

Author: 0xJacky

internal/upstream/proxy_parser.go renamed to internal/upstream/upstream_parser.go

@@ -25,20 +25,42 @@ type UpstreamContext struct {
 }
 
 // ParseProxyTargetsFromRawContent parses proxy targets from raw nginx configuration content
+// It performs two passes to handle cases where proxy_pass/grpc_pass directives appear before upstream definitions
+//
+// Problem: In nginx configuration files, the order of directives can vary. A proxy_pass directive
+// might reference an upstream block that is defined later in the file. Without two-pass parsing,
+// the parser would incorrectly treat such proxy_pass directives as direct targets instead of
+// upstream references.
+//
+// Solution:
+//  1. First pass: Scan the entire content to collect all upstream names
+//  2. Second pass: Parse upstream blocks and proxy_pass/grpc_pass directives with full knowledge
+//     of all upstream names, allowing proper identification of upstream references regardless of order
 func ParseProxyTargetsFromRawContent(content string) []ProxyTarget {
 	var targets []ProxyTarget
 
-	// First, collect all upstream names and their contexts
+	// First pass: collect all upstream names to handle forward references
+	// This ensures we know about all upstreams before processing proxy_pass directives
 	upstreamNames := make(map[string]bool)
-	upstreamContexts := make(map[string]*UpstreamContext)
-	upstreamRegex := regexp.MustCompile(`(?s)upstream\s+([^\s]+)\s*\{([^}]+)\}`)
+	upstreamRegex := regexp.MustCompile(`(?s)upstream\s+([^\s]+)\s*\{`)
 	upstreamMatches := upstreamRegex.FindAllStringSubmatch(content, -1)
 
-	// Parse upstream blocks and collect upstream names
 	for _, match := range upstreamMatches {
-		if len(match) >= 3 {
+		if len(match) >= 2 {
 			upstreamName := match[1]
 			upstreamNames[upstreamName] = true
+		}
+	}
+
+	// Second pass: parse upstream blocks with full context and collect upstream names
+	upstreamContexts := make(map[string]*UpstreamContext)
+	upstreamFullRegex := regexp.MustCompile(`(?s)upstream\s+([^\s]+)\s*\{([^}]+)\}`)
+	upstreamFullMatches := upstreamFullRegex.FindAllStringSubmatch(content, -1)
+
+	// Parse upstream blocks and collect upstream names
+	for _, match := range upstreamFullMatches {
+		if len(match) >= 3 {
+			upstreamName := match[1]
 			upstreamContent := match[2]
 
 			// Create upstream context

internal/upstream/proxy_parser_test.go renamed to internal/upstream/upstream_parser_test.go

@@ -753,3 +753,172 @@ func TestGrpcPassPortDefaults(t *testing.T) {
 		})
 	}
 }
+
+func TestParseProxyTargetsWithForwardReferences(t *testing.T) {
+	// Test case where proxy_pass appears before upstream definition
+	config := `server {
+    listen 80;
+    server_name example.com;
+
+    # This proxy_pass appears BEFORE the upstream definition
+    location /api/ {
+        proxy_pass http://api-backend/;
+    }
+
+    location /grpc/ {
+        grpc_pass grpc://grpc-backend;
+    }
+
+    # Direct proxy_pass that should be included
+    location /external/ {
+        proxy_pass http://external.example.com:8080/;
+    }
+}
+
+# Upstream definitions appear AFTER the proxy_pass directives
+upstream api-backend {
+    server 127.0.0.1:9000;
+    server 127.0.0.1:9001;
+}
+
+upstream grpc-backend {
+    server 127.0.0.1:9090;
+    server 127.0.0.1:9091;
+}`
+
+	targets := ParseProxyTargetsFromRawContent(config)
+
+	// Print actual results for debugging
+	t.Logf("Found %d targets:", len(targets))
+	for i, target := range targets {
+		t.Logf("Target %d: Host=%s, Port=%s, Type=%s", i+1, target.Host, target.Port, target.Type)
+	}
+
+	// Expected targets:
+	// - 4 upstream servers (2 from api-backend, 2 from grpc-backend)
+	// - 1 direct proxy_pass target (external.example.com:8080)
+	// - proxy_pass to api-backend and grpc_pass to grpc-backend should be ignored since they reference upstreams
+	expectedTargets := []ProxyTarget{
+		{Host: "127.0.0.1", Port: "9000", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "9001", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "9090", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "9091", Type: "upstream"},
+		{Host: "external.example.com", Port: "8080", Type: "proxy_pass"},
+	}
+
+	if len(targets) != len(expectedTargets) {
+		t.Errorf("Expected %d targets, got %d", len(expectedTargets), len(targets))
+		return
+	}
+
+	// Create a map for easier comparison
+	targetMap := make(map[string]ProxyTarget)
+	for _, target := range targets {
+		key := target.Host + ":" + target.Port + ":" + target.Type
+		targetMap[key] = target
+	}
+
+	for _, expected := range expectedTargets {
+		key := expected.Host + ":" + expected.Port + ":" + expected.Type
+		if _, found := targetMap[key]; !found {
+			t.Errorf("Expected target not found: %+v", expected)
+		}
+	}
+}
+
+func TestParseProxyTargetsWithMixedOrderReferences(t *testing.T) {
+	// Test case with mixed order: some proxy_pass before upstream, some after
+	config := `# First server block with forward references
+server {
+    listen 80;
+    server_name app1.example.com;
+
+    # These proxy_pass directives appear BEFORE upstream definitions
+    location /api/ {
+        proxy_pass http://api-backend/;
+    }
+
+    location /grpc/ {
+        grpc_pass grpc://grpc-backend;
+    }
+}
+
+# First upstream definition
+upstream api-backend {
+    server 127.0.0.1:9000;
+    server 127.0.0.1:9001;
+}
+
+# Second server block with backward references
+server {
+    listen 443 ssl;
+    server_name app2.example.com;
+
+    # These proxy_pass directives appear AFTER the first upstream definition
+    # but BEFORE the second upstream definition
+    location /api/ {
+        proxy_pass https://api-backend/;  # References already defined upstream
+    }
+
+    location /cache/ {
+        proxy_pass http://cache-backend/;  # Forward reference to upcoming upstream
+    }
+
+    # Direct proxy_pass that should be included
+    location /external/ {
+        proxy_pass https://external.example.com:8443/;
+    }
+}
+
+# Second upstream definition
+upstream cache-backend {
+    server 127.0.0.1:6379;
+    server 127.0.0.1:6380;
+}
+
+upstream grpc-backend {
+    server 127.0.0.1:9090;
+    server 127.0.0.1:9091;
+}`
+
+	targets := ParseProxyTargetsFromRawContent(config)
+
+	// Print actual results for debugging
+	t.Logf("Found %d targets:", len(targets))
+	for i, target := range targets {
+		t.Logf("Target %d: Host=%s, Port=%s, Type=%s", i+1, target.Host, target.Port, target.Type)
+	}
+
+	// Expected targets:
+	// - 6 upstream servers (2 from api-backend, 2 from cache-backend, 2 from grpc-backend)
+	// - 1 direct proxy_pass target (external.example.com:8443)
+	// - All proxy_pass/grpc_pass to upstreams should be ignored
+	expectedTargets := []ProxyTarget{
+		{Host: "127.0.0.1", Port: "9000", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "9001", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "6379", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "6380", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "9090", Type: "upstream"},
+		{Host: "127.0.0.1", Port: "9091", Type: "upstream"},
+		{Host: "external.example.com", Port: "8443", Type: "proxy_pass"},
+	}
+
+	if len(targets) != len(expectedTargets) {
+		t.Errorf("Expected %d targets, got %d", len(expectedTargets), len(targets))
+		return
+	}
+
+	// Create a map for easier comparison
+	targetMap := make(map[string]ProxyTarget)
+	for _, target := range targets {
+		key := target.Host + ":" + target.Port + ":" + target.Type
+		targetMap[key] = target
+	}
+
+	for _, expected := range expectedTargets {
+		key := expected.Host + ":" + expected.Port + ":" + expected.Type
+		if _, found := targetMap[key]; !found {
+			t.Errorf("Expected target not found: %+v", expected)
+		}
+	}
+}