Fix linters complaints

Author: dkropachev

cluster_test.go

@@ -46,8 +46,14 @@ func TestNewCluster_Defaults(t *testing.T) {
 	assertEqual(t, "cluster config reconnect interval", 60*time.Second, cfg.ReconnectInterval)
 	assertTrue(t, "cluster config conviction policy",
 		reflect.DeepEqual(&SimpleConvictionPolicy{}, cfg.ConvictionPolicy))
-	assertTrue(t, "cluster config reconnection policy",
-		reflect.DeepEqual(&ConstantReconnectionPolicy{MaxRetries: 3, Interval: 1 * time.Second}, cfg.ReconnectionPolicy))
+	assertTrue(
+		t,
+		"cluster config reconnection policy",
+		reflect.DeepEqual(
+			&ConstantReconnectionPolicy{MaxRetries: 3, Interval: 1 * time.Second},
+			cfg.ReconnectionPolicy,
+		),
+	)
 }
 
 func TestNewCluster_WithHosts(t *testing.T) {

common_test.go

@@ -40,13 +40,17 @@ import (
 )
 
 var (
-	flagCluster      = flag.String("cluster", "127.0.0.1", "a comma-separated list of host:port tuples")
-	flagProto        = flag.Int("proto", 0, "protcol version")
-	flagCQL          = flag.String("cql", "3.0.0", "CQL version")
-	flagRF           = flag.Int("rf", 1, "replication factor for test keyspace")
-	clusterSize      = flag.Int("clusterSize", 1, "the expected size of the cluster")
-	flagRetry        = flag.Int("retries", 5, "number of times to retry queries")
-	flagAutoWait     = flag.Duration("autowait", 1000*time.Millisecond, "time to wait for autodiscovery to fill the hosts poll")
+	flagCluster  = flag.String("cluster", "127.0.0.1", "a comma-separated list of host:port tuples")
+	flagProto    = flag.Int("proto", 0, "protcol version")
+	flagCQL      = flag.String("cql", "3.0.0", "CQL version")
+	flagRF       = flag.Int("rf", 1, "replication factor for test keyspace")
+	clusterSize  = flag.Int("clusterSize", 1, "the expected size of the cluster")
+	flagRetry    = flag.Int("retries", 5, "number of times to retry queries")
+	flagAutoWait = flag.Duration(
+		"autowait",
+		1000*time.Millisecond,
+		"time to wait for autodiscovery to fill the hosts poll",
+	)
 	flagRunSslTest   = flag.Bool("runssl", false, "Set to true to run ssl test")
 	flagRunAuthTest  = flag.Bool("runauth", false, "Set to true to run authentication test")
 	flagCompressTest = flag.String("compressor", "no-compression", "compressor to use")

conn.go

@@ -217,7 +217,12 @@ func (s *Session) connect(ctx context.Context, host *HostInfo, errorHandler Conn
 }
 
 // dial establishes a connection to a Cassandra node and notifies the session's connectObserver.
-func (s *Session) dial(ctx context.Context, host *HostInfo, connConfig *ConnConfig, errorHandler ConnErrorHandler) (*Conn, error) {
+func (s *Session) dial(
+	ctx context.Context,
+	host *HostInfo,
+	connConfig *ConnConfig,
+	errorHandler ConnErrorHandler,
+) (*Conn, error) {
 	var obs ObservedConnect
 	if s.connectObserver != nil {
 		obs.Host = host
@@ -238,7 +243,12 @@ func (s *Session) dial(ctx context.Context, host *HostInfo, connConfig *ConnConf
 // dialWithoutObserver establishes connection to a Cassandra node.
 //
 // dialWithoutObserver does not notify the connection observer, so you most probably want to call dial() instead.
-func (s *Session) dialWithoutObserver(ctx context.Context, host *HostInfo, cfg *ConnConfig, errorHandler ConnErrorHandler) (*Conn, error) {
+func (s *Session) dialWithoutObserver(
+	ctx context.Context,
+	host *HostInfo,
+	cfg *ConnConfig,
+	errorHandler ConnErrorHandler,
+) (*Conn, error) {
 	dialedHost, err := cfg.HostDialer.DialHost(ctx, host)
 	if err != nil {
 		return nil, err
@@ -385,7 +395,11 @@ func (s *startupCoordinator) setupConn(ctx context.Context) error {
 	return nil
 }
 
-func (s *startupCoordinator) write(ctx context.Context, frame frameBuilder, startupCompleted *atomic.Bool) (frame, error) {
+func (s *startupCoordinator) write(
+	ctx context.Context,
+	frame frameBuilder,
+	startupCompleted *atomic.Bool,
+) (frame, error) {
 	select {
 	case s.frameTicker <- struct{}{}:
 	case <-ctx.Done():
@@ -414,7 +428,11 @@ func (s *startupCoordinator) options(ctx context.Context, startupCompleted *atom
 	return s.startup(ctx, supported.supported, startupCompleted)
 }
 
-func (s *startupCoordinator) startup(ctx context.Context, supported map[string][]string, startupCompleted *atomic.Bool) error {
+func (s *startupCoordinator) startup(
+	ctx context.Context,
+	supported map[string][]string,
+	startupCompleted *atomic.Bool,
+) error {
 	m := map[string]string{
 		"CQL_VERSION":    s.conn.cfg.CQLVersion,
 		"DRIVER_NAME":    driverName,
@@ -457,7 +475,11 @@ func (s *startupCoordinator) startup(ctx context.Context, supported map[string][
 	}
 }
 
-func (s *startupCoordinator) authenticateHandshake(ctx context.Context, authFrame *authenticateFrame, startupCompleted *atomic.Bool) error {
+func (s *startupCoordinator) authenticateHandshake(
+	ctx context.Context,
+	authFrame *authenticateFrame,
+	startupCompleted *atomic.Bool,
+) error {
 	if s.conn.auth == nil {
 		return fmt.Errorf("authentication required (using %q)", authFrame.class)
 	}
@@ -592,7 +614,7 @@ func (c *Conn) heartBeat(ctx context.Context) {
 
 	for {
 		if failures > 5 {
-			c.closeWithError(fmt.Errorf("gocql: heartbeat failed"))
+			c.closeWithError(errors.New("gocql: heartbeat failed"))
 			return
 		}
 
@@ -659,10 +681,10 @@ func (c *Conn) processFrame(ctx context.Context, r io.Reader) error {
 
 	if c.frameObserver != nil {
 		c.frameObserver.ObserveFrameHeader(context.Background(), ObservedFrameHeader{
-			Version: protoVersion(head.version),
+			Version: head.version,
 			Flags:   head.flags,
 			Stream:  int16(head.stream),
-			Opcode:  frameOp(head.op),
+			Opcode:  head.op,
 			Length:  int32(head.length),
 			Start:   headStartTime,
 			End:     headEndTime,
@@ -822,7 +844,7 @@ func (c *Conn) recvPartialFrames(dst *bytes.Buffer, bytesToRead int) error {
 		}
 
 		if isSelfContained {
-			return fmt.Errorf("gocql: received self-contained segment, but expected not")
+			return errors.New("gocql: received self-contained segment, but expected not")
 		}
 
 		if totalLength := dst.Len() + len(frame); totalLength > dst.Cap() {
@@ -885,7 +907,7 @@ func (c *connReader) Read(p []byte) (n int, err error) {
 		}
 	}
 
-	return
+	return n, err
 }
 
 func (c *connReader) Write(b []byte) (n int, err error) {
@@ -1177,7 +1199,12 @@ func (c *Conn) exec(ctx context.Context, req frameBuilder, tracer Tracer) (*fram
 	return c.execInternal(ctx, req, tracer, true)
 }
 
-func (c *Conn) execInternal(ctx context.Context, req frameBuilder, tracer Tracer, startupCompleted bool) (*framer, error) {
+func (c *Conn) execInternal(
+	ctx context.Context,
+	req frameBuilder,
+	tracer Tracer,
+	startupCompleted bool,
+) (*framer, error) {
 	if ctxErr := ctx.Err(); ctxErr != nil {
 		return nil, ctxErr
 	}
@@ -1394,7 +1421,12 @@ type inflightPrepare struct {
 	preparedStatment *preparedStatment
 }
 
-func (c *Conn) prepareStatement(ctx context.Context, stmt string, tracer Tracer, keyspace string) (*preparedStatment, error) {
+func (c *Conn) prepareStatement(
+	ctx context.Context,
+	stmt string,
+	tracer Tracer,
+	keyspace string,
+) (*preparedStatment, error) {
 	stmtCacheKey := c.session.stmtsLRU.keyFor(c.host.HostID(), keyspace, stmt)
 	flight, ok := c.session.stmtsLRU.execIfMissing(stmtCacheKey, func(lru *lru.Cache) *inflightPrepare {
 		flight := &inflightPrepare{
@@ -1546,7 +1578,9 @@ func (c *Conn) executeQuery(ctx context.Context, qry *Query) *Iter {
 		}
 
 		if len(values) != info.request.actualColCount {
-			return &Iter{err: fmt.Errorf("gocql: expected %d values send got %d", info.request.actualColCount, len(values))}
+			return &Iter{
+				err: fmt.Errorf("gocql: expected %d values send got %d", info.request.actualColCount, len(values)),
+			}
 		}
 
 		params.values = make([]queryValues, len(values))
@@ -1560,7 +1594,8 @@ func (c *Conn) executeQuery(ctx context.Context, qry *Query) *Iter {
 		}
 
 		// if the metadata was not present in the response then we should not skip it
-		params.skipMeta = !(c.session.cfg.DisableSkipMetadata || qry.disableSkipMetadata) && info != nil && info.response.flags&flagNoMetaData == 0
+		params.skipMeta = !(c.session.cfg.DisableSkipMetadata || qry.disableSkipMetadata) && info != nil &&
+			info.response.flags&flagNoMetaData == 0
 
 		frame = &writeExecuteFrame{
 			preparedID:       info.id,
@@ -1791,7 +1826,14 @@ func (c *Conn) executeBatch(ctx context.Context, batch *Batch) *Iter {
 			}
 
 			if len(values) != info.request.actualColCount {
-				return &Iter{err: fmt.Errorf("gocql: batch statement %d expected %d values send got %d", i, info.request.actualColCount, len(values))}
+				return &Iter{
+					err: fmt.Errorf(
+						"gocql: batch statement %d expected %d values send got %d",
+						i,
+						info.request.actualColCount,
+						len(values),
+					),
+				}
 			}
 
 			b.preparedID = info.id
@@ -1876,7 +1918,8 @@ func (c *Conn) querySystemPeers(ctx context.Context, version cassVersion) *Iter
 
 		err := iter.checkErrAndNotFound()
 		if err != nil {
-			if errFrame, ok := err.(errorFrame); ok && errFrame.code == ErrCodeInvalid { // system.peers_v2 not found, try system.peers
+			if errFrame, ok := err.(errorFrame); ok &&
+				errFrame.code == ErrCodeInvalid { // system.peers_v2 not found, try system.peers
 				c.mu.Lock()
 				c.isSchemaV2 = false
 				c.mu.Unlock()
@@ -1908,17 +1951,19 @@ func (c *Conn) awaitSchemaAgreement(ctx context.Context) (err error) {
 
 		versions = make(map[string]struct{})
 
-		rows, err := iter.SliceMap()
+		var rows []map[string]interface{}
+		rows, err = iter.SliceMap()
 		if err != nil {
 			goto cont
 		}
 
 		for _, row := range rows {
-			h, err := NewHostInfo(c.host.ConnectAddress(), c.session.cfg.Port)
+			var host *HostInfo
+			host, err = NewHostInfo(c.host.ConnectAddress(), c.session.cfg.Port)
 			if err != nil {
 				goto cont
 			}
-			host, err := c.session.hostInfoFromMap(row, h)
+			host, err = c.session.hostInfoFromMap(row, host)
 			if err != nil {
 				goto cont
 			}

connectionpool.go

@@ -240,14 +240,14 @@ func (p *policyConnPool) getPool(host *HostInfo) (pool *hostConnPool, ok bool) {
 	p.mu.RLock()
 	pool, ok = p.hostConnPools[hostID]
 	p.mu.RUnlock()
-	return
+	return pool, ok
 }
 
 func (p *policyConnPool) getPoolByHostID(hostID string) (pool *hostConnPool, ok bool) {
 	p.mu.RLock()
 	pool, ok = p.hostConnPools[hostID]
 	p.mu.RUnlock()
-	return
+	return pool, ok
 }
 
 func (p *policyConnPool) Close() {
@@ -322,7 +322,6 @@ func (h *hostConnPool) String() string {
 
 func newHostConnPool(session *Session, host *HostInfo, port, size int,
 	keyspace string) *hostConnPool {
-
 	pool := &hostConnPool{
 		session:  session,
 		host:     host,

control.go

@@ -213,12 +213,12 @@ func parseProtocolFromError(err error) int {
 		return 0
 	}
 
-	max, err := strconv.Atoi(matches[0][1])
+	val, err := strconv.Atoi(matches[0][1])
 	if err != nil {
 		return 0
 	}
 
-	return max
+	return val
 }
 
 func (c *controlConn) discoverProtocol(hosts []*HostInfo) (int, error) {
@@ -272,7 +272,12 @@ func (c *controlConn) connect(hosts []*HostInfo) error {
 	for _, host := range hosts {
 		conn, err = c.session.dial(c.session.ctx, host, &cfg, c)
 		if err != nil {
-			c.session.logger.Printf("gocql: unable to dial control conn %v:%v: %v\n", host.ConnectAddress(), host.Port(), err)
+			c.session.logger.Printf(
+				"gocql: unable to dial control conn %v:%v: %v\n",
+				host.ConnectAddress(),
+				host.Port(),
+				err,
+			)
 			continue
 		}
 		err = c.setupConn(conn)
@@ -434,7 +439,12 @@ func (c *controlConn) attemptReconnectToAnyOfHosts(hosts []*HostInfo) (*Conn, er
 	for _, host := range hosts {
 		conn, err = c.session.connect(c.session.ctx, host, c)
 		if err != nil {
-			c.session.logger.Printf("gocql: unable to dial control conn %v:%v: %v\n", host.ConnectAddress(), host.Port(), err)
+			c.session.logger.Printf(
+				"gocql: unable to dial control conn %v:%v: %v\n",
+				host.ConnectAddress(),
+				host.Port(),
+				err,
+			)
 			continue
 		}
 		err = c.setupConn(conn)
@@ -532,7 +542,7 @@ func (c *controlConn) query(statement string, values ...interface{}) (iter *Iter
 		}
 	}
 
-	return
+	return iter
 }
 
 func (c *controlConn) awaitSchemaAgreement() error {

errors.go

@@ -148,7 +148,12 @@ type RequestErrUnavailable struct {
 }
 
 func (e *RequestErrUnavailable) String() string {
-	return fmt.Sprintf("[request_error_unavailable consistency=%s required=%d alive=%d]", e.Consistency, e.Required, e.Alive)
+	return fmt.Sprintf(
+		"[request_error_unavailable consistency=%s required=%d alive=%d]",
+		e.Consistency,
+		e.Required,
+		e.Alive,
+	)
 }
 
 type ErrorMap map[string]uint16

example_nulls_test.go

@@ -65,7 +65,6 @@ func Example_nulls() {
 		} else {
 			fmt.Printf("Row %d is null\n", id)
 		}
-
 	}
 	err = scanner.Err()
 	if err != nil {