fix lint

cmd/flags/constants.go

@@ -52,7 +52,7 @@ const (
 	TLSKeyFilePass               = "tls-keyfile-password" //nolint:gosec // Not a credential
 )
 
-func AddFormatTestFlag(flagSet *pflag.FlagSet, val *int) {
+func AddFormatTestFlag(flagSet *pflag.FlagSet, val *int) error {
 	flagSet.IntVar(val, Format, 0, "For testing only")
-	flagSet.MarkHidden(Format)
+	return flagSet.MarkHidden(Format)
 }

cmd/indexList.go

@@ -15,6 +15,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+//nolint:govet // Padding not a concern for a CLI
 var indexListFlags = &struct {
 	clientFlags flags.ClientFlags
 	verbose     bool
@@ -29,7 +30,11 @@ func newIndexListFlagSet() *pflag.FlagSet {
 	flagSet.BoolVarP(&indexListFlags.verbose, flags.Verbose, "v", false, "Print detailed index information.")                                                    //nolint:lll // For readability
 	flagSet.BoolVar(&indexListFlags.yaml, flags.Yaml, false, "Output indexes in yaml format to later be used with \"asvec index create --file <index-def.yaml>") //nolint:lll // For readability
 	flagSet.AddFlagSet(indexListFlags.clientFlags.NewClientFlagSet())
-	flags.AddFormatTestFlag(flagSet, &indexListFlags.format)
+
+	err := flags.AddFormatTestFlag(flagSet, &indexListFlags.format)
+	if err != nil {
+		panic(err)
+	}
 
 	return flagSet
 }
@@ -105,7 +110,7 @@ asvec index ls
 			wg.Wait()
 
 			logger.Debug("server index list", slog.String("response", indexList.String()))
-				
+
 			if indexListFlags.yaml {
 				out, err := protojson.Marshal(indexList)
 				if err != nil {

cmd/node_list.go

@@ -26,7 +26,11 @@ var nodeListFlags = &struct {
 func newNodeListFlagSet() *pflag.FlagSet {
 	flagSet := &pflag.FlagSet{}
 	flagSet.AddFlagSet(nodeListFlags.clientFlags.NewClientFlagSet())
-	flags.AddFormatTestFlag(flagSet, &nodeListFlags.format)
+
+	err := flags.AddFormatTestFlag(flagSet, &nodeListFlags.format)
+	if err != nil {
+		panic(err)
+	}
 
 	return flagSet
 }
@@ -69,15 +73,15 @@ asvec node ls
 
 			logger.Debug("received node states", slog.Any("nodeStates", nodeInfos))
 
-			isLB := isLoadBalancer(nodeListFlags.clientFlags.Seeds, nodeListFlags.clientFlags.Host)
+			isLB := isLoadBalancer(nodeListFlags.clientFlags.Seeds)
 
 			view.PrintNodeInfoList(nodeInfos, isLB, nodeListFlags.format)
 
 			idsVisibleToAllNodes := getIDsVisibleToAllNodes(nodeInfos)
 			idsVisibleToClient := map[uint64]struct{}{}
 
 			for _, nodeState := range nodeInfos {
-				idsVisibleToClient[nodeState.NodeId.GetId()] = struct{}{}
+				idsVisibleToClient[nodeState.NodeID.GetId()] = struct{}{}
 			}
 
 			idsNotVisibleToClient := getNodesNotVisibleToClient(idsVisibleToAllNodes, idsVisibleToClient)
@@ -89,7 +93,8 @@ asvec node ls
 Asvec can't reach: %s
 Possible scenarios:
 1. You should use --host instead of --seeds to indicate you are connection through a load balancer.
-2. Asvec was able to connect to your seeds but the server(s) are returning unreachable endpoints. Did you forget --listener-name.
+2. Asvec was able to connect to your seeds but the server(s) are returning unreachable endpoints.
+   Did you forget --listener-name?
 `, strings.Join(idsNotVisibleToClient, ", "))
 				}
 			}
@@ -111,33 +116,35 @@ Possible scenarios:
 }
 
 func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*writers.NodeInfo {
-	nodeIds := adminClient.NodeIDs(ctx)
+	nodeIDs := adminClient.NodeIDs(ctx)
 
-	logger.Debug("received node ids", slog.Any("nodeIds", nodeIds))
+	logger.Debug("received node ids", slog.Any("nodeIds", nodeIDs))
 
-	if len(nodeIds) == 0 {
+	if len(nodeIDs) == 0 {
 		// Loadbalancer must be enabled. Passing nil to admin client
 		// causes it to fetch info from seed node
-		nodeIds = append(nodeIds, nil)
+		nodeIDs = append(nodeIDs, nil)
 	}
 
-	nodeInfos := make([]*writers.NodeInfo, len(nodeIds))
+	nodeInfos := make([]*writers.NodeInfo, len(nodeIDs))
 	wg := sync.WaitGroup{}
 
-	for i, nodeId := range nodeIds {
+	for i, nodeID := range nodeIDs {
 		wg.Add(1)
+
 		go func(i int, nodeId *protos.NodeId) {
 			defer wg.Done()
 
 			l := logger.With("node", nodeId.String())
 
 			if nodeId == nil {
-				nodeInfos[i] = &writers.NodeInfo{NodeId: &protos.NodeId{Id: 0}}
+				nodeInfos[i] = &writers.NodeInfo{NodeID: &protos.NodeId{Id: 0}}
 			} else {
-				nodeInfos[i] = &writers.NodeInfo{NodeId: nodeId}
+				nodeInfos[i] = &writers.NodeInfo{NodeID: nodeId}
 			}
 
 			wg.Add(1)
+
 			go func() {
 				defer wg.Done()
 
@@ -149,6 +156,7 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 					)
 
 					view.Errorf("Failed to get connected endpoint from node %s: %s", nodeId.String(), err)
+
 					return
 				}
 
@@ -158,6 +166,7 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 			}()
 
 			wg.Add(1)
+
 			go func() {
 				defer wg.Done()
 
@@ -169,6 +178,7 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 					)
 
 					view.Errorf("Failed to get cluster endpoints from node %s: %s", nodeId.String(), err)
+
 					return
 				}
 
@@ -178,6 +188,7 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 			}()
 
 			wg.Add(1)
+
 			go func() {
 				defer wg.Done()
 
@@ -189,6 +200,7 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 					)
 
 					view.Errorf("Failed to get clustering state from node %s: %s", nodeId.String(), err)
+
 					return
 				}
 
@@ -198,6 +210,7 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 			}()
 
 			wg.Add(1)
+
 			go func() {
 				defer wg.Done()
 
@@ -209,14 +222,15 @@ func getAllNodesInfo(ctx context.Context, adminClient *avs.AdminClient) []*write
 					)
 
 					view.Errorf("Failed to get about info from node %s: %s", nodeId.String(), err)
+
 					return
 				}
 
 				l.Debug("received about info", slog.Any("about", about))
 
 				nodeInfos[i].About = about
 			}()
-		}(i, nodeId)
+		}(i, nodeID)
 	}
 
 	wg.Wait()
@@ -228,8 +242,8 @@ func getIDsVisibleToAllNodes(nodeInfos []*writers.NodeInfo) map[uint64]struct{}
 	idsVisibleToAllNodes := map[uint64]struct{}{}
 
 	for _, nodeState := range nodeInfos {
-		for toId := range nodeState.Endpoints.GetEndpoints() {
-			idsVisibleToAllNodes[toId] = struct{}{}
+		for toID := range nodeState.Endpoints.GetEndpoints() {
+			idsVisibleToAllNodes[toID] = struct{}{}
 		}
 	}
 
@@ -240,21 +254,21 @@ func getIDsVisibleToEachNode(nodeInfos []*writers.NodeInfo) map[uint64]map[uint6
 	idsVisibleToIndividualNodes := map[uint64]map[uint64]struct{}{} // using map as set
 
 	for _, nodeState := range nodeInfos {
-		fromId := nodeState.NodeId.GetId()
+		fromID := nodeState.NodeID.GetId()
 
-		for toId := range nodeState.Endpoints.GetEndpoints() {
-			if _, ok := idsVisibleToIndividualNodes[fromId]; !ok {
-				idsVisibleToIndividualNodes[fromId] = map[uint64]struct{}{}
+		for toID := range nodeState.Endpoints.GetEndpoints() {
+			if _, ok := idsVisibleToIndividualNodes[fromID]; !ok {
+				idsVisibleToIndividualNodes[fromID] = map[uint64]struct{}{}
 			}
 
-			idsVisibleToIndividualNodes[fromId][toId] = struct{}{}
+			idsVisibleToIndividualNodes[fromID][toID] = struct{}{}
 		}
 	}
 
 	return idsVisibleToIndividualNodes
 }
 
-func getNodesNotVisibleToClient(idsVisibleToAllNodes map[uint64]struct{}, idsVisibleToClient map[uint64]struct{}) []string {
+func getNodesNotVisibleToClient(idsVisibleToAllNodes, idsVisibleToClient map[uint64]struct{}) []string {
 	nodesNotVisibleToClient := []string{}
 
 	for id := range idsVisibleToAllNodes {
@@ -266,17 +280,20 @@ func getNodesNotVisibleToClient(idsVisibleToAllNodes map[uint64]struct{}, idsVis
 	return nodesNotVisibleToClient
 }
 
-func getNodesNotVisibleToEachNode(idsVisibleToEachNode map[uint64]map[uint64]struct{}, idsVisibleToAllNodes map[uint64]struct{}) map[uint64][]string {
+func getNodesNotVisibleToEachNode(
+	idsVisibleToEachNode map[uint64]map[uint64]struct{},
+	idsVisibleToAllNodes map[uint64]struct{},
+) map[uint64][]string {
 	nodesNotVisibleToEachNode := map[uint64][]string{}
 
 	for id := range idsVisibleToAllNodes {
-		for fromId, visibleFromNode := range idsVisibleToEachNode {
+		for fromID, visibleFromNode := range idsVisibleToEachNode {
 			if _, ok := visibleFromNode[id]; !ok {
-				if _, ok := nodesNotVisibleToEachNode[fromId]; !ok {
-					nodesNotVisibleToEachNode[fromId] = []string{}
+				if _, ok := nodesNotVisibleToEachNode[fromID]; !ok {
+					nodesNotVisibleToEachNode[fromID] = []string{}
 				}
 
-				nodesNotVisibleToEachNode[fromId] = append(nodesNotVisibleToEachNode[fromId], strconv.FormatUint(id, 10))
+				nodesNotVisibleToEachNode[fromID] = append(nodesNotVisibleToEachNode[fromID], strconv.FormatUint(id, 10))
 			}
 		}
 	}

cmd/rolesList.go

@@ -11,16 +11,20 @@ import (
 )
 
 var rolesListFlags = &struct {
-	format      int
 	clientFlags flags.ClientFlags
+	format      int
 }{
 	clientFlags: *flags.NewClientFlags(),
 }
 
 func newRoleListFlagSet() *pflag.FlagSet {
 	flagSet := &pflag.FlagSet{}
 
-	flags.AddFormatTestFlag(flagSet, &rolesListFlags.format)
+	err := flags.AddFormatTestFlag(flagSet, &rolesListFlags.format)
+	if err != nil {
+		panic(err)
+	}
+
 	flagSet.AddFlagSet(rolesListFlags.clientFlags.NewClientFlagSet())
 
 	return flagSet

cmd/root.go

@@ -83,7 +83,7 @@ asvec --help
 
 		return persistedErr
 	},
-	PersistentPostRun: func(cmd *cobra.Command, _ []string) {
+	PersistentPostRun: func(_ *cobra.Command, _ []string) {
 		code := errCode.Load()
 
 		if code != 0 {

cmd/userList.go

@@ -11,18 +11,22 @@ import (
 )
 
 var userListFlags = &struct {
-	format      int
 	clientFlags flags.ClientFlags
+	format      int
 }{
 	clientFlags: *flags.NewClientFlags(),
 }
 
 func newUserListFlagSet() *pflag.FlagSet {
 	flagSet := &pflag.FlagSet{}
 
-	flags.AddFormatTestFlag(flagSet, &userListFlags.format)
 	flagSet.AddFlagSet(userListFlags.clientFlags.NewClientFlagSet())
 
+	err := flags.AddFormatTestFlag(flagSet, &userListFlags.format)
+	if err != nil {
+		panic(err)
+	}
+
 	return flagSet
 }
 

cmd/utils.go

@@ -29,7 +29,7 @@ func passwordPrompt(prompt string) (string, error) {
 
 func createClientFromFlags(clientFlags *flags.ClientFlags) (*avs.AdminClient, error) {
 	hosts := parseBothHostSeedsFlag(clientFlags.Seeds, clientFlags.Host)
-	isLoadBalancer := isLoadBalancer(clientFlags.Seeds, clientFlags.Host)
+	isLoadBalancer := isLoadBalancer(clientFlags.Seeds)
 
 	ctx, cancel := context.WithTimeout(context.Background(), clientFlags.Timeout)
 	defer cancel()
@@ -88,8 +88,8 @@ func parseBothHostSeedsFlag(seeds *flags.SeedsSliceFlag, host *flags.HostPortFla
 	return hosts
 }
 
-func isLoadBalancer(seeds *flags.SeedsSliceFlag, host *flags.HostPortFlag) bool {
-	return len(seeds.Seeds) <= 0
+func isLoadBalancer(seeds *flags.SeedsSliceFlag) bool {
+	return len(seeds.Seeds) == 0
 }
 
 func nsAndSetString(namespace string, sets []string) string {

cmd/view.go

@@ -20,7 +20,7 @@ type View struct {
 	logger *slog.Logger
 }
 
-func NewView(out io.Writer, err io.Writer, logger *slog.Logger) *View {
+func NewView(out, err io.Writer, logger *slog.Logger) *View {
 	return &View{out: out, err: err, logger: logger}
 }
 

cmd/writers/nodeList.go

@@ -9,7 +9,7 @@ import (
 )
 
 type NodeInfo struct {
-	NodeId            *protos.NodeId
+	NodeID            *protos.NodeId
 	ConnectedEndpoint *protos.ServerEndpoint
 	Endpoints         *protos.ClusterNodeEndpoints
 	State             *protos.ClusteringState
@@ -45,7 +45,7 @@ func NewNodeTableWriter(writer io.Writer, isLB bool, logger *slog.Logger) *NodeT
 }
 
 func (itw *NodeTableWriter) AppendNodeRow(node *NodeInfo) {
-	var id = node.NodeId.GetId()
+	var id = node.NodeID.GetId()
 
 	row := table.Row{}
 

cmd/writers/utils.go

@@ -8,16 +8,6 @@ import (
 	"github.com/aerospike/avs-client-go/protos"
 )
 
-func formatNodeIdList(nodeIds []*protos.NodeId) string {
-	ids := make([]string, 0, len(nodeIds))
-
-	for _, nodeId := range nodeIds {
-		ids = append(ids, fmt.Sprintf("%d", nodeId.GetId()))
-	}
-
-	return strings.Join(ids, "\n")
-}
-
 func formatEndpoint(nodeEndpoint *protos.ServerEndpoint) string {
 	if nodeEndpoint == nil {
 		return "N/A"
@@ -26,7 +16,7 @@ func formatEndpoint(nodeEndpoint *protos.ServerEndpoint) string {
 	return fmt.Sprintf("%s:%d", nodeEndpoint.GetAddress(), nodeEndpoint.GetPort())
 }
 
-func formatEndpoints(nodeId uint64, nodeEndpoints map[uint64]*protos.ServerEndpointList) string {
+func formatEndpoints(nodeID uint64, nodeEndpoints map[uint64]*protos.ServerEndpointList) string {
 	if len(nodeEndpoints) == 0 {
 		return "N/A"
 	}
@@ -44,7 +34,7 @@ func formatEndpoints(nodeId uint64, nodeEndpoints map[uint64]*protos.ServerEndpo
 	})
 
 	for _, id := range ids {
-		if nodeId == id {
+		if nodeID == id {
 			// Node endpoint include themselves. Remove it from output
 			continue
 		}