[功能] 添加站点名称和多域名支持到代理路由，更新相关逻辑和测试

openflare_server/model/database_schema_version.go

@@ -4,7 +4,7 @@ import "time"
 
 const (
 	legacyDatabaseSchemaVersion  = 1
-	currentDatabaseSchemaVersion = 4
+	currentDatabaseSchemaVersion = 5
 	databaseSchemaVersionRowID   = 1
 )
 

openflare_server/model/main_test.go

@@ -10,6 +10,30 @@ import (
 	"gorm.io/gorm"
 )
 
+type legacyProxyRouteV4 struct {
+	ID            uint   `gorm:"primaryKey"`
+	Domain        string `gorm:"uniqueIndex;size:255;not null"`
+	OriginID      *uint  `gorm:"index"`
+	OriginURL     string `gorm:"size:2048;not null"`
+	OriginHost    string `gorm:"size:255"`
+	Upstreams     string `gorm:"type:text;not null;default:'[]'"`
+	Enabled       bool   `gorm:"not null;default:true"`
+	EnableHTTPS   bool   `gorm:"column:enable_https;not null;default:false"`
+	CertID        *uint
+	RedirectHTTP  bool   `gorm:"not null;default:false"`
+	CacheEnabled  bool   `gorm:"not null;default:false"`
+	CachePolicy   string `gorm:"size:32;not null;default:''"`
+	CacheRules    string `gorm:"type:text;not null;default:'[]'"`
+	CustomHeaders string `gorm:"type:text;not null;default:'[]'"`
+	Remark        string `gorm:"size:255"`
+	CreatedAt     time.Time
+	UpdatedAt     time.Time
+}
+
+func (legacyProxyRouteV4) TableName() string {
+	return "proxy_routes"
+}
+
 func openBareTestSQLiteDB(t *testing.T, name string) *gorm.DB {
 	t.Helper()
 
@@ -464,6 +488,78 @@ func TestMigrateOriginsSchemaBackfillsOrigins(t *testing.T) {
 	}
 }
 
+func TestEnsureDatabaseSchemaUpToDateBackfillsProxyRouteSiteFields(t *testing.T) {
+	db := openBareTestSQLiteDB(t, "legacy-proxy-route-sites.db")
+	if err := registerSharding(db, "sqlite"); err != nil {
+		t.Fatalf("register sharding: %v", err)
+	}
+	if err := autoMigrateSchemaMetadata(db); err != nil {
+		t.Fatalf("auto migrate schema metadata: %v", err)
+	}
+
+	for _, item := range registeredModels() {
+		if _, ok := item.(*ProxyRoute); ok {
+			continue
+		}
+		if err := db.AutoMigrate(item); err != nil {
+			t.Fatalf("auto migrate supporting table: %v", err)
+		}
+	}
+	if err := db.AutoMigrate(&legacyProxyRouteV4{}); err != nil {
+		t.Fatalf("auto migrate legacy proxy_routes: %v", err)
+	}
+
+	now := time.Now().UTC()
+	if err := db.Create(&legacyProxyRouteV4{
+		Domain:        "app.example.com",
+		OriginURL:     "https://origin-a.internal:8443",
+		Upstreams:     `["https://origin-a.internal:8443","https://origin-b.internal:8443"]`,
+		Enabled:       true,
+		EnableHTTPS:   false,
+		RedirectHTTP:  false,
+		CacheEnabled:  false,
+		CachePolicy:   "",
+		CacheRules:    `[]`,
+		CustomHeaders: `[]`,
+		CreatedAt:     now,
+		UpdatedAt:     now,
+	}).Error; err != nil {
+		t.Fatalf("seed legacy proxy route: %v", err)
+	}
+	if err := saveDatabaseSchemaVersion(db, 4); err != nil {
+		t.Fatalf("save schema version: %v", err)
+	}
+
+	previousDB := DB
+	DB = db
+	t.Cleanup(func() {
+		DB = previousDB
+	})
+
+	if err := ensureDatabaseSchemaUpToDate(db, "sqlite"); err != nil {
+		t.Fatalf("ensureDatabaseSchemaUpToDate: %v", err)
+	}
+
+	var route ProxyRoute
+	if err := db.First(&route).Error; err != nil {
+		t.Fatalf("query migrated proxy route: %v", err)
+	}
+	if route.SiteName != "app.example.com" {
+		t.Fatalf("unexpected site_name after migration: %s", route.SiteName)
+	}
+	if route.Domain != "app.example.com" {
+		t.Fatalf("unexpected domain mirror after migration: %s", route.Domain)
+	}
+
+	var domains []string
+	if err := json.Unmarshal([]byte(route.Domains), &domains); err != nil {
+		t.Fatalf("decode migrated domains: %v", err)
+	}
+	if len(domains) != 1 || domains[0] != "app.example.com" {
+		t.Fatalf("unexpected migrated domains: %#v", domains)
+	}
+}
+
 func TestRunDatabaseSchemaMigrationDoesNotAdvanceVersionWhenValidationFails(t *testing.T) {
 	db := openBareTestSQLiteDB(t, "failed-validation.db")
 

openflare_server/model/migrations.go

@@ -211,6 +211,179 @@ func validateDatabaseSchemaV4(db *gorm.DB, backend string) error {
 	return nil
 }
 
+func normalizeProxyRouteDomainForMigration(raw string) string {
+	return strings.ToLower(strings.TrimSpace(raw))
+}
+
+func normalizeProxyRouteSiteNameForMigration(raw string, primaryDomain string) string {
+	siteName := strings.TrimSpace(raw)
+	if siteName != "" {
+		return siteName
+	}
+	return primaryDomain
+}
+
+func decodeProxyRouteDomainsForMigration(raw string, fallbackDomain string) ([]string, error) {
+	primaryDomain := normalizeProxyRouteDomainForMigration(fallbackDomain)
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		if primaryDomain == "" {
+			return nil, fmt.Errorf("proxy route primary domain is empty")
+		}
+		return []string{primaryDomain}, nil
+	}
+
+	var domains []string
+	if err := json.Unmarshal([]byte(text), &domains); err != nil {
+		return nil, fmt.Errorf("decode proxy route domains failed: %w", err)
+	}
+
+	normalized := make([]string, 0, len(domains))
+	seen := make(map[string]struct{}, len(domains))
+	for _, domain := range domains {
+		item := normalizeProxyRouteDomainForMigration(domain)
+		if item == "" {
+			continue
+		}
+		if _, ok := seen[item]; ok {
+			continue
+		}
+		seen[item] = struct{}{}
+		normalized = append(normalized, item)
+	}
+	if len(normalized) == 0 {
+		if primaryDomain == "" {
+			return nil, fmt.Errorf("proxy route domains are empty")
+		}
+		return []string{primaryDomain}, nil
+	}
+	if primaryDomain == "" {
+		primaryDomain = normalized[0]
+	}
+	if normalized[0] != primaryDomain {
+		rest := make([]string, 0, len(normalized))
+		for _, domain := range normalized {
+			if domain == primaryDomain {
+				continue
+			}
+			rest = append(rest, domain)
+		}
+		normalized = append([]string{primaryDomain}, rest...)
+	}
+	return normalized, nil
+}
+
+func backfillProxyRouteSiteFields(db *gorm.DB) error {
+	if db == nil {
+		return fmt.Errorf("database handle is nil")
+	}
+	if !db.Migrator().HasTable(&ProxyRoute{}) {
+		return nil
+	}
+	if !db.Migrator().HasColumn(&ProxyRoute{}, "site_name") || !db.Migrator().HasColumn(&ProxyRoute{}, "domains") {
+		return nil
+	}
+
+	var routes []ProxyRoute
+	if err := db.Order("id asc").Find(&routes).Error; err != nil {
+		return fmt.Errorf("list proxy routes for site field backfill failed: %w", err)
+	}
+	for _, route := range routes {
+		domains, err := decodeProxyRouteDomainsForMigration(route.Domains, route.Domain)
+		if err != nil {
+			return fmt.Errorf("normalize proxy route %d domains failed: %w", route.ID, err)
+		}
+		domainsJSON, err := json.Marshal(domains)
+		if err != nil {
+			return fmt.Errorf("encode proxy route %d domains failed: %w", route.ID, err)
+		}
+
+		primaryDomain := domains[0]
+		siteName := normalizeProxyRouteSiteNameForMigration(route.SiteName, primaryDomain)
+		updates := make(map[string]any, 3)
+		if route.Domain != primaryDomain {
+			updates["domain"] = primaryDomain
+		}
+		if route.SiteName != siteName {
+			updates["site_name"] = siteName
+		}
+		if strings.TrimSpace(route.Domains) != string(domainsJSON) {
+			updates["domains"] = string(domainsJSON)
+		}
+		if len(updates) == 0 {
+			continue
+		}
+		if err := db.Model(&ProxyRoute{}).Where("id = ?", route.ID).Updates(updates).Error; err != nil {
+			return fmt.Errorf("update proxy route %d site fields failed: %w", route.ID, err)
+		}
+	}
+	return nil
+}
+
+func ensureProxyRouteSiteNameUniqueIndex(db *gorm.DB) error {
+	if db == nil {
+		return fmt.Errorf("database handle is nil")
+	}
+	if !db.Migrator().HasTable(&ProxyRoute{}) || !db.Migrator().HasColumn(&ProxyRoute{}, "site_name") {
+		return nil
+	}
+	return db.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_proxy_routes_site_name ON proxy_routes(site_name)`).Error
+}
+
+func validateDatabaseSchemaV5(db *gorm.DB, backend string) error {
+	if err := validateDatabaseSchemaV4(db, backend); err != nil {
+		return err
+	}
+	if !db.Migrator().HasColumn(&ProxyRoute{}, "site_name") {
+		return fmt.Errorf("column proxy_routes.site_name is missing")
+	}
+	if !db.Migrator().HasColumn(&ProxyRoute{}, "domains") {
+		return fmt.Errorf("column proxy_routes.domains is missing")
+	}
+
+	var routes []ProxyRoute
+	if err := db.Order("id asc").Find(&routes).Error; err != nil {
+		return fmt.Errorf("list proxy routes for validation failed: %w", err)
+	}
+
+	siteNames := make(map[string]uint, len(routes))
+	domainOwners := make(map[string]uint, len(routes))
+	for _, route := range routes {
+		domains, err := decodeProxyRouteDomainsForMigration(route.Domains, route.Domain)
+		if err != nil {
+			return fmt.Errorf("proxy route %d domains are invalid: %w", route.ID, err)
+		}
+		if len(domains) == 0 {
+			return fmt.Errorf("proxy route %d domains are empty", route.ID)
+		}
+		if route.Domain != domains[0] {
+			return fmt.Errorf("proxy route %d primary domain mirror is invalid", route.ID)
+		}
+
+		siteName := normalizeProxyRouteSiteNameForMigration(route.SiteName, domains[0])
+		if siteName == "" {
+			return fmt.Errorf("proxy route %d site_name is empty", route.ID)
+		}
+		if existingID, ok := siteNames[siteName]; ok && existingID != route.ID {
+			return fmt.Errorf("proxy route site_name %s is duplicated", siteName)
+		}
+		siteNames[siteName] = route.ID
+
+		localSeen := make(map[string]struct{}, len(domains))
+		for _, domain := range domains {
+			if _, ok := localSeen[domain]; ok {
+				return fmt.Errorf("proxy route %d contains duplicated domain %s", route.ID, domain)
+			}
+			localSeen[domain] = struct{}{}
+			if existingID, ok := domainOwners[domain]; ok && existingID != route.ID {
+				return fmt.Errorf("proxy route domain %s is duplicated", domain)
+			}
+			domainOwners[domain] = route.ID
+		}
+	}
+	return nil
+}
+
 func renameLegacyObservabilityShardTables(db *gorm.DB) error {
 	for _, baseTable := range shardedObservabilityBaseTables() {
 		for _, table := range observabilityShardTables(baseTable) {
@@ -549,11 +722,28 @@ func migrateV4(db *gorm.DB, backend string) error {
 	return backfillOriginsFromProxyRoutes(db)
 }
 
+// migrateV5 upgrades proxy_routes to website-level identity fields by
+// backfilling site_name and domains while keeping domain as the primary-domain
+// compatibility mirror.
+func migrateV5(db *gorm.DB, backend string) error {
+	if err := applyCurrentSchema(db, backend); err != nil {
+		return err
+	}
+	if err := backfillOriginsFromProxyRoutes(db); err != nil {
+		return err
+	}
+	if err := backfillProxyRouteSiteFields(db); err != nil {
+		return err
+	}
+	return ensureProxyRouteSiteNameUniqueIndex(db)
+}
+
 func databaseSchemaMigrations() []databaseSchemaMigration {
 	return []databaseSchemaMigration{
 		{fromVersion: 1, toVersion: 2, migrate: migrateV2, validate: validateDatabaseSchemaV2},
 		{fromVersion: 2, toVersion: 3, migrate: migrateV3, validate: validateDatabaseSchemaV3},
 		{fromVersion: 3, toVersion: 4, migrate: migrateV4, validate: validateDatabaseSchemaV4},
+		{fromVersion: 4, toVersion: 5, migrate: migrateV5, validate: validateDatabaseSchemaV5},
 	}
 }
 
@@ -618,13 +808,19 @@ func initializeFreshDatabaseSchema(db *gorm.DB, backend string) error {
 	if err := applyCurrentSchema(db, backend); err != nil {
 		return err
 	}
-	if err := backfillOriginsFromProxyRoutes(db); err != nil {
-		return err
-	}
 	if err := migrateSQLiteDataIfNeeded(db, backend); err != nil {
 		return err
 	}
-	if err := validateDatabaseSchemaV4(db, backend); err != nil {
+	if err := backfillOriginsFromProxyRoutes(db); err != nil {
+		return err
+	}
+	if err := backfillProxyRouteSiteFields(db); err != nil {
+		return err
+	}
+	if err := ensureProxyRouteSiteNameUniqueIndex(db); err != nil {
+		return err
+	}
+	if err := validateDatabaseSchemaV5(db, backend); err != nil {
 		return err
 	}
 	return saveDatabaseSchemaVersion(db, currentDatabaseSchemaVersion)

openflare_server/model/proxy_route.go

@@ -4,7 +4,9 @@ import "time"
 
 type ProxyRoute struct {
 	ID            uint      `json:"id" gorm:"primaryKey"`
+	SiteName      string    `json:"site_name" gorm:"size:255;not null;default:''"`
 	Domain        string    `json:"domain" gorm:"uniqueIndex;size:255;not null"`
+	Domains       string    `json:"domains" gorm:"type:text;not null;default:'[]'"`
 	OriginID      *uint     `json:"origin_id" gorm:"index"`
 	OriginURL     string    `json:"origin_url" gorm:"size:2048;not null"`
 	OriginHost    string    `json:"origin_host" gorm:"size:255"`
@@ -28,7 +30,7 @@ func ListProxyRoutes() (routes []*ProxyRoute, err error) {
 }
 
 func GetEnabledProxyRoutes() (routes []*ProxyRoute, err error) {
-	err = DB.Where("enabled = ?", true).Order("domain asc").Find(&routes).Error
+	err = DB.Where("enabled = ?", true).Order("site_name asc").Order("domain asc").Find(&routes).Error
 	return routes, err
 }
 
@@ -49,7 +51,9 @@ func (route *ProxyRoute) Insert() error {
 
 func (route *ProxyRoute) Update() error {
 	return DB.Model(&ProxyRoute{}).Where("id = ?", route.ID).Updates(map[string]any{
+		"site_name":      route.SiteName,
 		"domain":         route.Domain,
+		"domains":        route.Domains,
 		"origin_id":      route.OriginID,
 		"origin_url":     route.OriginURL,
 		"origin_host":    route.OriginHost,