feat: parse prefix from redis URI for queues

For security reasons, scoping access to a redis server via ACL rules is
a good practice. Some parts of the codebase handles prefix like cache[^1]
and session[^2], but the queue module doesn't.

This patch adds this missing functionality to the queue module.

Note about relevant test:
I tried to keep the PR as small as possible (and reasonable), and not
change how the test runs. Updated the existing test to use the same
redis address and basically duplicated the test with the extra flag. It
does NOT test if the keys are correct, it ensures only it works as
expected. To make assertions about the keys, the whole test has to be
updated as the general wrapper doesn't allow the main test to check
anything provider (redis) specific property. That's not something I
wanted to take on now.

[^1]: e4c3c039be/modules/cache/cache_redis.go (L139-L150)
[^2]: e4c3c039be/modules/session/redis.go (L122-L129)

Signed-off-by: Victoria Nadasdi <victoria@efertone.me>

modules/queue/base_redis.go

@@ -19,6 +19,7 @@ type baseRedis struct {
 	client   redis.UniversalClient
 	isUnique bool
 	cfg      *BaseConfig
+	prefix   string
 
 	mu sync.Mutex // the old implementation is not thread-safe, the queue operation and set operation should be protected together
 }
@@ -27,6 +28,22 @@ var _ baseQueue = (*baseRedis)(nil)
 
 func newBaseRedisGeneric(cfg *BaseConfig, unique bool) (baseQueue, error) {
 	client := nosql.GetManager().GetRedisClient(cfg.ConnStr)
+	prefix := ""
+	uri := nosql.ToRedisURI(cfg.ConnStr)
+
+	for key, value := range uri.Query() {
+		switch key {
+		case "prefix":
+			if len(value) > 0 {
+				prefix = value[0]
+
+				// As we are not checking any other values, if we found this one, we can
+				// exit from the loop.
+				// If a new key check is required, remove this break.
+				break
+			}
+		}
+	}
 
 	var err error
 	for i := 0; i < 10; i++ {
@@ -41,7 +58,7 @@ func newBaseRedisGeneric(cfg *BaseConfig, unique bool) (baseQueue, error) {
 		return nil, err
 	}
 
-	return &baseRedis{cfg: cfg, client: client, isUnique: unique}, nil
+	return &baseRedis{cfg: cfg, client: client, isUnique: unique, prefix: prefix}, nil
 }
 
 func newBaseRedisSimple(cfg *BaseConfig) (baseQueue, error) {
@@ -52,12 +69,16 @@ func newBaseRedisUnique(cfg *BaseConfig) (baseQueue, error) {
 	return newBaseRedisGeneric(cfg, true)
 }
 
+func (q *baseRedis) prefixedName(name string) string {
+	return q.prefix + name
+}
+
 func (q *baseRedis) PushItem(ctx context.Context, data []byte) error {
 	return backoffErr(ctx, backoffBegin, backoffUpper, time.After(pushBlockTime), func() (retry bool, err error) {
 		q.mu.Lock()
 		defer q.mu.Unlock()
 
-		cnt, err := q.client.LLen(ctx, q.cfg.QueueFullName).Result()
+		cnt, err := q.client.LLen(ctx, q.prefixedName(q.cfg.QueueFullName)).Result()
 		if err != nil {
 			return false, err
 		}
@@ -66,7 +87,7 @@ func (q *baseRedis) PushItem(ctx context.Context, data []byte) error {
 		}
 
 		if q.isUnique {
-			added, err := q.client.SAdd(ctx, q.cfg.SetFullName, data).Result()
+			added, err := q.client.SAdd(ctx, q.prefixedName(q.cfg.SetFullName), data).Result()
 			if err != nil {
 				return false, err
 			}
@@ -74,7 +95,7 @@ func (q *baseRedis) PushItem(ctx context.Context, data []byte) error {
 				return false, ErrAlreadyInQueue
 			}
 		}
-		return false, q.client.RPush(ctx, q.cfg.QueueFullName, data).Err()
+		return false, q.client.RPush(ctx, q.prefixedName(q.cfg.QueueFullName), data).Err()
 	})
 }
 
@@ -83,7 +104,7 @@ func (q *baseRedis) PopItem(ctx context.Context) ([]byte, error) {
 		q.mu.Lock()
 		defer q.mu.Unlock()
 
-		data, err = q.client.LPop(ctx, q.cfg.QueueFullName).Bytes()
+		data, err = q.client.LPop(ctx, q.prefixedName(q.cfg.QueueFullName)).Bytes()
 		if err == redis.Nil {
 			return true, nil, nil
 		}
@@ -92,7 +113,7 @@ func (q *baseRedis) PopItem(ctx context.Context) ([]byte, error) {
 		}
 		if q.isUnique {
 			// the data has been popped, even if there is any error we can't do anything
-			_ = q.client.SRem(ctx, q.cfg.SetFullName, data).Err()
+			_ = q.client.SRem(ctx, q.prefixedName(q.cfg.SetFullName), data).Err()
 		}
 		return false, data, err
 	})
@@ -104,13 +125,13 @@ func (q *baseRedis) HasItem(ctx context.Context, data []byte) (bool, error) {
 	if !q.isUnique {
 		return false, nil
 	}
-	return q.client.SIsMember(ctx, q.cfg.SetFullName, data).Result()
+	return q.client.SIsMember(ctx, q.prefixedName(q.cfg.SetFullName), data).Result()
 }
 
 func (q *baseRedis) Len(ctx context.Context) (int, error) {
 	q.mu.Lock()
 	defer q.mu.Unlock()
-	cnt, err := q.client.LLen(ctx, q.cfg.QueueFullName).Result()
+	cnt, err := q.client.LLen(ctx, q.prefixedName(q.cfg.QueueFullName)).Result()
 	return int(cnt), err
 }
 
@@ -124,10 +145,10 @@ func (q *baseRedis) RemoveAll(ctx context.Context) error {
 	q.mu.Lock()
 	defer q.mu.Unlock()
 
-	c1 := q.client.Del(ctx, q.cfg.QueueFullName)
+	c1 := q.client.Del(ctx, q.prefixedName(q.cfg.QueueFullName))
 	// the "set" must be cleared after the "list" because there is no transaction.
 	// it's better to have duplicate items than losing items.
-	c2 := q.client.Del(ctx, q.cfg.SetFullName)
+	c2 := q.client.Del(ctx, q.prefixedName(q.cfg.SetFullName))
 	if c1.Err() != nil {
 		return c1.Err()
 	}

modules/queue/base_redis_test.go

@@ -47,6 +47,12 @@ func redisServerCmd(t *testing.T) *exec.Cmd {
 }
 
 func TestBaseRedis(t *testing.T) {
+	redisAddress := "redis://127.0.0.1:6379/0"
+	queueSettings := setting.QueueSettings{
+		Length:  10,
+		ConnStr: redisAddress,
+	}
+
 	var redisServer *exec.Cmd
 	defer func() {
 		if redisServer != nil {
@@ -54,18 +60,48 @@ func TestBaseRedis(t *testing.T) {
 			_ = redisServer.Wait()
 		}
 	}()
-	if !waitRedisReady("redis://127.0.0.1:6379/0", 0) {
+	if !waitRedisReady(redisAddress, 0) {
 		redisServer = redisServerCmd(t)
 		if true {
 			t.Skip("redis-server not found in Forgejo test yet")
 			return
 		}
 		assert.NoError(t, redisServer.Start())
-		if !assert.True(t, waitRedisReady("redis://127.0.0.1:6379/0", 5*time.Second), "start redis-server") {
+		if !assert.True(t, waitRedisReady(redisAddress, 5*time.Second), "start redis-server") {
 			return
 		}
 	}
 
-	testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", setting.QueueSettings{Length: 10}), false)
-	testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", setting.QueueSettings{Length: 10}), true)
+	testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", queueSettings), false)
+	testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", queueSettings), true)
+}
+
+func TestBaseRedisWithPrefix(t *testing.T) {
+	redisAddress := "redis://127.0.0.1:6379/0?prefix=forgejo:queue:"
+	queueSettings := setting.QueueSettings{
+		Length:  10,
+		ConnStr: redisAddress,
+	}
+
+	var redisServer *exec.Cmd
+	defer func() {
+		if redisServer != nil {
+			_ = redisServer.Process.Signal(os.Interrupt)
+			_ = redisServer.Wait()
+		}
+	}()
+	if !waitRedisReady(redisAddress, 0) {
+		redisServer = redisServerCmd(t)
+		if true {
+			t.Skip("redis-server not found in Forgejo test yet")
+			return
+		}
+		assert.NoError(t, redisServer.Start())
+		if !assert.True(t, waitRedisReady(redisAddress, 5*time.Second), "start redis-server") {
+			return
+		}
+	}
+
+	testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", queueSettings), false)
+	testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", queueSettings), true)
 }