refactor(locker): deprecate v1 change to v2 add unit tests (#332)

* test(locker): add unit tests for locker and owner

* test(locker): add unit tests for locker and owner

* feat(locker): deprecate v1 change to v2

* feat(locker): deprecate v1 change to v2

* feat(locker): deprecate v1 change to v2

Author: flc1125

cache/redis/store.go

@@ -161,5 +161,8 @@ func (s *Store) Add(ctx context.Context, key string, value any, ttl time.Duratio
 }
 
 func (s *Store) Lock(key string, ttl time.Duration) locker.Locker {
-	return redisLocker.NewLocker(s.redis, s.opts.prefix+key, ttl)
+	return redisLocker.NewLocker(s.redis,
+		redisLocker.WithName(s.opts.prefix+key),
+		redisLocker.WithTTL(ttl),
+	)
 }

cache/redis/store_test.go

@@ -123,9 +123,8 @@ func TestRedis_Lock(t *testing.T) {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			err := r.Lock("test", 5*time.Second).Try(context.Background(), func() error {
+			err := r.Lock("test", 5*time.Second).Try(context.Background(), func() {
 				time.Sleep(time.Second)
-				return nil
 			})
 			if err != nil {
 				assert.True(t, errors.Is(err, locker.ErrLocked))

locker/README.md

@@ -11,18 +11,30 @@ import (
 
 	"github.com/redis/go-redis/v9"
 
+	"github.com/go-kratos-ecosystem/components/v2/cache"
+	redisStore "github.com/go-kratos-ecosystem/components/v2/cache/redis"
 	redisLocker "github.com/go-kratos-ecosystem/components/v2/locker/redis"
 )
 
 func main() {
 	client := redis.NewClient(&redis.Options{
 		Addr: "localhost:6379",
-    })
+	})
+
+	// ex1: 直接用
+	locker := redisLocker.NewLocker(client, redisLocker.WithName("lock"), redisLocker.WithTTL(5*time.Minute))
+	_ = locker.Try(context.Background(), func() {
+		// do something
+	})
+
+	// ex2: 基于缓存用
+	repository := cache.NewRepository(
+		redisStore.New(client, redisStore.Prefix("cache")),
+	)
 
-	locker := redisLocker.NewLocker(client, "lock", 5*time.Minute)
-	_ = locker.Try(context.Background(), func() error {
+	_ = repository.Lock("lock", 5*time.Minute).Try(context.Background(), func() {
 		// do something
-		return nil
 	})
 }
+
 ```

locker/locker.go

@@ -7,37 +7,42 @@ import (
 )
 
 var (
-	ErrLocked    = errors.New("locker: locked")
-	ErrTimeout   = errors.New("locker: timeout")
-	ErrNotLocked = errors.New("locker: not locked")
+	ErrLocked    = errors.New("locker: the locker is locked")
+	ErrTimeout   = errors.New("locker: the locker is timeout")
+	ErrNotLocked = errors.New("locker: the locker is not locked")
 )
 
 type Locker interface {
-	// Try tries to acquire the lock and execute the function.
-	// If the lock is already acquired, it will return ErrLocked.
-	// Otherwise, it will release the lock after the function is executed, and return the error of the function.
-	Try(ctx context.Context, fn func() error) error
-
-	// Until tries to acquire the lock and execute the function.
-	// If the lock is already acquired, it will wait until the lock is released or the timeout is reached.
-	// If the timeout is reached, it will return ErrTimeout.
-	// Otherwise, it will release the lock after the function is executed, and return the error of the function.
-	Until(ctx context.Context, timeout time.Duration, fn func() error) error
-
-	// Release releases the lock for the current owner.
-	// It returns true if the lock is released successfully, otherwise it returns false.
-	// If the lock acquired by another owner, it will return false.
-	Release(ctx context.Context) (bool, error)
-
-	// ForceRelease releases the lock forcefully.
-	ForceRelease(ctx context.Context) error
+	// Try tries to get the lock.
+	// if the lock is locked, it will return an error.
+	Try(ctx context.Context, fn func()) error
+
+	// Until tries to get the lock until the timeout.
+	// if the lock is locked, it will wait until the lock is released or the timeout is reached.
+	Until(ctx context.Context, timeout time.Duration, fn func()) error
+
+	// Get tries to get the lock.
+	// if the lock is locked, it will return the owner of the lock or an error.
+	Get(ctx context.Context) (Owner, error)
+
+	// Release releases the locked owner.
+	// if the owner is not the locked owner, it will return an error.
+	Release(ctx context.Context, owner Owner) error
 
-	// Owner return the owner of the lock.
-	Owner() string
+	// ForceRelease releases the lock forcibly.
+	ForceRelease(ctx context.Context) error
 
-	// LockedOwner returns the current owner of the lock.
-	// If the lock is not acquired, it will return an empty string and ErrNotLocked.
-	// Unlike Owner, which returns the owner of the current node in the cluster,
-	// LockedOwner returns the owner of the lock acquired by the Cluster.
-	LockedOwner(ctx context.Context) (string, error)
+	// LockedOwner returns the owner of the lock.
+	LockedOwner(ctx context.Context) (Owner, error)
 }
+
+type NoopLocker struct{}
+
+var _ Locker = NoopLocker{}
+
+func (l NoopLocker) Try(context.Context, func()) error                  { return nil }
+func (l NoopLocker) Until(context.Context, time.Duration, func()) error { return nil }
+func (l NoopLocker) Get(context.Context) (Owner, error)                 { return nil, nil }
+func (l NoopLocker) Release(context.Context, Owner) error               { return nil }
+func (l NoopLocker) ForceRelease(context.Context) error                 { return nil }
+func (l NoopLocker) LockedOwner(context.Context) (Owner, error)         { return nil, nil }

locker/locker_test.go

@@ -0,0 +1,28 @@
+package locker
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLocker_NoopLocker(t *testing.T) {
+	l := NoopLocker{}
+	ctx := context.Background()
+
+	assert.NoError(t, l.Try(ctx, func() {}))
+	assert.NoError(t, l.Until(ctx, time.Second, func() {}))
+
+	o, err := l.Get(ctx)
+	assert.NoError(t, err)
+	assert.Nil(t, o)
+
+	assert.NoError(t, l.Release(ctx, nil))
+	assert.NoError(t, l.ForceRelease(ctx))
+
+	o, err = l.LockedOwner(ctx)
+	assert.NoError(t, err)
+	assert.Nil(t, o)
+}

locker/memory/locker.go

@@ -0,0 +1,47 @@
+package locker
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+)
+
+type Owner interface {
+	// Name returns the name of the owner.
+	Name() string
+
+	// Release releases the lock.
+	Release(ctx context.Context) error
+}
+
+type owner struct {
+	name   string
+	locker Locker
+}
+
+type OwnerOption func(*owner)
+
+func WithOwnerName(name string) OwnerOption {
+	return func(o *owner) {
+		o.name = name
+	}
+}
+
+func NewOwner(locker Locker, opts ...OwnerOption) Owner {
+	o := &owner{
+		name:   uuid.New().String(),
+		locker: locker,
+	}
+	for _, opt := range opts {
+		opt(o)
+	}
+	return o
+}
+
+func (o *owner) Name() string {
+	return o.name
+}
+
+func (o *owner) Release(ctx context.Context) error {
+	return o.locker.Release(ctx, o)
+}

locker/memory/locker_test.go

@@ -0,0 +1,14 @@
+package locker
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestOwner_owner(t *testing.T) {
+	o := NewOwner(NoopLocker{}, WithOwnerName("test"))
+	assert.Equal(t, "test", o.Name())
+	assert.NoError(t, o.Release(context.Background()))
+}