fix redis incr ttl

Author: xcolwell

connect/transport_rate_limit.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/redis/go-redis/v9"
+
 	"github.com/urnetwork/glog"
 
 	"github.com/urnetwork/server"
@@ -111,25 +113,26 @@ func (self *ConnectionRateLimit) Connect() (err error, disconnect func()) {
 	var burstCount int64
 	var totalCount int64
 	server.Redis(self.ctx, func(r server.RedisClient) {
-		burstCount, err = r.Incr(self.ctx, burstKey).Result()
+		var burstCmd *redis.IntCmd
+		var totalCmd *redis.IntCmd
+		r.TxPipelined(self.ctx, func(pipe redis.Pipeliner) error {
+			burstCmd = pipe.Incr(self.ctx, burstKey)
+			pipe.Expire(self.ctx, burstKey, self.settings.BurstDuration)
+
+			totalCmd = pipe.Incr(self.ctx, totalKey)
+			pipe.Expire(self.ctx, totalKey, self.settings.TotalExpiration)
+
+			return nil
+		})
+		burstCount, err = burstCmd.Result()
 		if err != nil {
 			return
 		}
-		if burstCount == 1 {
-			// FIXME put this in an atomic lua script
-			// for now it doesnt matter if a few keys linger
-			r.Expire(self.ctx, burstKey, self.settings.BurstDuration).Err()
-		}
-		totalCount, err = r.Incr(self.ctx, totalKey).Result()
+		totalCount, err = totalCmd.Result()
 		if err != nil {
 			return
 		}
 		totalIncremented = true
-		if totalCount == 1 {
-			// FIXME put this in an atomic lua script
-			// for now it doesnt matter if a few keys linger
-			r.Expire(self.ctx, totalKey, self.settings.TotalExpiration).Err()
-		}
 	})
 	if err != nil {
 		return

model/network_client_model.go

@@ -19,6 +19,8 @@ import (
 	// "github.com/twmb/murmur3"
 	"golang.org/x/exp/maps"
 
+	"github.com/redis/go-redis/v9"
+
 	"github.com/urnetwork/glog"
 
 	"github.com/urnetwork/server"
@@ -1321,33 +1323,49 @@ func ClientError(ctx context.Context, networkId server.Id, clientId server.Id, c
 
 	server.Redis(ctx, func(r server.RedisClient) {
 
-		networkCount, err := r.Incr(ctx, networkKey).Result()
+		var networkCountCmd *redis.IntCmd
+		var clientCountCmd *redis.IntCmd
+		var networkErrorMessageCountCmd *redis.IntCmd
+		var clientErrorMessageCountCmd *redis.IntCmd
+		r.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
+			networkCountCmd = pipe.Incr(ctx, networkKey)
+			pipe.Expire(ctx, networkKey, ttl)
+
+			clientCountCmd = pipe.Incr(ctx, clientKey)
+			pipe.Expire(ctx, clientKey, ttl)
+
+			networkErrorMessageCountCmd = pipe.Incr(ctx, networkErrorMessageKey)
+			pipe.Expire(ctx, networkErrorMessageKey, ttl)
+
+			clientErrorMessageCountCmd = pipe.Incr(ctx, clientErrorMessageKey)
+			pipe.Expire(ctx, clientErrorMessageKey, ttl)
+
+			return nil
+		})
+
+		networkCount, err := networkCountCmd.Result()
 		if err == nil {
-			r.Expire(ctx, networkKey, ttl)
 			if networkCount%warnThreshold == 0 {
 				glog.V(1).Infof("[ncm][%s]network has a significant amount of connection errors (%d)\n", networkId, networkCount)
 			}
 		}
 
-		clientCount, err := r.Incr(ctx, clientKey).Result()
+		clientCount, err := clientCountCmd.Result()
 		if err == nil {
-			r.Expire(ctx, clientKey, ttl)
 			if clientCount%warnThreshold == 0 {
 				glog.V(1).Infof("[ncm][%s]client has a significant amount of connection errors (%d)\n", clientId, clientCount)
 			}
 		}
 
-		networkErrorMessageCount, err := r.Incr(ctx, networkErrorMessageKey).Result()
+		networkErrorMessageCount, err := networkErrorMessageCountCmd.Result()
 		if err == nil {
-			r.Expire(ctx, networkErrorMessageKey, ttl)
 			if networkErrorMessageCount%warnThreshold == 0 {
 				glog.V(1).Infof("[ncm][%s]network has a significant count of connection error message (%d): %s\n", networkId, networkErrorMessageCount, errorMessage)
 			}
 		}
 
-		clientErrorMessageCount, err := r.Incr(ctx, clientErrorMessageKey).Result()
+		clientErrorMessageCount, err := clientErrorMessageCountCmd.Result()
 		if err == nil {
-			r.Expire(ctx, clientErrorMessageKey, ttl)
 			if clientErrorMessageCount%warnThreshold == 0 {
 				glog.V(1).Infof("[ncm][%s]client has a significant count of connection error message (%d): %s\n", clientId, clientErrorMessageCount, errorMessage)
 			}