fix: close

Author: wolfogre

modules/globallock/globallock_test.go

@@ -25,14 +25,25 @@ func TestLockAndDo(t *testing.T) {
 			}
 		}
 
+		oldDefaultLocker := defaultLocker
+		defer func() {
+			defaultLocker = oldDefaultLocker
+		}()
+
 		initOnce = sync.Once{}
 		initFunc = func() {
 			defaultLocker = NewRedisLocker(url)
 		}
 
 		testLockAndDo(t)
+		require.NoError(t, defaultLocker.(*redisLocker).Close())
 	})
 	t.Run("memory", func(t *testing.T) {
+		oldDefaultLocker := defaultLocker
+		defer func() {
+			defaultLocker = oldDefaultLocker
+		}()
+
 		initOnce = sync.Once{}
 		initFunc = func() {
 			defaultLocker = NewMemoryLocker()

modules/globallock/locker_test.go

@@ -35,6 +35,7 @@ func TestLocker(t *testing.T) {
 		locker := NewRedisLocker(url)
 		testLocker(t, locker)
 		testRedisLocker(t, locker.(*redisLocker))
+		require.NoError(t, locker.(*redisLocker).Close())
 	})
 	t.Run("memory", func(t *testing.T) {
 		locker := NewMemoryLocker()
@@ -178,7 +179,17 @@ func testMemoryLocker(t *testing.T, locker *memoryLocker) {
 
 // testRedisLocker does specific tests for redisLocker
 func testRedisLocker(t *testing.T, locker *redisLocker) {
-	t.Run("missing extension", func(t *testing.T) {
+	defer func() {
+		// This case should be tested at the end.
+		// Otherwise, it will affect other tests.
+		t.Run("close", func(t *testing.T) {
+			assert.NoError(t, locker.Close())
+			_, _, err := locker.Lock(context.Background(), "test")
+			assert.Error(t, err)
+		})
+	}()
+
+	t.Run("failed extend", func(t *testing.T) {
 		ctx, release, err := locker.Lock(context.Background(), "test")
 		defer release()
 		require.NoError(t, err)

modules/globallock/redis_locker.go

@@ -6,7 +6,9 @@ package globallock
 import (
 	"context"
 	"errors"
+	"fmt"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"code.gitea.io/gitea/modules/nosql"
@@ -25,6 +27,7 @@ type redisLocker struct {
 	rs *redsync.Redsync
 
 	mutexM sync.Map
+	closed atomic.Bool
 }
 
 var _ Locker = &redisLocker{}
@@ -59,12 +62,25 @@ func (l *redisLocker) TryLock(ctx context.Context, key string) (bool, context.Co
 	return err == nil, ctx, f, err
 }
 
+// Close closes the locker.
+// It will stop extending the locks and refuse to acquire new locks.
+// In actual use, it is not necessary to call this function.
+// But it's useful in tests to release resources.
+func (l *redisLocker) Close() error {
+	l.closed.Store(true)
+	return nil
+}
+
 type redisMutex struct {
 	mutex  *redsync.Mutex
 	cancel context.CancelCauseFunc
 }
 
 func (l *redisLocker) lock(ctx context.Context, key string, tries int) (context.Context, ReleaseFunc, error) {
+	if l.closed.Load() {
+		return ctx, func() context.Context { return ctx }, fmt.Errorf("locker is closed")
+	}
+
 	originalCtx := ctx
 
 	options := []redsync.Option{
@@ -102,6 +118,10 @@ func (l *redisLocker) lock(ctx context.Context, key string, tries int) (context.
 }
 
 func (l *redisLocker) startExtend() {
+	if l.closed.Load() {
+		return
+	}
+
 	toExtend := make([]*redisMutex, 0)
 	l.mutexM.Range(func(_, value any) bool {
 		m := value.(*redisMutex)