fix: Use a mixed of virtual and path styles within a single subdomain (#7357)

* fix: Use a mixed of virtual and path styles within a single subdomain

* address comments

* add tests

---------

Co-authored-by: chrislu <chris.lu@gmail.com>
Co-authored-by: Chris Lu <chrislusf@users.noreply.github.com>

1 files changed, 242 insertions, 0 deletions

diff --git a/weed/s3api/s3api_domain_test.go b/weed/s3api/s3api_domain_test.go
new file mode 100644
index 000000000..369606f79
--- /dev/null
+++ b/weed/s3api/s3api_domain_test.go
@@ -0,0 +1,242 @@
+package s3api
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestClassifyDomainNames tests the domain classification logic for mixed virtual-host and path-style S3 access
+// This test validates the fix for issue #7356
+func TestClassifyDomainNames(t *testing.T) {
+	tests := []struct {
+		name                string
+		domainNames         []string
+		expectedPathStyle   []string
+		expectedVirtualHost []string
+		description         string
+	}{
+		{
+			name:                "Mixed path-style and virtual-host with single parent",
+			domainNames:         []string{"s3.mydomain.com", "develop.s3.mydomain.com"},
+			expectedPathStyle:   []string{"develop.s3.mydomain.com"},
+			expectedVirtualHost: []string{"s3.mydomain.com"},
+			description:         "develop.s3.mydomain.com is path-style because s3.mydomain.com is in the list",
+		},
+		{
+			name:                "Multiple subdomains with same parent",
+			domainNames:         []string{"s3.mydomain.com", "develop.s3.mydomain.com", "staging.s3.mydomain.com"},
+			expectedPathStyle:   []string{"develop.s3.mydomain.com", "staging.s3.mydomain.com"},
+			expectedVirtualHost: []string{"s3.mydomain.com"},
+			description:         "Multiple subdomains can be path-style when parent is in the list",
+		},
+		{
+			name:                "Subdomain without parent in list",
+			domainNames:         []string{"develop.s3.mydomain.com"},
+			expectedPathStyle:   []string{},
+			expectedVirtualHost: []string{"develop.s3.mydomain.com"},
+			description:         "Subdomain becomes virtual-host when parent is not in the list",
+		},
+		{
+			name:                "Only top-level domain",
+			domainNames:         []string{"s3.mydomain.com"},
+			expectedPathStyle:   []string{},
+			expectedVirtualHost: []string{"s3.mydomain.com"},
+			description:         "Top-level domain is always virtual-host style",
+		},
+		{
+			name:                "Multiple independent domains",
+			domainNames:         []string{"s3.domain1.com", "s3.domain2.com"},
+			expectedPathStyle:   []string{},
+			expectedVirtualHost: []string{"s3.domain1.com", "s3.domain2.com"},
+			description:         "Independent domains without parent relationships are all virtual-host",
+		},
+		{
+			name:                "Mixed with nested levels",
+			domainNames:         []string{"example.com", "s3.example.com", "api.s3.example.com"},
+			expectedPathStyle:   []string{"s3.example.com", "api.s3.example.com"},
+			expectedVirtualHost: []string{"example.com"},
+			description:         "Both s3.example.com and api.s3.example.com are path-style because their immediate parents are in the list",
+		},
+		{
+			name:                "Domain without dot",
+			domainNames:         []string{"localhost"},
+			expectedPathStyle:   []string{},
+			expectedVirtualHost: []string{"localhost"},
+			description:         "Domain without dot (no subdomain) is virtual-host style",
+		},
+		{
+			name:                "Empty list",
+			domainNames:         []string{},
+			expectedPathStyle:   []string{},
+			expectedVirtualHost: []string{},
+			description:         "Empty domain list returns empty results",
+		},
+		{
+			name:                "Mixed localhost and domain",
+			domainNames:         []string{"localhost", "s3.localhost"},
+			expectedPathStyle:   []string{"s3.localhost"},
+			expectedVirtualHost: []string{"localhost"},
+			description:         "s3.localhost is path-style when localhost is in the list",
+		},
+		{
+			name:                "Three-level subdomain hierarchy",
+			domainNames:         []string{"example.com", "s3.example.com", "dev.s3.example.com", "api.dev.s3.example.com"},
+			expectedPathStyle:   []string{"s3.example.com", "dev.s3.example.com", "api.dev.s3.example.com"},
+			expectedVirtualHost: []string{"example.com"},
+			description:         "Each level that has its parent in the list becomes path-style",
+		},
+		{
+			name:                "Real-world example from issue #7356",
+			domainNames:         []string{"s3.mydomain.com", "develop.s3.mydomain.com", "staging.s3.mydomain.com", "prod.s3.mydomain.com"},
+			expectedPathStyle:   []string{"develop.s3.mydomain.com", "staging.s3.mydomain.com", "prod.s3.mydomain.com"},
+			expectedVirtualHost: []string{"s3.mydomain.com"},
+			description:         "Real-world scenario with multiple environment subdomains",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pathStyle, virtualHost := classifyDomainNames(tt.domainNames)
+
+			assert.ElementsMatch(t, tt.expectedPathStyle, pathStyle,
+				"Path-style domains mismatch: %s", tt.description)
+			assert.ElementsMatch(t, tt.expectedVirtualHost, virtualHost,
+				"Virtual-host domains mismatch: %s", tt.description)
+		})
+	}
+}
+
+// TestClassifyDomainNamesOrder tests that the function maintains consistent behavior regardless of input order
+func TestClassifyDomainNamesOrder(t *testing.T) {
+	tests := []struct {
+		name        string
+		domainNames []string
+		description string
+	}{
+		{
+			name:        "Parent before child",
+			domainNames: []string{"s3.mydomain.com", "develop.s3.mydomain.com"},
+			description: "Parent domain listed before child",
+		},
+		{
+			name:        "Child before parent",
+			domainNames: []string{"develop.s3.mydomain.com", "s3.mydomain.com"},
+			description: "Child domain listed before parent",
+		},
+		{
+			name:        "Mixed order with multiple children",
+			domainNames: []string{"staging.s3.mydomain.com", "s3.mydomain.com", "develop.s3.mydomain.com"},
+			description: "Children and parent in mixed order",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pathStyle, virtualHost := classifyDomainNames(tt.domainNames)
+
+			// Regardless of order, the result should be consistent
+			// Parent should be virtual-host
+			assert.Contains(t, virtualHost, "s3.mydomain.com",
+				"Parent should always be virtual-host: %s", tt.description)
+
+			// Children should be path-style
+			if len(tt.domainNames) > 1 {
+				assert.Greater(t, len(pathStyle), 0,
+					"Should have at least one path-style domain: %s", tt.description)
+			}
+		})
+	}
+}
+
+// TestClassifyDomainNamesEdgeCases tests edge cases and special scenarios
+func TestClassifyDomainNamesEdgeCases(t *testing.T) {
+	t.Run("Duplicate domains", func(t *testing.T) {
+		domainNames := []string{"s3.example.com", "s3.example.com", "api.s3.example.com"}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		// Even with duplicates, classification should work
+		assert.Contains(t, pathStyle, "api.s3.example.com")
+		assert.Contains(t, virtualHost, "s3.example.com")
+	})
+
+	t.Run("Very long domain name", func(t *testing.T) {
+		domainNames := []string{"very.long.subdomain.hierarchy.example.com", "long.subdomain.hierarchy.example.com"}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		// Should handle long domains correctly
+		assert.Contains(t, pathStyle, "very.long.subdomain.hierarchy.example.com")
+		assert.Contains(t, virtualHost, "long.subdomain.hierarchy.example.com")
+	})
+
+	t.Run("Similar but different domains", func(t *testing.T) {
+		domainNames := []string{"s3.example.com", "s3.examples.com", "api.s3.example.com"}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		// api.s3.example.com should be path-style (parent s3.example.com is in list)
+		// s3.examples.com should be virtual-host (different domain)
+		assert.Contains(t, pathStyle, "api.s3.example.com")
+		assert.Contains(t, virtualHost, "s3.example.com")
+		assert.Contains(t, virtualHost, "s3.examples.com")
+	})
+
+	t.Run("IP address as domain", func(t *testing.T) {
+		domainNames := []string{"127.0.0.1"}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		// IP address should be treated as virtual-host
+		assert.Empty(t, pathStyle)
+		assert.Contains(t, virtualHost, "127.0.0.1")
+	})
+}
+
+// TestClassifyDomainNamesUseCases tests real-world use cases
+func TestClassifyDomainNamesUseCases(t *testing.T) {
+	t.Run("Issue #7356 - Prometheus blackbox exporter scenario", func(t *testing.T) {
+		// From the PR: allow both path-style and virtual-host within same subdomain
+		// curl -H 'Host: develop.s3.mydomain.com' http://127.0.0.1:8000/prometheus-blackbox-exporter/status.html
+		// curl -H 'Host: prometheus-blackbox-exporter.s3.mydomain.com' http://127.0.0.1:8000/status.html
+
+		domainNames := []string{"s3.mydomain.com", "develop.s3.mydomain.com"}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		// develop.s3.mydomain.com should be path-style for /bucket/object access
+		assert.Contains(t, pathStyle, "develop.s3.mydomain.com",
+			"develop subdomain should be path-style")
+
+		// s3.mydomain.com should be virtual-host for bucket.s3.mydomain.com access
+		assert.Contains(t, virtualHost, "s3.mydomain.com",
+			"parent domain should be virtual-host")
+	})
+
+	t.Run("Multi-environment setup", func(t *testing.T) {
+		// Common scenario: different environments using different access styles
+		domainNames := []string{
+			"s3.company.com",         // Production - virtual-host style
+			"dev.s3.company.com",     // Development - path-style
+			"test.s3.company.com",    // Testing - path-style
+			"staging.s3.company.com", // Staging - path-style
+		}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		assert.Len(t, pathStyle, 3, "Should have 3 path-style domains")
+		assert.Len(t, virtualHost, 1, "Should have 1 virtual-host domain")
+		assert.Contains(t, virtualHost, "s3.company.com")
+	})
+
+	t.Run("Mixed production setup", func(t *testing.T) {
+		// Multiple base domains with their own subdomains
+		domainNames := []string{
+			"s3-us-east.company.com",
+			"api.s3-us-east.company.com",
+			"s3-eu-west.company.com",
+			"api.s3-eu-west.company.com",
+		}
+		pathStyle, virtualHost := classifyDomainNames(domainNames)
+
+		assert.Contains(t, pathStyle, "api.s3-us-east.company.com")
+		assert.Contains(t, pathStyle, "api.s3-eu-west.company.com")
+		assert.Contains(t, virtualHost, "s3-us-east.company.com")
+		assert.Contains(t, virtualHost, "s3-eu-west.company.com")
+	})
+}