Enhancement locker.go with options when want using prefix and time to live and add a function for isLockedTTL

Author: WanMuhafidzFaldi

candiutils/locker.go

@@ -3,6 +3,7 @@ package candiutils
 import (
 	"context"
 	"errors"
+	"fmt"
 	"time"
 
 	"github.com/gomodule/redigo/redis"
@@ -13,76 +14,161 @@ import (
 type (
 	// RedisLocker lock using redis
 	RedisLocker struct {
-		pool *redis.Pool
+		pool          *redis.Pool
+		lockeroptions LockerOptions
 	}
 
 	// NoopLocker empty locker
 	NoopLocker struct{}
+
+	// Options for RedisLocker
+	LockerOptions struct {
+		Prefix string
+		TTL    time.Duration
+	}
+
+	// Option function type for setting options
+	LockerOption func(*LockerOptions)
 )
 
+// WithPrefix sets the prefix for keys
+func WithPrefixLocker(prefix string) LockerOption {
+	return func(o *LockerOptions) {
+		o.Prefix = prefix
+	}
+}
+
+// WithTTL sets the default TTL for keys
+func WithTTLLocker(ttl time.Duration) LockerOption {
+	return func(o *LockerOptions) {
+		o.TTL = ttl
+	}
+}
+
 // NewRedisLocker constructor
-func NewRedisLocker(pool *redis.Pool) *RedisLocker {
-	return &RedisLocker{pool: pool}
+func NewRedisLocker(pool *redis.Pool, opts ...LockerOption) *RedisLocker {
+	lockeroptions := LockerOptions{
+		Prefix: "LOCKFOR",
+		TTL:    0,
+	}
+	for _, opt := range opts {
+		opt(&lockeroptions)
+	}
+	return &RedisLocker{pool: pool, lockeroptions: lockeroptions}
+}
+
+// GetPrefix returns the prefix used for keys
+func (r *RedisLocker) GetPrefixLocker() string {
+	return r.lockeroptions.Prefix + ":"
+}
+
+// GetTTLLocker returns the default TTL for keys
+func (r *RedisLocker) GetTTLLocker() time.Duration {
+	return r.lockeroptions.TTL
+}
+
+func (r *RedisLocker) IsLocked(key string) bool {
+	conn := r.pool.Get()
+	defer conn.Close()
+
+	lockKey := fmt.Sprintf("%s:%s", r.lockeroptions.Prefix, key)
+	incr, err := redis.Int64(conn.Do("INCR", lockKey))
+	if err != nil {
+		return false
+	}
+
+	return incr > 1
 }
 
-func (r *RedisLocker) IsLocked(key string, expiration ...time.Duration) bool {
+func (r *RedisLocker) IsLockedTTL(key string, TTL time.Duration) bool {
 	conn := r.pool.Get()
-	incr, _ := redis.Int64(conn.Do("INCR", key))
+	defer conn.Close()
+
+	lockKey := fmt.Sprintf("%s:%s", r.lockeroptions.Prefix, key)
+	incr, err := redis.Int64(conn.Do("INCR", lockKey))
+	if err != nil {
+		return false
+	}
 
-	if len(expiration) > 0 {
-		conn.Do("EXPIRE", key, int(expiration[0].Seconds()))
+	var expireTime time.Duration
+	if TTL > 0 {
+		expireTime = TTL
+	} else {
+		expireTime = r.lockeroptions.TTL
+	}
+
+	if expireTime > 0 {
+		conn.Do("EXPIRE", lockKey, int(expireTime.Seconds()))
 	}
-	conn.Close()
 
 	return incr > 1
 }
 
 func (r *RedisLocker) HasBeenLocked(key string) bool {
 	conn := r.pool.Get()
-	incr, _ := redis.Int64(conn.Do("GET", key))
-	conn.Close()
+	defer conn.Close()
+
+	lockKey := fmt.Sprintf("%s:%s", r.lockeroptions.Prefix, key)
+	incr, _ := redis.Int64(conn.Do("GET", lockKey))
 
 	return incr > 0
 }
 
 // Unlock method
 func (r *RedisLocker) Unlock(key string) {
 	conn := r.pool.Get()
-	conn.Do("DEL", key)
-	conn.Close()
+	defer conn.Close()
+
+	lockKey := fmt.Sprintf("%s:%s", r.lockeroptions.Prefix, key)
+	conn.Do("DEL", lockKey)
 }
 
 // Reset method
 func (r *RedisLocker) Reset(key string) {
 	conn := r.pool.Get()
-	keys, _ := redis.Strings(conn.Do("KEYS", key))
+	defer conn.Close()
+
+	lockKey := fmt.Sprintf("%s:%s", r.lockeroptions.Prefix, key)
+	keys, err := redis.Strings(conn.Do("KEYS", lockKey))
+	if err != nil {
+		fmt.Println("Error when reset locker: ", key, err)
+		return
+	}
+
 	for _, k := range keys {
-		conn.Do("DEL", k)
+		_, err := conn.Do("DEL", k)
+		if err != nil {
+			fmt.Println("Error when reset locker: ", key, err)
+		}
 	}
-	conn.Close()
-	return
 }
 
 // Disconnect close and reset
 func (r *RedisLocker) Disconnect(ctx context.Context) error {
 	conn := r.pool.Get()
-	conn.Do("DEL", "LOCKFOR:*")
-	conn.Close()
+	defer conn.Close()
+
+	lockKey := fmt.Sprintf("%s:*", r.lockeroptions.Prefix)
+	_, err := conn.Do("DEL", lockKey)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
 // Lock method
 func (r *RedisLocker) Lock(key string, timeout time.Duration) (unlockFunc func(), err error) {
 	if timeout <= 0 {
-		return func() {}, errors.New("Timeout must be positive")
+		return func() {}, errors.New("timeout must be positive")
 	}
 	if key == "" {
-		return func() {}, errors.New("Key cannot empty")
+		return func() {}, errors.New("key cannot empty")
 	}
 
-	lockKey := "LOCKFOR:" + key
-	unlockFunc = func() { r.Unlock(lockKey) }
-	if !r.IsLocked(lockKey) {
+	lockKey := fmt.Sprintf("%s:%s", r.lockeroptions.Prefix, key)
+	unlockFunc = func() { r.Unlock(key) }
+	if !r.IsLocked(key) {
 		return unlockFunc, nil
 	}
 
@@ -99,7 +185,7 @@ func (r *RedisLocker) Lock(key string, timeout time.Duration) (unlockFunc func()
 		for {
 			switch msg := psc.Receive().(type) {
 			case redis.Message:
-				if msg.Pattern == eventChannel && lockKey == string(msg.Data) && !r.IsLocked(lockKey) {
+				if msg.Pattern == eventChannel && lockKey == string(msg.Data) && !r.IsLocked(key) {
 					wait <- nil
 					return
 				}
@@ -116,8 +202,8 @@ func (r *RedisLocker) Lock(key string, timeout time.Duration) (unlockFunc func()
 		return unlockFunc, err
 
 	case <-time.After(timeout):
-		r.Unlock(lockKey)
-		return unlockFunc, errors.New("Timeout when waiting unlock another process")
+		r.Unlock(key)
+		return unlockFunc, errors.New("timeout when waiting unlock another process")
 	}
 }
 
@@ -126,8 +212,8 @@ func (r *RedisLocker) Lock(key string, timeout time.Duration) (unlockFunc func()
 // IsLocked method
 func (NoopLocker) IsLocked(string) bool { return false }
 
-// IsLocked method
-func (NoopLocker) IsLockedWithTTL(string, time.Duration) bool { return false }
+// IsLockedTTL method
+func (NoopLocker) IsLockedTTL(string, time.Duration) bool { return false }
 
 // HasBeenLocked method
 func (NoopLocker) HasBeenLocked(string) bool { return false }
@@ -142,3 +228,9 @@ func (NoopLocker) Reset(string) {}
 func (NoopLocker) Lock(string, time.Duration) (func(), error) { return func() {}, nil }
 
 func (NoopLocker) Disconnect(context.Context) error { return nil }
+
+// GetPrefix method
+func (NoopLocker) GetPrefixLocker() string { return "" }
+
+// GetTTLLocker method
+func (NoopLocker) GetTTLLocker() time.Duration { return 0 }

codebase/interfaces/locker.go

@@ -6,11 +6,13 @@ type (
 	// Locker abstraction, lock concurrent process
 	Locker interface {
 		IsLocked(key string) bool
-		IsLockedWithTTL(key string, timeout time.Duration) bool
+		IsLockedTTL(key string, ttl time.Duration) bool
 		HasBeenLocked(key string) bool
 		Unlock(key string)
 		Reset(key string)
 		Lock(key string, timeout time.Duration) (unlockFunc func(), err error)
+		GetPrefixLocker() string
+		GetTTLLocker() time.Duration
 		Closer
 	}
 )