[Vendor] Update go-redis to v8.5.0 (#13749)

* Update go-redis to v8.4.0

* github.com/go-redis/redis/v8  v8.4.0 -> v8.5.0

* Apply suggestions from code review

Co-authored-by: zeripath <art27@cantab.net>

* TODO

* Use the Queue termination channel as the default context for pushes

Signed-off-by: Andrew Thornton <art27@cantab.net>

* missed one

Signed-off-by: Andrew Thornton <art27@cantab.net>

Co-authored-by: zeripath <art27@cantab.net>

3 files changed, 43 insertions, 18 deletions

diff --git a/modules/queue/queue_bytefifo.go b/modules/queue/queue_bytefifo.go
index cad258bda8..4bb7bbf2b1 100644
--- a/modules/queue/queue_bytefifo.go
+++ b/modules/queue/queue_bytefifo.go
@@ -163,6 +163,11 @@ func (q *ByteFIFOQueue) Shutdown() {
 	log.Debug("%s: %s Shutdown", q.typ, q.name)
 }
 
+// IsShutdown returns a channel which is closed when this Queue is shutdown
+func (q *ByteFIFOQueue) IsShutdown() <-chan struct{} {
+	return q.closed
+}
+
 // Terminate this queue and close the queue
 func (q *ByteFIFOQueue) Terminate() {
 	log.Trace("%s: %s Terminating", q.typ, q.name)
@@ -185,6 +190,11 @@ func (q *ByteFIFOQueue) Terminate() {
 	log.Debug("%s: %s Terminated", q.typ, q.name)
 }
 
+// IsTerminated returns a channel which is closed when this Queue is terminated
+func (q *ByteFIFOQueue) IsTerminated() <-chan struct{} {
+	return q.terminated
+}
+
 var _ (UniqueQueue) = &ByteFIFOUniqueQueue{}
 
 // ByteFIFOUniqueQueue represents a UniqueQueue formed from a UniqueByteFifo
diff --git a/modules/queue/queue_redis.go b/modules/queue/queue_redis.go
index 04e7b5d252..2b1d36f0ad 100644
--- a/modules/queue/queue_redis.go
+++ b/modules/queue/queue_redis.go
@@ -5,10 +5,14 @@
 package queue
 
 import (
+	"context"
+	"fmt"
+
+	"code.gitea.io/gitea/modules/graceful"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/nosql"
 
-	"github.com/go-redis/redis/v7"
+	"github.com/go-redis/redis/v8"
 )
 
 // RedisQueueType is the type for redis queue
@@ -43,6 +47,8 @@ func NewRedisQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)
 		return nil, err
 	}
 
+	byteFIFO.ctx = graceful.NewChannelContext(byteFIFOQueue.IsTerminated(), fmt.Errorf("queue has been terminated"))
+
 	queue := &RedisQueue{
 		ByteFIFOQueue: byteFIFOQueue,
 	}
@@ -53,13 +59,13 @@ func NewRedisQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue, error)
 }
 
 type redisClient interface {
-	RPush(key string, args ...interface{}) *redis.IntCmd
-	LPop(key string) *redis.StringCmd
-	LLen(key string) *redis.IntCmd
-	SAdd(key string, members ...interface{}) *redis.IntCmd
-	SRem(key string, members ...interface{}) *redis.IntCmd
-	SIsMember(key string, member interface{}) *redis.BoolCmd
-	Ping() *redis.StatusCmd
+	RPush(ctx context.Context, key string, args ...interface{}) *redis.IntCmd
+	LPop(ctx context.Context, key string) *redis.StringCmd
+	LLen(ctx context.Context, key string) *redis.IntCmd
+	SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd
+	SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd
+	SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd
+	Ping(ctx context.Context) *redis.StatusCmd
 	Close() error
 }
 
@@ -67,6 +73,7 @@ var _ (ByteFIFO) = &RedisByteFIFO{}
 
 // RedisByteFIFO represents a ByteFIFO formed from a redisClient
 type RedisByteFIFO struct {
+	ctx       context.Context
 	client    redisClient
 	queueName string
 }
@@ -82,8 +89,9 @@ func NewRedisByteFIFO(config RedisByteFIFOConfiguration) (*RedisByteFIFO, error)
 	fifo := &RedisByteFIFO{
 		queueName: config.QueueName,
 	}
+	fifo.ctx = graceful.GetManager().TerminateContext()
 	fifo.client = nosql.GetManager().GetRedisClient(config.ConnectionString)
-	if err := fifo.client.Ping().Err(); err != nil {
+	if err := fifo.client.Ping(graceful.GetManager().ShutdownContext()).Err(); err != nil {
 		return nil, err
 	}
 	return fifo, nil
@@ -96,12 +104,12 @@ func (fifo *RedisByteFIFO) PushFunc(data []byte, fn func() error) error {
 			return err
 		}
 	}
-	return fifo.client.RPush(fifo.queueName, data).Err()
+	return fifo.client.RPush(fifo.ctx, fifo.queueName, data).Err()
 }
 
 // Pop pops data from the start of the fifo
 func (fifo *RedisByteFIFO) Pop() ([]byte, error) {
-	data, err := fifo.client.LPop(fifo.queueName).Bytes()
+	data, err := fifo.client.LPop(fifo.ctx, fifo.queueName).Bytes()
 	if err == nil || err == redis.Nil {
 		return data, nil
 	}
@@ -115,7 +123,7 @@ func (fifo *RedisByteFIFO) Close() error {
 
 // Len returns the length of the fifo
 func (fifo *RedisByteFIFO) Len() int64 {
-	val, err := fifo.client.LLen(fifo.queueName).Result()
+	val, err := fifo.client.LLen(fifo.ctx, fifo.queueName).Result()
 	if err != nil {
 		log.Error("Error whilst getting length of redis queue %s: Error: %v", fifo.queueName, err)
 		return -1
diff --git a/modules/queue/unique_queue_redis.go b/modules/queue/unique_queue_redis.go
index 67efc66bc9..96fcad1a83 100644
--- a/modules/queue/unique_queue_redis.go
+++ b/modules/queue/unique_queue_redis.go
@@ -4,7 +4,12 @@
 
 package queue
 
-import "github.com/go-redis/redis/v7"
+import (
+	"fmt"
+
+	"code.gitea.io/gitea/modules/graceful"
+	"github.com/go-redis/redis/v8"
+)
 
 // RedisUniqueQueueType is the type for redis queue
 const RedisUniqueQueueType Type = "unique-redis"
@@ -46,6 +51,8 @@ func NewRedisUniqueQueue(handle HandlerFunc, cfg, exemplar interface{}) (Queue,
 		return nil, err
 	}
 
+	byteFIFO.ctx = graceful.NewChannelContext(byteFIFOQueue.IsTerminated(), fmt.Errorf("queue has been terminated"))
+
 	queue := &RedisUniqueQueue{
 		ByteFIFOUniqueQueue: byteFIFOQueue,
 	}
@@ -86,7 +93,7 @@ func NewRedisUniqueByteFIFO(config RedisUniqueByteFIFOConfiguration) (*RedisUniq
 
 // PushFunc pushes data to the end of the fifo and calls the callback if it is added
 func (fifo *RedisUniqueByteFIFO) PushFunc(data []byte, fn func() error) error {
-	added, err := fifo.client.SAdd(fifo.setName, data).Result()
+	added, err := fifo.client.SAdd(fifo.ctx, fifo.setName, data).Result()
 	if err != nil {
 		return err
 	}
@@ -98,12 +105,12 @@ func (fifo *RedisUniqueByteFIFO) PushFunc(data []byte, fn func() error) error {
 			return err
 		}
 	}
-	return fifo.client.RPush(fifo.queueName, data).Err()
+	return fifo.client.RPush(fifo.ctx, fifo.queueName, data).Err()
 }
 
 // Pop pops data from the start of the fifo
 func (fifo *RedisUniqueByteFIFO) Pop() ([]byte, error) {
-	data, err := fifo.client.LPop(fifo.queueName).Bytes()
+	data, err := fifo.client.LPop(fifo.ctx, fifo.queueName).Bytes()
 	if err != nil && err != redis.Nil {
 		return data, err
 	}
@@ -112,13 +119,13 @@ func (fifo *RedisUniqueByteFIFO) Pop() ([]byte, error) {
 		return data, nil
 	}
 
-	err = fifo.client.SRem(fifo.setName, data).Err()
+	err = fifo.client.SRem(fifo.ctx, fifo.setName, data).Err()
 	return data, err
 }
 
 // Has returns whether the fifo contains this data
 func (fifo *RedisUniqueByteFIFO) Has(data []byte) (bool, error) {
-	return fifo.client.SIsMember(fifo.setName, data).Result()
+	return fifo.client.SIsMember(fifo.ctx, fifo.setName, data).Result()
 }
 
 func init() {