fix

Author: everfid-ever

pkg/console/service/condition_rule.go

@@ -96,7 +96,6 @@ func updateConditionRuleUnsafe(ctx context.Context, name string, res *meshresour
 		logger.Warnf("update %s condition failed with error: %s", name, err.Error())
 		return err
 	}
-	logger.Infof("Condition route %s updated successfully", name)
 	return nil
 }
 
@@ -114,7 +113,6 @@ func CreateConditionRule(ctx context.Context, name string, res *meshresource.Con
 	})
 }
 
-// createConditionRuleUnsafe performs the actual creation without lock protection
 func createConditionRuleUnsafe(ctx context.Context, name string, res *meshresource.ConditionRouteResource) error {
 	if err := ctx.ResourceManager().Add(res); err != nil {
 		logger.Warnf("create %s condition failed with error: %s", name, err.Error())

pkg/console/service/configurator_rule.go

@@ -95,7 +95,7 @@ func DeleteConfigurator(ctx consolectx.Context, name string, mesh string) error
 
 	return lock.WithLock(ctx.AppContext(), lockKey, lockTimeout, func() error {
 		if err := ctx.ResourceManager().DeleteByKey(meshresource.DynamicConfigKind, coremodel.BuildResourceKey(mesh, name)); err != nil {
-			logger.Warnf("delete %s configurator failed with error:  %s", name, err.Error())
+			logger.Warnf("delete %s configurator failed with error: %s", name, err.Error())
 			return err
 		}
 		return nil

pkg/console/service/tag_rule.go

@@ -18,10 +18,8 @@
 package service
 
 import (
-	"fmt"
-	"time"
-
 	consolectx "github.com/apache/dubbo-admin/pkg/console/context"
+	"github.com/apache/dubbo-admin/pkg/core/lock"
 	"github.com/apache/dubbo-admin/pkg/core/logger"
 	"github.com/apache/dubbo-admin/pkg/core/manager"
 	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
@@ -41,15 +39,14 @@ func GetTagRule(ctx consolectx.Context, name string, mesh string) (*meshresource
 }
 
 func UpdateTagRule(ctx consolectx.Context, res *meshresource.TagRouteResource) error {
-	lock := ctx.LockManager()
-	if lock == nil {
+	lockMgr := ctx.LockManager()
+	if lockMgr == nil {
 		return updateTagRuleUnsafe(ctx, res)
 	}
 
-	lockKey := fmt.Sprintf("tag_route:%s:%s", res.Mesh, res.Name)
-	lockTimeout := 30 * time.Second
+	lockKey := lock.BuildTagRouteLockKey(res.Mesh, res.Name)
 
-	return lock.WithLock(ctx.AppContext(), lockKey, lockTimeout, func() error {
+	return lockMgr.WithLock(ctx.AppContext(), lockKey, lock.DefaultLockTimeout, func() error {
 		return updateTagRuleUnsafe(ctx, res)
 	})
 }
@@ -64,15 +61,14 @@ func updateTagRuleUnsafe(ctx consolectx.Context, res *meshresource.TagRouteResou
 }
 
 func CreateTagRule(ctx consolectx.Context, res *meshresource.TagRouteResource) error {
-	lock := ctx.LockManager()
-	if lock == nil {
+	lockMgr := ctx.LockManager()
+	if lockMgr == nil {
 		return createTagRuleUnsafe(ctx, res)
 	}
 
-	lockKey := fmt.Sprintf("tag_route:%s:%s", res.Mesh, res.Name)
-	lockTimeout := 30 * time.Second
+	lockKey := lock.BuildTagRouteLockKey(res.Mesh, res.Name)
 
-	return lock.WithLock(ctx.AppContext(), lockKey, lockTimeout, func() error {
+	return lockMgr.WithLock(ctx.AppContext(), lockKey, lock.DefaultLockTimeout, func() error {
 		return createTagRuleUnsafe(ctx, res)
 	})
 }
@@ -87,15 +83,14 @@ func createTagRuleUnsafe(ctx consolectx.Context, res *meshresource.TagRouteResou
 }
 
 func DeleteTagRule(ctx consolectx.Context, name string, mesh string) error {
-	lock := ctx.LockManager()
-	if lock == nil {
+	lockMgr := ctx.LockManager()
+	if lockMgr == nil {
 		return ctx.ResourceManager().DeleteByKey(meshresource.TagRouteKind, coremodel.BuildResourceKey(mesh, name))
 	}
 
-	lockKey := fmt.Sprintf("tag_route:%s:%s", mesh, name)
-	lockTimeout := 30 * time.Second
+	lockKey := lock.BuildTagRouteLockKey(mesh, name)
 
-	return lock.WithLock(ctx.AppContext(), lockKey, lockTimeout, func() error {
+	return lockMgr.WithLock(ctx.AppContext(), lockKey, lock.DefaultLockTimeout, func() error {
 		err := ctx.ResourceManager().DeleteByKey(meshresource.TagRouteKind, coremodel.BuildResourceKey(mesh, name))
 		if err != nil {
 			logger.Warnf("delete tag rule %s error: %v", name, err)

pkg/core/bootstrap/bootstrap.go

@@ -45,8 +45,7 @@ func Bootstrap(appCtx context.Context, cfg app.AdminConfig) (runtime.Runtime, er
 	}
 	// 2. initialize distributed lock
 	if err := initDistributedLock(builder); err != nil {
-		// Don't fail bootstrap if lock initialization fails
-		logger.Warnf("Failed to initialize distributed lock: %v", err)
+		return nil, errors.Wrap(err, "failed to initialize distributed lock")
 	}
 	// 3. initialize discovery
 	if err := initializeResourceDiscovery(builder); err != nil {
@@ -94,6 +93,15 @@ func initResourceStore(cfg app.AdminConfig, builder *runtime.Builder) error {
 	}
 	return initAndActivateComponent(builder, comp)
 }
+
+func initDistributedLock(builder *runtime.Builder) error {
+	comp, err := runtime.ComponentRegistry().Get(lock.DistributedLockComponent)
+	if err != nil {
+		return err
+	}
+	return initAndActivateComponent(builder, comp)
+}
+
 func initResourceManager(builder *runtime.Builder) error {
 	comp, err := runtime.ComponentRegistry().ResourceManager()
 	if err != nil {
@@ -153,10 +161,3 @@ func initAndActivateComponent(builder *runtime.Builder, comp runtime.Component)
 	}
 	return nil
 }
-func initDistributedLock(builder *runtime.Builder) error {
-	comp, err := runtime.ComponentRegistry().Get(lock.DistributedLockComponent)
-	if err != nil {
-		return err
-	}
-	return initAndActivateComponent(builder, comp)
-}

pkg/core/lock/component.go

@@ -19,13 +19,14 @@ package lock
 
 import (
 	"context"
+	"gorm.io/gorm"
+	"math"
 	"time"
 
 	"github.com/pkg/errors"
 
 	"github.com/apache/dubbo-admin/pkg/core/logger"
 	"github.com/apache/dubbo-admin/pkg/core/runtime"
-	"github.com/apache/dubbo-admin/pkg/store/dbcommon"
 )
 
 const (
@@ -49,48 +50,47 @@ func (c *Component) Type() runtime.ComponentType {
 }
 
 // Order indicates the initialization order
-// Lock should be initialized after Store (Order 100) but before other services
+// Lock should be initialized after Store (Order math.MaxInt - 1)
+// Higher order values are initialized first, so we use math.MaxInt - 2
 func (c *Component) Order() int {
-	return 90 // After Store, before Console
+	return math.MaxInt - 2 // After Store, before other services
 }
 
 // Init initializes the distributed lock component
 func (c *Component) Init(ctx runtime.BuilderContext) error {
-	// Get the store component to access connection pool
+	// Get the store component to access database connection
 	storeComp, err := ctx.GetActivatedComponent(runtime.ResourceStore)
 	if err != nil {
 		return err
 	}
 
-	// Try to extract connection pool from store component
-	// We need to use type assertion with the proper interface
-	type ConnectionPoolProvider interface {
-		GetConnectionPool() *dbcommon.ConnectionPool
+	// Try to extract database connection from store component
+	// We use GetDB() interface to avoid circular dependency with dbcommon package
+	type DBProvider interface {
+		GetDB() *gorm.DB
 	}
 
-	storeWithPool, ok := storeComp.(ConnectionPoolProvider)
+	storeWithDB, ok := storeComp.(DBProvider)
 	if !ok {
-		// For memory store or other stores without connection pool
-		logger.Warnf("Store component does not provide connection pool, distributed lock will not be available")
+		// For memory store or other stores without database
+		logger.Warnf("Store component does not provide database connection, distributed lock will not be available")
 		return nil
 	}
 
-	pool := storeWithPool.GetConnectionPool()
-	if pool == nil {
-		logger.Warnf("Connection pool is nil, distributed lock will not be available")
+	db := storeWithDB.GetDB()
+	if db == nil {
+		logger.Warnf("Database connection is nil, distributed lock will not be available")
 		return nil
 	}
 
-	// Create GORM-based lock implementation using NewGormLock
-	c.lock = NewGormLock(pool)
+	// Create GORM-based lock implementation using NewGormLockFromDB
+	c.lock = NewGormLockFromDB(db)
 
 	// Initialize the lock table
-	db := pool.GetDB()
 	if err := db.AutoMigrate(&LockRecord{}); err != nil {
 		return errors.Wrap(err, "failed to migrate lock table")
 	}
 
-	logger.Info("Distributed lock component initialized successfully")
 	return nil
 }
 
@@ -102,20 +102,17 @@ func (c *Component) Start(rt runtime.Runtime, stop <-chan struct{}) error {
 	}
 
 	// Start background cleanup task
-	ticker := time.NewTicker(5 * time.Minute) // Cleanup every 5 minutes
+	ticker := time.NewTicker(DefaultCleanupInterval) // Cleanup every 5 minutes
 	defer ticker.Stop()
 
-	logger.Info("Distributed lock cleanup task started")
-
 	for {
 		select {
 		case <-stop:
-			logger.Info("Distributed lock cleanup task stopped")
 			return nil
 		case <-ticker.C:
-			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			ctx, cancel := context.WithTimeout(context.Background(), DefaultCleanupTimeout)
 			if err := c.lock.CleanupExpiredLocks(ctx); err != nil {
-				logger.Errorf("Failed to cleanup expired locks:  %v", err)
+				logger.Errorf("Failed to cleanup expired locks: %v", err)
 			}
 			cancel()
 		}
@@ -136,7 +133,6 @@ func GetLockFromRuntime(rt runtime.Runtime) (Lock, error) {
 
 	lockComp, ok := comp.(*Component)
 	if !ok {
-		// 修正：使用标准错误处理
 		return nil, errors.Errorf("component %s is not a valid lock component", DistributedLockComponent)
 	}
 

pkg/core/lock/const.go

@@ -0,0 +1,40 @@
+package lock
+
+import "time"
+
+const (
+	// DefaultLockTimeout is the default timeout for distributed lock operations
+	// This timeout applies to lock acquisition, renewal, and release operations
+	DefaultLockTimeout = 30 * time.Second
+
+	// DefaultAutoRenewThreshold is the TTL threshold above which auto-renewal is enabled
+	// Locks with TTL longer than this value will be automatically renewed
+	DefaultAutoRenewThreshold = 10 * time.Second
+
+	// DefaultUnlockTimeout is the timeout for unlock operations in deferred cleanup
+	DefaultUnlockTimeout = 5 * time.Second
+
+	// DefaultRenewTimeout is the timeout for lock renewal operations
+	DefaultRenewTimeout = 5 * time.Second
+
+	// DefaultLockRetryInterval is the interval between lock acquisition retry attempts
+	DefaultLockRetryInterval = 100 * time.Millisecond
+
+	// DefaultCleanupInterval is the interval for periodic expired lock cleanup
+	DefaultCleanupInterval = 5 * time.Minute
+
+	// DefaultCleanupTimeout is the timeout for cleanup operations
+	DefaultCleanupTimeout = 30 * time.Second
+)
+
+// Lock key prefixes for different resource types
+const (
+	// TagRouteKeyPrefix is the prefix for tag route lock keys
+	TagRouteKeyPrefix = "tag_route"
+
+	// ConfiguratorRuleKeyPrefix is the prefix for configurator rule lock keys
+	ConfiguratorRuleKeyPrefix = "configurator_rule"
+
+	// ConditionRuleKeyPrefix is the prefix for condition rule lock keys
+	ConditionRuleKeyPrefix = "condition_rule"
+)