fix(lints): update files according to the latest linter rules

Signed-off-by: Dusan Malusev <[email protected]>

Author: CodeLieutenant

.golangci.yml

@@ -76,7 +76,7 @@ linters:
         - pattern: ^print(ln)?$
           msg: "Use log package instead of fmt"
     gocyclo:
-      min-complexity: 19
+      min-complexity: 20
     govet:
       enable-all: true
       settings:

internal/version/version.go

@@ -68,9 +68,9 @@ func newGithubClient() *githubClient {
 }
 
 // Performs an HTTP GET request and decodes the JSON response to the target
-func (g *githubClient) getJSON(path string, target interface{}) error {
+func (g *githubClient) getJSON(path string, target any) error {
 	url := g.baseURL + path
-	req, err := http.NewRequest("GET", url, nil)
+	req, err := http.NewRequest(http.MethodGet, url, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}

internal/version/version_test.go

@@ -176,12 +176,12 @@ func TestGetDriverVersionWithEnvVar(t *testing.T) {
 	originalRepo := os.Getenv("GOCQL_REPO")
 	originalVersion := os.Getenv("GOCQL_VERSION")
 	defer func() {
-		os.Setenv("GOCQL_REPO", originalRepo)
-		os.Setenv("GOCQL_VERSION", originalVersion)
+		t.Setenv("GOCQL_REPO", originalRepo)
+		t.Setenv("GOCQL_VERSION", originalVersion)
 	}()
 
-	os.Setenv("GOCQL_REPO", "github.com/testowner/gocql")
-	os.Setenv("GOCQL_VERSION", "1234567890abcdef")
+	t.Setenv("GOCQL_REPO", "github.com/testowner/gocql")
+	t.Setenv("GOCQL_VERSION", "1234567890abcdef")
 
 	info := getDriverVersionInfo()
 	if info.Version == "" {

main.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/scylladb/scylla-bench/internal/version"
 	"github.com/scylladb/scylla-bench/pkg/results"
-
 	//nolint:revive
 	. "github.com/scylladb/scylla-bench/pkg/workloads"
 	"github.com/scylladb/scylla-bench/random"
@@ -120,7 +119,10 @@ func Query(session *gocql.Session, request string) {
 
 func PrepareDatabase(session *gocql.Session, replicationFactor int) {
 	//nolint:lll
-	Query(session, fmt.Sprintf("CREATE KEYSPACE IF NOT EXISTS %s WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'replication_factor' : %d }", keyspaceName, replicationFactor))
+	Query(
+		session,
+		fmt.Sprintf("CREATE KEYSPACE IF NOT EXISTS %s WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'replication_factor' : %d }", keyspaceName, replicationFactor),
+	)
 
 	switch mode {
 	case "counter_update":
@@ -315,7 +317,12 @@ func main() {
 	flag.BoolVar(&provideUpperBound, "provide-upper-bound", false, "whether read requests should provide an upper bound")
 	flag.BoolVar(&inRestriction, "in-restriction", false, "use IN restriction in read requests")
 	//nolint:lll
-	flag.StringVar(&selectOrderBy, "select-order-by", "none", "controls order part 'order by ck asc/desc' of the read query, you can set it to: none,asc,desc or to the list of them, i.e. 'none,asc', in such case it will run queries with these orders one by one")
+	flag.StringVar(
+		&selectOrderBy,
+		"select-order-by",
+		"none",
+		"controls order part 'order by ck asc/desc' of the read query, you can set it to: none,asc,desc or to the list of them, i.e. 'none,asc', in such case it will run queries with these orders one by one",
+	)
 	flag.BoolVar(&noLowerBound, "no-lower-bound", false, "do not provide lower bound in read requests")
 	flag.BoolVar(&bypassCache, "bypass-cache", false, "Execute queries with the \"BYPASS CACHE\" CQL clause")
 	flag.IntVar(&rangeCount, "range-count", 1, "number of ranges to split the token space into (relevant only for scan mode)")
@@ -357,7 +364,12 @@ func main() {
 	flag.StringVar(&datacenter, "datacenter", "", "datacenter for the rack-aware policy")
 	//nolint:lll
 	flag.StringVar(&rack, "rack", "", "rack for the rack-aware policy")
-	flag.IntVar(&maxErrorsAtRow, "error-at-row-limit", 0, "set limit of errors caught by one thread at row after which workflow will be terminated and error reported. Set it to 0 if you want to haven no limit")
+	flag.IntVar(
+		&maxErrorsAtRow,
+		"error-at-row-limit",
+		0,
+		"set limit of errors caught by one thread at row after which workflow will be terminated and error reported. Set it to 0 if you want to haven no limit",
+	)
 	flag.IntVar(
 		&maxErrors,
 		"error-limit", 0,

modes.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/sha256"
 	"encoding/binary"
+	stdErrors "errors"
 	"fmt"
 	"log"
 	"math"
@@ -17,13 +18,10 @@ import (
 	"github.com/gocql/gocql"
 	"github.com/pkg/errors"
 
-	stdErrors "errors"
-
 	"github.com/scylladb/scylla-bench/pkg/results"
-	"github.com/scylladb/scylla-bench/random"
-
 	//nolint
 	. "github.com/scylladb/scylla-bench/pkg/workloads"
+	"github.com/scylladb/scylla-bench/random"
 )
 
 var reportInterval = 1 * time.Second
@@ -157,7 +155,7 @@ func RunTest(
 	threadResult *results.TestThreadResult,
 	workload WorkloadGenerator,
 	rateLimiter RateLimiter,
-	test func(rb *results.TestThreadResult) (error, time.Duration),
+	test func(rb *results.TestThreadResult) (time.Duration, error),
 ) {
 	start := time.Now()
 	partialStart := start
@@ -171,7 +169,7 @@ func RunTest(
 			expectedStartTime = time.Now()
 		}
 
-		err, rawLatency := test(threadResult)
+		rawLatency, err := test(threadResult)
 		endTime := time.Now()
 		switch {
 		case err == nil:
@@ -381,7 +379,7 @@ func handleSbRetryError(queryStr string, err error, currentAttempts int) error {
 }
 
 func DoWrites(session *gocql.Session, threadResult *results.TestThreadResult, workload WorkloadGenerator, rateLimiter RateLimiter, validateData bool) {
-	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (error, time.Duration) {
+	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (time.Duration, error) {
 		request := fmt.Sprintf("INSERT INTO %s.%s (pk, ck, v) VALUES (?, ?, ?)", keyspaceName, tableName)
 		query := session.Query(request)
 		defer query.Release()
@@ -403,8 +401,7 @@ func DoWrites(session *gocql.Session, threadResult *results.TestThreadResult, wo
 			if err == nil {
 				rb.IncOps()
 				rb.IncRows()
-				latency := requestEnd.Sub(requestStart)
-				return nil, latency
+				return requestEnd.Sub(requestStart), nil
 			}
 			if retryHandler == "sb" {
 				if queryStr == "" {
@@ -417,7 +414,7 @@ func DoWrites(session *gocql.Session, threadResult *results.TestThreadResult, wo
 				err = handleSbRetryError(queryStr, err, currentAttempts)
 			}
 			if err != nil {
-				return err, time.Duration(0)
+				return time.Duration(0), err
 			}
 			currentAttempts++
 		}
@@ -427,7 +424,7 @@ func DoWrites(session *gocql.Session, threadResult *results.TestThreadResult, wo
 func DoBatchedWrites(session *gocql.Session, threadResult *results.TestThreadResult, workload WorkloadGenerator, rateLimiter RateLimiter, validateData bool) {
 	request := fmt.Sprintf("INSERT INTO %s.%s (pk, ck, v) VALUES (?, ?, ?)", keyspaceName, tableName)
 
-	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (error, time.Duration) {
+	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (time.Duration, error) {
 		batch := session.Batch(gocql.UnloggedBatch)
 		batchSize := 0
 
@@ -436,7 +433,7 @@ func DoBatchedWrites(session *gocql.Session, threadResult *results.TestThreadRes
 		valuesSizesSummary := 0
 		for !workload.IsPartitionDone() && batchSize < rowsPerRequest {
 			if atomic.LoadUint32(&stopAll) != 0 {
-				return errDoNotRegister, 0
+				return time.Duration(0), errDoNotRegister
 			}
 			ck := workload.NextClusteringKey()
 			if batchSize == 0 {
@@ -452,7 +449,7 @@ func DoBatchedWrites(session *gocql.Session, threadResult *results.TestThreadRes
 			batch.Query(request, currentPk, ck, value)
 		}
 		if batchSize == 0 {
-			return errDoNotRegister, 0
+			return time.Duration(0), errDoNotRegister
 		}
 		endingCk := int(startingCk) + batchSize - 1
 		avgValueSize := valuesSizesSummary / batchSize
@@ -467,8 +464,7 @@ func DoBatchedWrites(session *gocql.Session, threadResult *results.TestThreadRes
 			if err == nil {
 				rb.IncOps()
 				rb.AddRows(batchSize)
-				latency := requestEnd.Sub(requestStart)
-				return nil, latency
+				return requestEnd.Sub(requestStart), nil
 			}
 			if retryHandler == "sb" {
 				if queryStr == "" {
@@ -479,15 +475,15 @@ func DoBatchedWrites(session *gocql.Session, threadResult *results.TestThreadRes
 				err = handleSbRetryError(queryStr, err, currentAttempts)
 			}
 			if err != nil {
-				return err, time.Duration(0)
+				return time.Duration(0), err
 			}
 			currentAttempts++
 		}
 	})
 }
 
 func DoCounterUpdates(session *gocql.Session, threadResult *results.TestThreadResult, workload WorkloadGenerator, rateLimiter RateLimiter, _ bool) {
-	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (error, time.Duration) {
+	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (time.Duration, error) {
 		pk := workload.NextPartitionKey()
 		ck := workload.NextClusteringKey()
 
@@ -504,8 +500,7 @@ func DoCounterUpdates(session *gocql.Session, threadResult *results.TestThreadRe
 			if err == nil {
 				rb.IncOps()
 				rb.IncRows()
-				latency := requestEnd.Sub(requestStart)
-				return nil, latency
+				return requestEnd.Sub(requestStart), nil
 			}
 			if retryHandler == "sb" {
 				if queryStr == "" {
@@ -514,7 +509,7 @@ func DoCounterUpdates(session *gocql.Session, threadResult *results.TestThreadRe
 				err = handleSbRetryError(queryStr, err, currentAttempts)
 			}
 			if err != nil {
-				return err, time.Duration(0)
+				return time.Duration(0), err
 			}
 			currentAttempts++
 		}
@@ -562,10 +557,17 @@ func BuildReadQuery(table, orderBy string, session *gocql.Session) *gocql.Query
 	return session.Query(BuildReadQueryString(table, orderBy))
 }
 
-//nolint:lll
-func DoReadsFromTable(table string, session *gocql.Session, threadResult *results.TestThreadResult, workload WorkloadGenerator, rateLimiter RateLimiter, validateData bool) {
+// nolint:gocyclo
+func DoReadsFromTable(
+	table string,
+	session *gocql.Session,
+	threadResult *results.TestThreadResult,
+	workload WorkloadGenerator,
+	rateLimiter RateLimiter,
+	validateData bool,
+) {
 	counter, numOfOrderings := 0, len(selectOrderByParsed)
-	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (error, time.Duration) {
+	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (time.Duration, error) {
 		counter++
 		pk := workload.NextPartitionKey()
 		query := BuildReadQuery(table, selectOrderByParsed[counter%numOfOrderings], session)
@@ -636,7 +638,7 @@ func DoReadsFromTable(table string, session *gocql.Session, threadResult *result
 
 			if err == nil {
 				rb.IncOps()
-				return nil, requestEnd.Sub(requestStart)
+				return requestEnd.Sub(requestStart), nil
 			}
 			if retryHandler == "sb" {
 				if queryStr == "" {
@@ -645,7 +647,7 @@ func DoReadsFromTable(table string, session *gocql.Session, threadResult *result
 				err = handleSbRetryError(queryStr, err, currentAttempts)
 			}
 			if err != nil {
-				return err, time.Duration(0)
+				return time.Duration(0), err
 			}
 			currentAttempts++
 		}
@@ -654,7 +656,7 @@ func DoReadsFromTable(table string, session *gocql.Session, threadResult *result
 
 func DoScanTable(session *gocql.Session, threadResult *results.TestThreadResult, workload WorkloadGenerator, rateLimiter RateLimiter, _ bool) {
 	request := fmt.Sprintf("SELECT * FROM %s.%s WHERE token(pk) >= ? AND token(pk) <= ?", keyspaceName, tableName)
-	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (error, time.Duration) {
+	RunTest(threadResult, workload, rateLimiter, func(rb *results.TestThreadResult) (time.Duration, error) {
 		query := session.Query(request)
 		currentRange := workload.NextTokenRange()
 		currentAttempts := 0
@@ -671,8 +673,7 @@ func DoScanTable(session *gocql.Session, threadResult *results.TestThreadResult,
 
 			if err == nil {
 				rb.IncOps()
-				latency := requestEnd.Sub(requestStart)
-				return nil, latency
+				return requestEnd.Sub(requestStart), nil
 			}
 			if retryHandler == "sb" {
 				if queryStr == "" {
@@ -681,7 +682,7 @@ func DoScanTable(session *gocql.Session, threadResult *results.TestThreadResult,
 				err = handleSbRetryError(queryStr, err, currentAttempts)
 			}
 			if err != nil {
-				return err, time.Duration(0)
+				return time.Duration(0), err
 			}
 			currentAttempts++
 		}

pkg/results/merged_result.go

@@ -130,11 +130,23 @@ func (mr *MergedResult) PrintPartialResult() {
 	if globalResultConfiguration.measureLatency {
 		scale := globalResultConfiguration.hdrLatencyScale
 		latencyHist := mr.getLatencyHistogram()
-		fmt.Printf(withLatencyLineFmt, Round(mr.Time), mr.Operations, mr.ClusteringRows, mr.Errors,
-			Round(time.Duration(latencyHist.Max()*scale)), Round(time.Duration(latencyHist.ValueAtQuantile(99.9)*scale)), Round(time.Duration(latencyHist.ValueAtQuantile(99)*scale)),
-			Round(time.Duration(latencyHist.ValueAtQuantile(95)*scale)), Round(time.Duration(latencyHist.ValueAtQuantile(90)*scale)),
-			Round(time.Duration(latencyHist.ValueAtQuantile(50)*scale)), Round(time.Duration(latencyHist.Mean()*float64(scale))),
-			latencyError)
+		fmt.Printf(
+			withLatencyLineFmt,
+			Round(mr.Time),
+			mr.Operations,
+			mr.ClusteringRows,
+			mr.Errors,
+			Round(
+				time.Duration(latencyHist.Max()*scale),
+			),
+			Round(time.Duration(latencyHist.ValueAtQuantile(99.9)*scale)),
+			Round(time.Duration(latencyHist.ValueAtQuantile(99)*scale)),
+			Round(time.Duration(latencyHist.ValueAtQuantile(95)*scale)),
+			Round(time.Duration(latencyHist.ValueAtQuantile(90)*scale)),
+			Round(time.Duration(latencyHist.ValueAtQuantile(50)*scale)),
+			Round(time.Duration(latencyHist.Mean()*float64(scale))),
+			latencyError,
+		)
 	} else {
 		fmt.Printf(withoutLatencyLineFmt, Round(mr.Time), mr.Operations, mr.ClusteringRows, mr.Errors)
 	}

pkg/workloads/workloads.go

@@ -95,7 +95,12 @@ type RandomUniform struct {
 
 func NewRandomUniform(i int, partitionCount, partitionOffset, clusteringRowCount int64) *RandomUniform {
 	generator := rand.New(rand.NewSource(int64(time.Now().Nanosecond() * (i + 1))))
-	return &RandomUniform{generator, int64(partitionCount), int64(partitionOffset), int64(clusteringRowCount)}
+	return &RandomUniform{
+		Generator:          generator,
+		PartitionCount:     partitionCount,
+		PartitionOffset:    partitionOffset,
+		ClusteringRowCount: clusteringRowCount,
+	}
 }
 
 func (ru *RandomUniform) NextTokenRange() TokenRange {
@@ -138,7 +143,7 @@ type TimeSeriesWrite struct {
 }
 
 func NewTimeSeriesWriter(threadID, threadCount int, pkCount, basicPkOffset, ckCount int64, startTime time.Time, rate int64) *TimeSeriesWrite {
-	period := time.Duration(int64(time.Second.Nanoseconds()) * (pkCount / int64(threadCount)) / rate)
+	period := time.Duration(time.Second.Nanoseconds() * (pkCount / int64(threadCount)) / rate)
 	pkStride := int64(threadCount)
 	pkOffset := int64(threadID) + basicPkOffset
 	return &TimeSeriesWrite{