Update and fix linter version at v2.3.1, also address all linter issues (#156)

* Update and fix linter version at v2.3.1, also address all linter issues

* Update golangci/golangci-lint-action version to v2.3.1

* Fix lint issues after a git pull

Author: mennanov

.github/workflows/golangci-lint.yml

@@ -23,4 +23,4 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v8
         with:
-          version: "v2.1.6"
+          version: "v2.3.1"

Makefile

@@ -10,7 +10,7 @@ benchmark: docker-compose-up
 	ETCD_ENDPOINTS="127.0.0.1:2379" REDIS_ADDR="127.0.0.1:6379" REDIS_NODES="127.0.0.1:11000,127.0.0.1:11001,127.0.0.1:11002,127.0.0.1:11003,127.0.0.1:11004,127.0.0.1:11005" ZOOKEEPER_ENDPOINTS="127.0.0.1" CONSUL_ADDR="127.0.0.1:8500" AWS_ADDR="127.0.0.1:8000" MEMCACHED_ADDR="127.0.0.1:11211" POSTGRES_URL="postgres://postgres@localhost:5432/?sslmode=disable" COSMOS_ADDR="127.0.0.1:8081" go test -race -run=nonexistent -bench=.
 
 lint:
-	@(which golangci-lint && golangci-lint --version | grep 2.1.6) || (curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(shell go env GOPATH)/bin v2.1.6)
+	@(which golangci-lint && golangci-lint --version | grep 2.3.1) || (curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/v2.3.1/install.sh | sh -s -- -b $(shell go env GOPATH)/bin v2.3.1)
 	golangci-lint run --fix ./...
 
 goimports:

concurrent_buffer.go

@@ -39,11 +39,15 @@ func NewConcurrentBuffer(locker DistLocker, concurrentStateBackend ConcurrentBuf
 func (c *ConcurrentBuffer) Limit(ctx context.Context, key string) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	if err := c.locker.Lock(ctx); err != nil {
+
+	err := c.locker.Lock(ctx)
+	if err != nil {
 		return err
 	}
+
 	defer func() {
-		if err := c.locker.Unlock(ctx); err != nil {
+		err := c.locker.Unlock(ctx)
+		if err != nil {
 			c.logger.Log(err)
 		}
 	}()
@@ -52,9 +56,11 @@ func (c *ConcurrentBuffer) Limit(ctx context.Context, key string) error {
 	if err != nil {
 		return err
 	}
+
 	if counter > c.capacity {
 		// Rollback the Add() operation.
-		if err = c.backend.Remove(ctx, key); err != nil {
+		err = c.backend.Remove(ctx, key)
+		if err != nil {
 			c.logger.Log(err)
 		}
 
@@ -89,6 +95,7 @@ func NewConcurrentBufferInMemory(registry *Registry, ttl time.Duration, clock Cl
 func (c *ConcurrentBufferInMemory) Add(ctx context.Context, key string) (int64, error) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
+
 	now := c.clock.Now()
 	c.registry.DeleteExpired(now)
 	c.registry.GetOrCreate(key, func() interface{} {
@@ -102,6 +109,7 @@ func (c *ConcurrentBufferInMemory) Add(ctx context.Context, key string) (int64,
 func (c *ConcurrentBufferInMemory) Remove(_ context.Context, key string) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
+
 	c.registry.Delete(key)
 
 	return nil
@@ -125,11 +133,16 @@ func NewConcurrentBufferRedis(cli redis.UniversalClient, key string, ttl time.Du
 // Add adds the request with the given key to the sorted set in Redis and returns the total number of requests in it.
 // It also removes the keys with expired TTL.
 func (c *ConcurrentBufferRedis) Add(ctx context.Context, key string) (int64, error) {
-	var countCmd *redis.IntCmd
-	var err error
+	var (
+		countCmd *redis.IntCmd
+		err      error
+	)
+
 	done := make(chan struct{})
+
 	go func() {
 		defer close(done)
+
 		_, err = c.cli.Pipelined(ctx, func(pipeliner redis.Pipeliner) error {
 			// Remove expired items.
 			now := c.clock.Now()
@@ -186,14 +199,20 @@ type SortedSetNode struct {
 // It also removes the keys with expired TTL.
 func (c *ConcurrentBufferMemcached) Add(ctx context.Context, element string) (int64, error) {
 	var err error
+
 	done := make(chan struct{})
 	now := c.clock.Now()
-	var newNodes []SortedSetNode
-	var casId uint64 = 0
+
+	var (
+		newNodes []SortedSetNode
+		casId    uint64 = 0
+	)
 
 	go func() {
 		defer close(done)
+
 		var item *memcache.Item
+
 		item, err = c.cli.Get(c.key)
 		if err != nil {
 			if !errors.Is(err, memcache.ErrCacheMiss) {
@@ -202,17 +221,23 @@ func (c *ConcurrentBufferMemcached) Add(ctx context.Context, element string) (in
 		} else {
 			casId = item.CasID
 			b := bytes.NewBuffer(item.Value)
+
 			var oldNodes []SortedSetNode
+
 			_ = gob.NewDecoder(b).Decode(&oldNodes)
 			for _, node := range oldNodes {
 				if node.CreatedAt > now.UnixNano() && node.Value != element {
 					newNodes = append(newNodes, node)
 				}
 			}
 		}
+
 		newNodes = append(newNodes, SortedSetNode{CreatedAt: now.Add(c.ttl).UnixNano(), Value: element})
+
 		var b bytes.Buffer
+
 		_ = gob.NewEncoder(&b).Encode(newNodes)
+
 		item = &memcache.Item{
 			Key:   c.key,
 			Value: b.Bytes(),
@@ -245,9 +270,14 @@ func (c *ConcurrentBufferMemcached) Add(ctx context.Context, element string) (in
 // Remove removes the request identified by the key from the slice in Memcached.
 func (c *ConcurrentBufferMemcached) Remove(ctx context.Context, key string) error {
 	var err error
+
 	now := c.clock.Now()
-	var newNodes []SortedSetNode
-	var casID uint64
+
+	var (
+		newNodes []SortedSetNode
+		casID    uint64
+	)
+
 	item, err := c.cli.Get(c.key)
 	if err != nil {
 		if errors.Is(err, memcache.ErrCacheMiss) {
@@ -256,8 +286,11 @@ func (c *ConcurrentBufferMemcached) Remove(ctx context.Context, key string) erro
 
 		return errors.Wrap(err, "failed to Get")
 	}
+
 	casID = item.CasID
+
 	var oldNodes []SortedSetNode
+
 	_ = gob.NewDecoder(bytes.NewBuffer(item.Value)).Decode(&oldNodes)
 	for _, node := range oldNodes {
 		if node.CreatedAt > now.UnixNano() && node.Value != key {
@@ -266,12 +299,14 @@ func (c *ConcurrentBufferMemcached) Remove(ctx context.Context, key string) erro
 	}
 
 	var b bytes.Buffer
+
 	_ = gob.NewEncoder(&b).Encode(newNodes)
 	item = &memcache.Item{
 		Key:   c.key,
 		Value: b.Bytes(),
 		CasID: casID,
 	}
+
 	err = c.cli.CompareAndSwap(item)
 	if err != nil && (errors.Is(err, memcache.ErrCASConflict) || errors.Is(err, memcache.ErrNotStored) || errors.Is(err, memcache.ErrCacheMiss)) {
 		return c.Remove(ctx, key)

concurrent_buffer_test.go

@@ -13,6 +13,7 @@ import (
 
 func (s *LimitersTestSuite) concurrentBuffers(capacity int64, ttl time.Duration, clock l.Clock) map[string]*l.ConcurrentBuffer {
 	buffers := make(map[string]*l.ConcurrentBuffer)
+
 	for lockerName, locker := range s.lockers(true) {
 		for bName, b := range s.concurrentBufferBackends(ttl, clock) {
 			buffers[lockerName+":"+bName] = l.NewConcurrentBuffer(locker, b, capacity, s.logger)
@@ -34,19 +35,23 @@ func (s *LimitersTestSuite) concurrentBufferBackends(ttl time.Duration, clock l.
 func (s *LimitersTestSuite) TestConcurrentBufferNoOverflow() {
 	clock := newFakeClock()
 	capacity := int64(10)
+
 	ttl := time.Second
 	for name, buffer := range s.concurrentBuffers(capacity, ttl, clock) {
 		s.Run(name, func() {
 			wg := sync.WaitGroup{}
 			for i := int64(0); i < capacity; i++ {
 				wg.Add(1)
+
 				go func(i int64, buffer *l.ConcurrentBuffer) {
 					defer wg.Done()
+
 					key := fmt.Sprintf("key%d", i)
 					s.NoError(buffer.Limit(context.TODO(), key))
 					s.NoError(buffer.Done(context.TODO(), key))
 				}(i, buffer)
 			}
+
 			wg.Wait()
 			s.NoError(buffer.Limit(context.TODO(), "last"))
 			s.NoError(buffer.Done(context.TODO(), "last"))
@@ -57,23 +62,32 @@ func (s *LimitersTestSuite) TestConcurrentBufferNoOverflow() {
 func (s *LimitersTestSuite) TestConcurrentBufferOverflow() {
 	clock := newFakeClock()
 	capacity := int64(3)
+
 	ttl := time.Second
 	for name, buffer := range s.concurrentBuffers(capacity, ttl, clock) {
 		s.Run(name, func() {
 			mu := sync.Mutex{}
+
 			var errors []error
+
 			wg := sync.WaitGroup{}
 			for i := int64(0); i <= capacity; i++ {
 				wg.Add(1)
+
 				go func(i int64, buffer *l.ConcurrentBuffer) {
 					defer wg.Done()
-					if err := buffer.Limit(context.TODO(), fmt.Sprintf("key%d", i)); err != nil {
+
+					err := buffer.Limit(context.TODO(), fmt.Sprintf("key%d", i))
+					if err != nil {
 						mu.Lock()
+
 						errors = append(errors, err)
+
 						mu.Unlock()
 					}
 				}(i, buffer)
 			}
+
 			wg.Wait()
 			s.Equal([]error{l.ErrLimitExhausted}, errors)
 		})
@@ -83,6 +97,7 @@ func (s *LimitersTestSuite) TestConcurrentBufferOverflow() {
 func (s *LimitersTestSuite) TestConcurrentBufferExpiredKeys() {
 	clock := newFakeClock()
 	capacity := int64(2)
+
 	ttl := time.Second
 	for name, buffer := range s.concurrentBuffers(capacity, ttl, clock) {
 		s.Run(name, func() {
@@ -100,6 +115,7 @@ func (s *LimitersTestSuite) TestConcurrentBufferExpiredKeys() {
 func (s *LimitersTestSuite) TestConcurrentBufferDuplicateKeys() {
 	clock := newFakeClock()
 	capacity := int64(2)
+
 	ttl := time.Second
 	for name, buffer := range s.concurrentBuffers(capacity, ttl, clock) {
 		s.Run(name, func() {
@@ -115,9 +131,11 @@ func BenchmarkConcurrentBuffers(b *testing.B) {
 	s := new(LimitersTestSuite)
 	s.SetT(&testing.T{})
 	s.SetupSuite()
+
 	capacity := int64(1)
 	ttl := time.Second
 	clock := newFakeClock()
+
 	buffers := s.concurrentBuffers(capacity, ttl, clock)
 	for name, buffer := range buffers {
 		b.Run(name, func(b *testing.B) {
@@ -126,5 +144,6 @@ func BenchmarkConcurrentBuffers(b *testing.B) {
 			}
 		})
 	}
+
 	s.TearDownSuite()
 }

dynamodb.go

@@ -116,12 +116,16 @@ func dynamoDBputItem(ctx context.Context, client *dynamodb.Client, input *dynamo
 func dynamoDBGetItem(ctx context.Context, client *dynamodb.Client, input *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) {
 	input.ConsistentRead = aws.Bool(true)
 
-	var resp *dynamodb.GetItemOutput
-	var err error
+	var (
+		resp *dynamodb.GetItemOutput
+		err  error
+	)
 
 	done := make(chan struct{})
+
 	go func() {
 		defer close(done)
+
 		resp, err = client.GetItem(ctx, input)
 	}()
 

dynamodb_test.go

@@ -55,11 +55,11 @@ func CreateTestDynamoDBTable(ctx context.Context, client *dynamodb.Client) error
 
 	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
 	defer cancel()
+
 	for {
 		resp, err := client.DescribeTable(ctx, &dynamodb.DescribeTableInput{
 			TableName: aws.String(testDynamoDBTableName),
 		})
-
 		if err == nil {
 			return errors.Wrap(err, "failed to describe test table")
 		}