all: fix errors reported by 'go vet'

.github/workflows/ci.yml

@@ -34,7 +34,7 @@ jobs:
 
       - name: Test
         run: |
-          make test
+          make fmtchk vet test
 
       - name: build
         run: |

Makefile

@@ -62,7 +62,11 @@ generate:
 
 .PHONY: fmtcheck
 fmtchk:
-	$Qexit $(shell gofmt -l . | grep -v '^vendor' | wc -l)
+	@OUTPUT=$$(gofmt -l . | grep -v vendor/); \
+		if [ -n "$$OUTPUT" ]; then \
+			echo "Some files were not gofmtted:\\n$$OUTPUT"; \
+			exit 1; \
+		fi
 
 .PHONY: fmtfix
 fmtfix:
@@ -75,4 +79,3 @@ test:
 .PHONY: bench
 bench:
 	$Qgo test $(GOTESTFLAGS) -bench .
-

pkg/cmd/ctlstore/main.go

@@ -632,7 +632,7 @@ func newReflector(cliCfg reflectorCliConfig, isSupervisor bool, i int) (*reflect
 		events.Log("DEPRECATION NOTICE: use --disable-ecs-behavior instead of --disable to control this ledger monitor behavior")
 	}
 	id := fmt.Sprintf("%s-%d", path.Base(cliCfg.LDBPath), i)
-	l := events.NewLogger(events.DefaultHandler).With(events.Args{{"id", id}})
+	l := events.NewLogger(events.DefaultHandler).With(events.Args{{Name: "id", Value: id}})
 	l.EnableDebug = cliCfg.Debug
 	return reflectorpkg.ReflectorFromConfig(reflectorpkg.ReflectorConfig{
 		LDBPath:         cliCfg.LDBPath,

pkg/event/changelog_test.go

@@ -161,16 +161,16 @@ func TestChangelog(t *testing.T) {
 				rotateAfter:      test.rotateAfter,
 				rotateAfterBytes: test.rotateAfterBytes,
 			}
+			var writeErr error
 			var wg sync.WaitGroup
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
 				err := flw.writeN(ctx, test.numEvents)
 				if err != nil {
-					t.Fatal(err)
+					writeErr = err
 				}
 			}()
-			defer wg.Wait()
 			for i := 0; i < test.numEvents; i++ {
 				event, err := cl.next(ctx)
 				if err != nil {
@@ -182,6 +182,10 @@ func TestChangelog(t *testing.T) {
 			if test.mustRotateN > 0 {
 				require.EqualValues(t, test.mustRotateN, atomic.LoadInt64(&flw.rotations))
 			}
+			wg.Wait()
+			if writeErr != nil {
+				t.Fatal(writeErr)
+			}
 		})
 	}
 }

pkg/event/entry.go

@@ -2,7 +2,8 @@ package event
 
 // entry represents a single row in the changelog
 // e.g.
-//   {"seq":1,"family":"fam","table":"foo","key":[{"name":"id","type":"int","value":1}]}
+//
+//	{"seq":1,"family":"fam","table":"foo","key":[{"name":"id","type":"int","value":1}]}
 type entry struct {
 	Seq    int64  `json:"seq"`
 	Family string `json:"family"`

pkg/executive/db_executive.go

@@ -166,7 +166,7 @@ func (e *dbExecutive) CreateTable(familyName string, tableName string, fieldName
 
 	err = tbl.Validate()
 	if err != nil {
-		return &errs.BadRequestError{err.Error()}
+		return &errs.BadRequestError{Err: err.Error()}
 	}
 
 	ddl, err := tbl.AsCreateTableDDL()

pkg/executive/dml_ledger_writer_test.go

@@ -23,6 +23,7 @@ func TestDMLLogWriterAdd(t *testing.T) {
 
 	for i, testCase := range suite {
 		testName := fmt.Sprintf("[%d] %s", i, testCase.desc)
+		statements := testCase.statements
 		t.Run(testName, func(t *testing.T) {
 			t.Parallel()
 			ctx := context.Background()
@@ -42,7 +43,7 @@ func TestDMLLogWriterAdd(t *testing.T) {
 			defer w.Close()
 
 			seqs := []schema.DMLSequence{}
-			for _, stString := range testCase.statements {
+			for _, stString := range statements {
 				seq, err := w.Add(ctx, stString)
 				if err != nil {
 					t.Fatalf("Unexpected error: %v", err)
@@ -81,7 +82,7 @@ func TestDMLLogWriterAdd(t *testing.T) {
 
 			i := 0
 			for rows.Next() {
-				if i+1 > len(testCase.statements) {
+				if i+1 > len(statements) {
 					t.Errorf("Scanned more statements than expected")
 					break
 				}
@@ -98,7 +99,7 @@ func TestDMLLogWriterAdd(t *testing.T) {
 					t.Errorf("Expected %v, got %v", want, got)
 				}
 
-				if want, got := testCase.statements[i], rowStmt; want != got {
+				if want, got := statements[i], rowStmt; want != got {
 					t.Errorf("Expected %v, got %v", want, got)
 				}
 

pkg/executive/executive.go

@@ -78,7 +78,7 @@ func newMutationRequest(famName schema.FamilyName, req ExecutiveMutationRequest)
 }
 
 // Returns the request Values as a slice in the order specified by the
-//fieldOrder param. An error will be returned if a field is missing.
+// fieldOrder param. An error will be returned if a field is missing.
 func (r *mutationRequest) valuesByOrder(fieldOrder []schema.FieldName) ([]interface{}, error) {
 	values := []interface{}{}
 	for _, fn := range fieldOrder {

pkg/ldbwriter/ldb_writer_with_changelog.go

@@ -19,7 +19,6 @@ type LDBWriterWithChangelog struct {
 	Seq             int64
 }
 
-//
 // NOTE: How does the changelog work?
 //
 // This is sort of the crux of how the changelog comes together. The Reflector
@@ -33,7 +32,6 @@ type LDBWriterWithChangelog struct {
 // This is pretty complex, but after enumerating about 8 different options, it
 // ended up actually being the most simple. Other options involved not-so-great
 // options like parsing SQL or maintaining triggers on every table.
-//
 func (w *LDBWriterWithChangelog) ApplyDMLStatement(ctx context.Context, statement schema.DMLStatement) error {
 	err := w.LdbWriter.ApplyDMLStatement(ctx, statement)
 	if err != nil {

pkg/reflector/reflector_ctl.go

@@ -137,14 +137,17 @@ func (r *ReflectorCtl) lifecycle(appCtx context.Context) {
 	for {
 		select {
 		case <-appCtx.Done():
-			// the application is quitting
+			// the application is quitting - cancel the reflector
 			events.Log("reflectorCtl stopping due to context err=%v", appCtx.Err())
+			if cancel != nil {
+				cancel()
+			}
 			return
 		case msg := <-r.messages:
 			// another goroutine has asked for the reflector to either
 			// be started or stopped.
 			switch msg.desired {
-			case true:
+			case true: // start the reflector
 				if !running {
 					ctx, cancel = context.WithCancel(appCtx)
 					wg.Add(1)
@@ -155,7 +158,7 @@ func (r *ReflectorCtl) lifecycle(appCtx context.Context) {
 					running = true
 				}
 				msg.sendErr(appCtx, nil)
-			case false:
+			case false: // stop the reflector
 				if running {
 					cancel()
 					done := make(chan struct{})

pkg/reflector/reflector_ctl_test.go

@@ -84,11 +84,12 @@ func TestReflectorCtl(t *testing.T) {
 // context root.
 func TestReflectorCtlContext(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	ctx2, _ := context.WithCancel(ctx)
+	ctx2, cancel2 := context.WithCancel(ctx)
+	defer cancel2()
 	cancel()
 	select {
 	case <-ctx2.Done():
 	default:
-		t.Fatal("context should have been canceled")
+		t.Fatal("child context should have been canceled")
 	}
 }

pkg/reflector/shovel.go

@@ -55,6 +55,11 @@ func (s *shovel) Start(ctx context.Context) error {
 		safeCancel()
 		var sctx context.Context
 		sctx, cancel = context.WithTimeout(ctx, s.pollTimeout)
+		safeCancel = func() {
+			if cancel != nil {
+				cancel()
+			}
+		}
 
 		stats.Incr("shovel.loop_enter")
 		s.logger().Debug("shovel polling...")

pkg/sqlgen/sqlgen_test.go

@@ -25,9 +25,9 @@ func TestMetaTableAsCreateTableDDL(t *testing.T) {
 		FamilyName: famName,
 		TableName:  tblName,
 		Fields: []schema.NamedFieldType{
-			{schema.FieldName{Name: "field1"}, schema.FTString},
-			{schema.FieldName{Name: "field2"}, schema.FTInteger},
-			{schema.FieldName{Name: "field3"}, schema.FTDecimal},
+			{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+			{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTInteger},
+			{Name: schema.FieldName{Name: "field3"}, FieldType: schema.FTDecimal},
 		},
 		KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}}},
 	}
@@ -176,10 +176,10 @@ func TestMetaTableUpsertDML(t *testing.T) {
 					FamilyName: famName,
 					TableName:  tblName,
 					Fields: []schema.NamedFieldType{
-						{schema.FieldName{Name: "field1"}, schema.FTString},
-						{schema.FieldName{Name: "field2"}, schema.FTString},
-						{schema.FieldName{Name: "field3"}, schema.FTInteger},
-						{schema.FieldName{Name: "field4"}, schema.FTByteString},
+						{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field3"}, FieldType: schema.FTInteger},
+						{Name: schema.FieldName{Name: "field4"}, FieldType: schema.FTByteString},
 					},
 					KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}, {Name: "field2"}}},
 				}
@@ -200,9 +200,9 @@ func TestMetaTableUpsertDML(t *testing.T) {
 					FamilyName: famName,
 					TableName:  tblName,
 					Fields: []schema.NamedFieldType{
-						{schema.FieldName{Name: "field1"}, schema.FTString},
-						{schema.FieldName{Name: "field2"}, schema.FTString},
-						{schema.FieldName{Name: "field3"}, schema.FTInteger},
+						{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field3"}, FieldType: schema.FTInteger},
 					},
 					KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}, {Name: "field2"}}},
 				}
@@ -222,9 +222,9 @@ func TestMetaTableUpsertDML(t *testing.T) {
 					FamilyName: famName,
 					TableName:  tblName,
 					Fields: []schema.NamedFieldType{
-						{schema.FieldName{Name: "field1"}, schema.FTString},
-						{schema.FieldName{Name: "field2"}, schema.FTString},
-						{schema.FieldName{Name: "field3"}, schema.FTInteger},
+						{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field3"}, FieldType: schema.FTInteger},
 					},
 					KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}, {Name: "field2"}}},
 				}
@@ -261,9 +261,9 @@ func TestMetaTableDeleteDML(t *testing.T) {
 					FamilyName: famName,
 					TableName:  tblName,
 					Fields: []schema.NamedFieldType{
-						{schema.FieldName{Name: "field1"}, schema.FTString},
-						{schema.FieldName{Name: "field2"}, schema.FTByteString},
-						{schema.FieldName{Name: "field3"}, schema.FTInteger},
+						{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTByteString},
+						{Name: schema.FieldName{Name: "field3"}, FieldType: schema.FTInteger},
 					},
 					KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}, {Name: "field2"}}},
 				}
@@ -285,8 +285,8 @@ func TestMetaTableDeleteDML(t *testing.T) {
 					FamilyName: famName,
 					TableName:  tblName,
 					Fields: []schema.NamedFieldType{
-						{schema.FieldName{Name: "field1"}, schema.FTString},
-						{schema.FieldName{Name: "field2"}, schema.FTString},
+						{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+						{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTString},
 					},
 					KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}}},
 				}
@@ -313,8 +313,8 @@ func TestMetaTableClearTableDDL(t *testing.T) {
 		FamilyName: famName,
 		TableName:  tblName,
 		Fields: []schema.NamedFieldType{
-			{schema.FieldName{Name: "field1"}, schema.FTString},
-			{schema.FieldName{Name: "field2"}, schema.FTByteString},
+			{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
+			{Name: schema.FieldName{Name: "field2"}, FieldType: schema.FTByteString},
 		},
 		KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}}},
 	}
@@ -334,7 +334,7 @@ func TestMetaTableDropTableDDL(t *testing.T) {
 		FamilyName: famName,
 		TableName:  tblName,
 		Fields: []schema.NamedFieldType{
-			{schema.FieldName{Name: "field1"}, schema.FTString},
+			{Name: schema.FieldName{Name: "field1"}, FieldType: schema.FTString},
 		},
 		KeyFields: schema.PrimaryKey{Fields: []schema.FieldName{{Name: "field1"}}},
 	}

pkg/unsafe/unsafe_test.go

@@ -1,3 +1,4 @@
+//go:build !race
 // +build !race
 
 package unsafe

pkg/utils/interface_slice.go

@@ -6,14 +6,13 @@ import "reflect"
 //
 // - Returns empty slice if no args are passed
 //
-// - For a single argument which is of a slice type, the slice
-//   is converted and returned.
+//   - For a single argument which is of a slice type, the slice
+//     is converted and returned.
 //
-// - For a single argument which is not a slice type, the value is
-//   returned within a single-element slice.
+//   - For a single argument which is not a slice type, the value is
+//     returned within a single-element slice.
 //
 // - For multiple arguments, returns a slice with all the args
-//
 func InterfaceSlice(any ...interface{}) []interface{} {
 	if len(any) == 0 {
 		return []interface{}{}

pkg/version/version_go1_12.go

@@ -1,3 +1,4 @@
+//go:build go1.12
 // +build go1.12
 
 package version

tools.go

@@ -1,3 +1,4 @@
+//go:build tools
 // +build tools
 
 package ctlstore