From aa0984c3e2cca0484f78787d572eca62ac0a7296 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dani=C3=ABl=20van=20Eeden?= Date: Tue, 9 Jun 2026 16:54:27 +0200 Subject: [PATCH 1/2] Run go fix and remove legacy tlsrsakex godebug option --- cdc/sink/tablesink/state/state_test.go | 1 - dm/pkg/backoff/backoff_test.go | 10 +- dm/pkg/binlog/event/common.go | 2 +- dm/pkg/binlog/event/dml.go | 2 +- dm/pkg/binlog/event/dml_test.go | 16 +- dm/pkg/binlog/event/event.go | 2 +- dm/pkg/binlog/event/event_test.go | 20 +- dm/pkg/binlog/event/generator_test.go | 24 +-- dm/pkg/binlog/event/util.go | 28 +-- dm/pkg/func-rollback/rollback.go | 5 +- dm/pkg/func-rollback/rollback_test.go | 2 +- dm/pkg/helper/value.go | 4 +- dm/pkg/terror/adapter.go | 4 +- dm/pkg/terror/terror.go | 16 +- dm/pkg/terror/terror_test.go | 8 +- dm/simulator/mcp/mcp_test.go | 18 +- dm/simulator/mcp/uk.go | 33 ++- dm/simulator/mcp/uk_test.go | 20 +- engine/executor/worker/task_committer.go | 6 +- engine/executor/worker/task_runner.go | 2 +- engine/executor/worker/task_runner_test.go | 22 +- .../internal/eventloop/runner_test.go | 18 +- engine/framework/model/master.go | 2 +- engine/framework/model/master_test.go | 1 - engine/framework/model/worker.go | 4 +- engine/jobmaster/dm/bootstrap/upgrade.go | 5 +- engine/pkg/client/internal/call_test.go | 12 +- engine/pkg/client/internal/leader_resolver.go | 6 +- .../client/internal/leader_resolver_test.go | 4 +- engine/pkg/containers/slice_queue_test.go | 22 +- engine/pkg/deps/deps.go | 8 +- engine/pkg/dm/ticker/ticker_test.go | 6 +- engine/pkg/errctx/center_test.go | 16 +- engine/pkg/notifier/notifier.go | 6 +- engine/pkg/notifier/notifier_test.go | 18 +- engine/pkg/orm/model/common.go | 2 +- engine/pkg/orm/model/executor.go | 6 +- engine/pkg/orm/model/jobop.go | 4 +- engine/pkg/p2p/message_sender.go | 8 +- .../pkg/p2p/mock_message_handler_manager.go | 2 +- engine/pkg/p2p/mock_message_sender.go | 6 +- engine/pkg/p2p/mock_message_sender_test.go | 12 +- engine/pkg/p2p/server.go | 4 +- engine/pkg/p2p/server_integration_test.go | 12 +- engine/pkg/rpcutil/middleware.go | 7 +- .../serverutil/watch_executors_test.go | 12 +- engine/test/mock/grpc.go | 6 +- engine/test/mock/test_server.go | 12 +- go.mod | 3 - pkg/causality/conflict_detector.go | 6 +- pkg/causality/internal/node.go | 16 +- pkg/causality/internal/slots.go | 2 +- pkg/causality/internal/slots_test.go | 18 +- pkg/causality/tests/driver.go | 2 +- pkg/causality/tests/worker.go | 6 +- pkg/causality/txn_cache_test.go | 4 +- pkg/chann/chann_test.go | 78 ++++--- pkg/chann/drainable_chann_test.go | 2 +- pkg/chdelay/channel_delayer_test.go | 14 +- pkg/column-mapping/column.go | 10 +- pkg/column-mapping/column_test.go | 26 +-- pkg/compression/compress.go | 4 +- pkg/container/queue/chunkqueue.go | 22 +- pkg/container/queue/chunkqueue_test.go | 30 +-- pkg/container/queue/iterator_test.go | 22 +- pkg/container/sortmap/sort.go | 7 +- pkg/errors/helper.go | 4 +- pkg/errors/helper_test.go | 4 +- pkg/label/label_test.go | 2 - pkg/label/selector_test.go | 10 +- pkg/leakutil/leak_helper_test.go | 2 +- pkg/notify/notify_test.go | 22 +- pkg/p2p/client.go | 8 +- pkg/p2p/client_batch_sender.go | 5 +- pkg/p2p/client_batch_sender_test.go | 10 +- pkg/p2p/client_connector_test.go | 12 +- pkg/p2p/grpc_client.go | 11 +- pkg/p2p/grpc_client_test.go | 40 ++-- pkg/p2p/internal/send_chan_test.go | 58 ++---- pkg/p2p/message_router.go | 6 +- pkg/p2p/message_router_test.go | 40 ++-- pkg/p2p/mock_cluster.go | 20 +- pkg/p2p/mock_grpc_client.go | 4 +- pkg/p2p/model.go | 2 +- pkg/p2p/serializer.go | 4 +- pkg/p2p/server.go | 22 +- pkg/p2p/server_ack_manager.go | 2 +- pkg/p2p/server_client_integration_test.go | 112 ++++------ pkg/p2p/server_stream_handle_test.go | 12 +- pkg/p2p/server_test.go | 196 +++++++----------- pkg/p2p/server_wrapper_test.go | 14 +- pkg/retry/retry_test.go | 2 +- pkg/security/credential.go | 2 +- pkg/security/sasl_test.go | 2 - pkg/tcpserver/tcp_server_test.go | 84 +++----- pkg/util/seahash/seahash.go | 5 +- pkg/util/seahash/seahash_test.go | 2 +- pkg/uuid/uuid_test.go | 2 +- pkg/workerpool/async_pool_impl.go | 18 +- pkg/workerpool/async_pool_test.go | 4 +- pkg/workerpool/pool.go | 6 +- pkg/workerpool/pool_impl.go | 30 +-- pkg/workerpool/pool_test.go | 82 ++++---- tests/integration_tests/bank/case.go | 12 +- tests/integration_tests/ddl_wait/test.go | 4 +- .../integration_tests/ddl_with_exists/test.go | 12 +- .../http_proxies/run-proxy.go | 2 +- tests/mq_protocol_tests/cases/case_alter.go | 6 +- .../cases/case_composite_pkey.go | 6 +- .../mq_protocol_tests/cases/case_date_time.go | 2 +- tests/mq_protocol_tests/cases/case_delete.go | 8 +- .../cases/case_handle_key.go | 6 +- .../cases/case_many_types.go | 2 +- tests/mq_protocol_tests/cases/case_simple.go | 8 +- .../mq_protocol_tests/cases/case_unsigned.go | 2 +- .../framework/avro/kafka_docker_env.go | 2 +- .../mq_protocol_tests/framework/docker_env.go | 2 +- tests/mq_protocol_tests/framework/env.go | 4 +- .../framework/sql_batch_op.go | 16 +- .../mq_protocol_tests/framework/sql_helper.go | 48 ++--- 120 files changed, 738 insertions(+), 1003 deletions(-) diff --git a/cdc/sink/tablesink/state/state_test.go b/cdc/sink/tablesink/state/state_test.go index b767dfac4b..bdf92dee34 100644 --- a/cdc/sink/tablesink/state/state_test.go +++ b/cdc/sink/tablesink/state/state_test.go @@ -33,7 +33,6 @@ func TestStateString(t *testing.T) { } for _, tc := range testCases { - tc := tc t.Run(tc.want, func(t *testing.T) { t.Parallel() require.Equal(t, tc.want, tc.state.String()) diff --git a/dm/pkg/backoff/backoff_test.go b/dm/pkg/backoff/backoff_test.go index 46c56b064f..7d006a9a3b 100644 --- a/dm/pkg/backoff/backoff_test.go +++ b/dm/pkg/backoff/backoff_test.go @@ -70,14 +70,14 @@ func TestExponentialBackoff(t *testing.T) { Factor: factor, } - for i := 0; i < 10; i++ { + for i := range 10 { expected := minT * time.Duration(math.Pow(factor, float64(i))) require.Equal(t, expected, b.Duration()) } b.Rollback() require.Equal(t, 512*minT, b.Current()) b.Forward() - for i := 0; i < 10; i++ { + for range 10 { require.Equal(t, maxT, b.Duration()) } b.Reset() @@ -123,7 +123,7 @@ func TestFixedBackoff(t *testing.T) { Max: maxT, Factor: factor, } - for i := 0; i < 10; i++ { + for range 10 { require.Equal(t, maxT, b.Duration()) } } @@ -163,13 +163,13 @@ func TestForward(t *testing.T) { Max: maxT, Factor: factor, } - for i := 0; i < n; i++ { + for range n { b.Forward() } require.Equal(t, n, b.cwnd) b.Reset() require.Equal(t, 0, b.cwnd) - for i := 0; i < n; i++ { + for range n { b.BoundaryForward() } require.Equal(t, 3, b.cwnd) diff --git a/dm/pkg/binlog/event/common.go b/dm/pkg/binlog/event/common.go index 5d36153b1f..51c7d8f79d 100644 --- a/dm/pkg/binlog/event/common.go +++ b/dm/pkg/binlog/event/common.go @@ -176,7 +176,7 @@ func GTIDIncrease(flavor string, gSet gmysql.GTIDSet) (gmysql.GTIDSet, error) { } // verifySingleGTID verifies gSet whether only containing a single valid GTID. -func verifySingleGTID(flavor string, gSet gmysql.GTIDSet) (interface{}, error) { +func verifySingleGTID(flavor string, gSet gmysql.GTIDSet) (any, error) { if gtid.CheckGTIDSetEmpty(gSet) { return nil, terror.ErrBinlogEmptyGTID.Generate() } diff --git a/dm/pkg/binlog/event/dml.go b/dm/pkg/binlog/event/dml.go index 881fba6871..9bd7a2f3ad 100644 --- a/dm/pkg/binlog/event/dml.go +++ b/dm/pkg/binlog/event/dml.go @@ -28,7 +28,7 @@ type DMLData struct { Schema string Table string ColumnType []byte - Rows [][]interface{} + Rows [][]any // if Query is not empty, we generate a Query event Query string diff --git a/dm/pkg/binlog/event/dml_test.go b/dm/pkg/binlog/event/dml_test.go index 0a2ee94753..325ba2de64 100644 --- a/dm/pkg/binlog/event/dml_test.go +++ b/dm/pkg/binlog/event/dml_test.go @@ -43,8 +43,8 @@ func TestGenDMLEvent(t *testing.T) { require.Nil(t, result) // single INSERT without batch - insertRows1 := make([][]interface{}, 0, 1) - insertRows1 = append(insertRows1, []interface{}{int32(11), "string column value"}) + insertRows1 := make([][]any, 0, 1) + insertRows1 = append(insertRows1, []any{int32(11), "string column value"}) insertDMLData := []*DMLData{ { TableID: 11, @@ -69,8 +69,8 @@ func TestGenDMLEvent(t *testing.T) { xid++ // multi INSERT with batch - insertRows2 := make([][]interface{}, 0, 2) - insertRows2 = append(insertRows2, []interface{}{int32(101), "string column value a"}, []interface{}{int32(102), "string column value b"}) + insertRows2 := make([][]any, 0, 2) + insertRows2 = append(insertRows2, []any{int32(101), "string column value a"}, []any{int32(102), "string column value b"}) insertDMLData = append(insertDMLData, &DMLData{ TableID: 12, Schema: "db2", @@ -91,8 +91,8 @@ func TestGenDMLEvent(t *testing.T) { xid++ // single UPDATE - updateRows := make([][]interface{}, 0, 2) - updateRows = append(updateRows, []interface{}{int32(21), "old string"}, []interface{}{int32(21), "new string"}) + updateRows := make([][]any, 0, 2) + updateRows = append(updateRows, []any{int32(21), "old string"}, []any{int32(21), "new string"}) updateDMLData := []*DMLData{ { TableID: 21, @@ -121,8 +121,8 @@ func TestGenDMLEvent(t *testing.T) { require.Nil(t, err) // single DELETE - deleteRows := make([][]interface{}, 0, 1) - deleteRows = append(deleteRows, []interface{}{int32(31), "string a"}) + deleteRows := make([][]any, 0, 1) + deleteRows = append(deleteRows, []any{int32(31), "string a"}) deleteDMLData := []*DMLData{ { TableID: 31, diff --git a/dm/pkg/binlog/event/event.go b/dm/pkg/binlog/event/event.go index a0994de10c..dc5dded8d6 100644 --- a/dm/pkg/binlog/event/event.go +++ b/dm/pkg/binlog/event/event.go @@ -521,7 +521,7 @@ func GenTableMapEvent(header *replication.EventHeader, latestPos uint32, tableID // // ref: https://dev.mysql.com/doc/internals/en/rows-event.html // ref: http://blog.51cto.com/yanzongshuai/2090894 -func GenRowsEvent(header *replication.EventHeader, latestPos uint32, eventType replication.EventType, tableID uint64, rowsFlags uint16, rows [][]interface{}, columnType []byte, tableMapEv *replication.BinlogEvent) (*replication.BinlogEvent, error) { +func GenRowsEvent(header *replication.EventHeader, latestPos uint32, eventType replication.EventType, tableID uint64, rowsFlags uint16, rows [][]any, columnType []byte, tableMapEv *replication.BinlogEvent) (*replication.BinlogEvent, error) { switch eventType { case replication.WRITE_ROWS_EVENTv0, replication.WRITE_ROWS_EVENTv1, replication.WRITE_ROWS_EVENTv2, replication.UPDATE_ROWS_EVENTv0, replication.UPDATE_ROWS_EVENTv1, replication.UPDATE_ROWS_EVENTv2, diff --git a/dm/pkg/binlog/event/event_test.go b/dm/pkg/binlog/event/event_test.go index 87dbc83596..0ac182fd46 100644 --- a/dm/pkg/binlog/event/event_test.go +++ b/dm/pkg/binlog/event/event_test.go @@ -480,7 +480,7 @@ func TestGenRowsEvent(t *testing.T) { tableID uint64 = 108 eventType = replication.TABLE_MAP_EVENT rowsFlag = RowFlagsEndOfStatement - rows [][]interface{} + rows [][]any columnType []byte // nil ) @@ -496,7 +496,7 @@ func TestGenRowsEvent(t *testing.T) { require.Nil(t, rowsEv) // valid eventType and rows, invalid columnType - row := []interface{}{int32(1)} + row := []any{int32(1)} rows = append(rows, row) rowsEv, err = GenRowsEvent(header, latestPos, eventType, tableID, rowsFlag, rows, columnType, nil) require.NotNil(t, err) @@ -522,15 +522,15 @@ func TestGenRowsEvent(t *testing.T) { require.Equal(t, rows, rowsEvBody.Rows) // multi rows, with different length, invalid - rows = append(rows, []interface{}{int32(1), int32(2)}) + rows = append(rows, []any{int32(1), int32(2)}) rowsEv, err = GenRowsEvent(header, latestPos, eventType, tableID, rowsFlag, rows, columnType, nil) require.NotNil(t, err) require.Nil(t, rowsEv) // multi rows, multi columns, valid - rows = make([][]interface{}, 0, 2) - rows = append(rows, []interface{}{int32(1), int32(2)}) - rows = append(rows, []interface{}{int32(3), int32(4)}) + rows = make([][]any, 0, 2) + rows = append(rows, []any{int32(1), int32(2)}) + rows = append(rows, []any{int32(3), int32(4)}) columnType = []byte{gmysql.MYSQL_TYPE_LONG, gmysql.MYSQL_TYPE_LONG} rowsEv, err = GenRowsEvent(header, latestPos, eventType, tableID, rowsFlag, rows, columnType, nil) require.Nil(t, err) @@ -556,8 +556,8 @@ func TestGenRowsEvent(t *testing.T) { } // more column types - rows = make([][]interface{}, 0, 1) - rows = append(rows, []interface{}{ + rows = make([][]any, 0, 1) + rows = append(rows, []any{ int32(1), int8(2), int16(3), int32(4), int64(5), float32(1.23), float64(4.56), "string with type STRING", }) @@ -582,8 +582,8 @@ func TestGenRowsEvent(t *testing.T) { require.Nil(t, rowsEv) // NotSupported column type - rows = make([][]interface{}, 0, 1) - rows = append(rows, []interface{}{int32(1)}) + rows = make([][]any, 0, 1) + rows = append(rows, []any{int32(1)}) unsupportedTypes := []byte{ gmysql.MYSQL_TYPE_VARCHAR, gmysql.MYSQL_TYPE_VAR_STRING, gmysql.MYSQL_TYPE_NEWDECIMAL, gmysql.MYSQL_TYPE_BIT, diff --git a/dm/pkg/binlog/event/generator_test.go b/dm/pkg/binlog/event/generator_test.go index 5bee26a4f3..2c163d7a2d 100644 --- a/dm/pkg/binlog/event/generator_test.go +++ b/dm/pkg/binlog/event/generator_test.go @@ -165,8 +165,8 @@ func testGenerate(t *testing.T, flavor string, serverID uint32, latestGTID gmysq tableID uint64 = 8 columnType = []byte{gmysql.MYSQL_TYPE_LONG, gmysql.MYSQL_TYPE_STRING} ) - insertRows := make([][]interface{}, 0, 1) - insertRows = append(insertRows, []interface{}{int32(1), "string 1"}) + insertRows := make([][]any, 0, 1) + insertRows = append(insertRows, []any{int32(1), "string 1"}) dmlData := []*DMLData{ { TableID: tableID, @@ -186,10 +186,10 @@ func testGenerate(t *testing.T, flavor string, serverID uint32, latestGTID gmysq // INSERT INTO `db`.`tbl` VALUES (11, "string 11"), (12, "string 12") // INSERT INTO `db`.`tbl` VALUES (13, "string 13"), - insertRows1 := make([][]interface{}, 0, 2) - insertRows1 = append(insertRows1, []interface{}{int32(11), "string 11"}, []interface{}{int32(12), "string 12"}) - insertRows2 := make([][]interface{}, 0, 1) - insertRows2 = append(insertRows2, []interface{}{int32(13), "string 13"}) + insertRows1 := make([][]any, 0, 2) + insertRows1 = append(insertRows1, []any{int32(11), "string 11"}, []any{int32(12), "string 12"}) + insertRows2 := make([][]any, 0, 1) + insertRows2 = append(insertRows2, []any{int32(13), "string 13"}) dmlData = []*DMLData{ { TableID: tableID, @@ -215,10 +215,10 @@ func testGenerate(t *testing.T, flavor string, serverID uint32, latestGTID gmysq // UPDATE `db`.`tbl` SET c2="another string 11" WHERE c1=11 // UPDATE `db`.`tbl` SET c1=120, c2="another string 120" WHERE C1=12 - updateRows1 := make([][]interface{}, 0, 2) - updateRows1 = append(updateRows1, []interface{}{int32(11), "string 11"}, []interface{}{int32(11), "another string 11"}) - updateRows2 := make([][]interface{}, 0, 2) - updateRows2 = append(updateRows2, []interface{}{int32(12), "string 12"}, []interface{}{int32(120), "another string 120"}) + updateRows1 := make([][]any, 0, 2) + updateRows1 = append(updateRows1, []any{int32(11), "string 11"}, []any{int32(11), "another string 11"}) + updateRows2 := make([][]any, 0, 2) + updateRows2 = append(updateRows2, []any{int32(12), "string 12"}, []any{int32(120), "another string 120"}) dmlData = []*DMLData{ { TableID: tableID, @@ -244,8 +244,8 @@ func testGenerate(t *testing.T, flavor string, serverID uint32, latestGTID gmysq allEventTypes = append(allEventTypes, gtidEventType(t, flavor), replication.QUERY_EVENT, replication.TABLE_MAP_EVENT, eventType, replication.TABLE_MAP_EVENT, eventType, replication.XID_EVENT) // DELETE FROM `db`.`tbl` WHERE c1=13 - deleteRows := make([][]interface{}, 0, 1) - deleteRows = append(deleteRows, []interface{}{int32(13), "string 13"}) + deleteRows := make([][]any, 0, 1) + deleteRows = append(deleteRows, []any{int32(13), "string 13"}) dmlData = []*DMLData{ { TableID: tableID, diff --git a/dm/pkg/binlog/event/util.go b/dm/pkg/binlog/event/util.go index 4465fa41a3..077ee563dd 100644 --- a/dm/pkg/binlog/event/util.go +++ b/dm/pkg/binlog/event/util.go @@ -111,7 +111,7 @@ func nullBytes(n int) []byte { // fullBytes returns a n-length full bytes slice (all bits are set). func fullBytes(n int) []byte { buf := new(bytes.Buffer) - for i := 0; i < n; i++ { + for range n { buf.WriteByte(0xff) } return buf.Bytes() @@ -197,7 +197,7 @@ func combineHeaderPayload(buf *bytes.Buffer, header, postHeader, payload []byte) // ref: https://github.com/go-mysql-org/go-mysql/blob/88e9cd7f6643b246b4dcc0e3206e9a169dd0ac96/replication/row_event.go#L368 // NOTE: we do not generate meaningful `meta` yet. // nolint:unparam -func encodeColumnValue(v interface{}, tp byte, meta uint16) ([]byte, error) { +func encodeColumnValue(v any, tp byte, meta uint16) ([]byte, error) { var ( buf = new(bytes.Buffer) err error @@ -206,33 +206,33 @@ func encodeColumnValue(v interface{}, tp byte, meta uint16) ([]byte, error) { case gmysql.MYSQL_TYPE_NULL: return nil, nil case gmysql.MYSQL_TYPE_LONG: - err = writeIntegerColumnValue(buf, v, reflect.TypeOf(int32(0))) + err = writeIntegerColumnValue(buf, v, reflect.TypeFor[int32]()) case gmysql.MYSQL_TYPE_TINY: - err = writeIntegerColumnValue(buf, v, reflect.TypeOf(int8(0))) + err = writeIntegerColumnValue(buf, v, reflect.TypeFor[int8]()) case gmysql.MYSQL_TYPE_SHORT: - err = writeIntegerColumnValue(buf, v, reflect.TypeOf(int16(0))) + err = writeIntegerColumnValue(buf, v, reflect.TypeFor[int16]()) case gmysql.MYSQL_TYPE_INT24: - err = writeIntegerColumnValue(buf, v, reflect.TypeOf(int32(0))) + err = writeIntegerColumnValue(buf, v, reflect.TypeFor[int32]()) if err == nil { buf.Truncate(3) } case gmysql.MYSQL_TYPE_LONGLONG: - err = writeIntegerColumnValue(buf, v, reflect.TypeOf(int64(0))) + err = writeIntegerColumnValue(buf, v, reflect.TypeFor[int64]()) case gmysql.MYSQL_TYPE_FLOAT: value, ok := v.(float32) if !ok { - err = terror.ErrBinlogColumnTypeMisMatch.Generate(v, reflect.TypeOf(v), reflect.TypeOf(float32(0))) + err = terror.ErrBinlogColumnTypeMisMatch.Generate(v, reflect.TypeOf(v), reflect.TypeFor[float32]()) } else { bits := math.Float32bits(value) - err = writeIntegerColumnValue(buf, bits, reflect.TypeOf(uint32(0))) + err = writeIntegerColumnValue(buf, bits, reflect.TypeFor[uint32]()) } case gmysql.MYSQL_TYPE_DOUBLE: value, ok := v.(float64) if !ok { - err = terror.ErrBinlogColumnTypeMisMatch.Generate(v, reflect.TypeOf(v), reflect.TypeOf(float64(0))) + err = terror.ErrBinlogColumnTypeMisMatch.Generate(v, reflect.TypeOf(v), reflect.TypeFor[float64]()) } else { bits := math.Float64bits(value) - err = writeIntegerColumnValue(buf, bits, reflect.TypeOf(uint64(0))) + err = writeIntegerColumnValue(buf, bits, reflect.TypeFor[uint64]()) } case gmysql.MYSQL_TYPE_STRING: err = writeStringColumnValue(buf, v) @@ -252,7 +252,7 @@ func encodeColumnValue(v interface{}, tp byte, meta uint16) ([]byte, error) { } // writeIntegerColumnValue writes integer value to bytes buffer. -func writeIntegerColumnValue(buf *bytes.Buffer, value interface{}, valueType reflect.Type) error { +func writeIntegerColumnValue(buf *bytes.Buffer, value any, valueType reflect.Type) error { if reflect.TypeOf(value) != valueType { return terror.ErrBinlogColumnTypeMisMatch.Generate(value, reflect.TypeOf(value), valueType) } @@ -260,10 +260,10 @@ func writeIntegerColumnValue(buf *bytes.Buffer, value interface{}, valueType ref } // writeStringColumnValue writes string value to bytes buffer. -func writeStringColumnValue(buf *bytes.Buffer, value interface{}) error { +func writeStringColumnValue(buf *bytes.Buffer, value any) error { str, ok := value.(string) if !ok { - return terror.ErrBinlogColumnTypeMisMatch.Generate(value, reflect.TypeOf(value), reflect.TypeOf("")) + return terror.ErrBinlogColumnTypeMisMatch.Generate(value, reflect.TypeOf(value), reflect.TypeFor[string]()) } var ( err error diff --git a/dm/pkg/func-rollback/rollback.go b/dm/pkg/func-rollback/rollback.go index cf838b60fa..95b5c45425 100644 --- a/dm/pkg/func-rollback/rollback.go +++ b/dm/pkg/func-rollback/rollback.go @@ -14,6 +14,7 @@ package rollback import ( + "slices" "sync" "github.com/pingcap/tiflow/dm/pkg/log" @@ -53,8 +54,8 @@ func (h *FuncRollbackHolder) Add(fn FuncRollback) { func (h *FuncRollbackHolder) RollbackReverseOrder() { h.mu.Lock() defer h.mu.Unlock() - for i := len(h.fns) - 1; i >= 0; i-- { - fn := h.fns[i] + for _, fn := range slices.Backward(h.fns) { + log.L().Info("rolling back", zap.String("functon", fn.Name), zap.String("onwer", h.owner)) fn.Fn() } diff --git a/dm/pkg/func-rollback/rollback_test.go b/dm/pkg/func-rollback/rollback_test.go index 6b0bb122e7..84f3b02f8a 100644 --- a/dm/pkg/func-rollback/rollback_test.go +++ b/dm/pkg/func-rollback/rollback_test.go @@ -37,7 +37,7 @@ func TestRollback(t *testing.T) { expected = append(expected, i) // [4, 3, 2, 1, 0] } - for i := 0; i < total; i++ { + for i := range total { h.Add(FuncRollback{Name: fmt.Sprintf("test-%d", i), Fn: rf}) } h.RollbackReverseOrder() diff --git a/dm/pkg/helper/value.go b/dm/pkg/helper/value.go index 5789e5a1c5..c2e41daecc 100644 --- a/dm/pkg/helper/value.go +++ b/dm/pkg/helper/value.go @@ -17,12 +17,12 @@ import "reflect" // IsNil tests whether the passed in value is nil. // ref https://github.com/golang/go/blob/87113f7eadf6d8b12279709f05c0359b54b194ea/src/reflect/value.go#L1049. -func IsNil(vi interface{}) (result bool) { +func IsNil(vi any) (result bool) { if vi == nil { result = true } else { switch v := reflect.ValueOf(vi); v.Kind() { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.UnsafePointer, reflect.Slice: + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.UnsafePointer, reflect.Slice: return v.IsNil() } } diff --git a/dm/pkg/terror/adapter.go b/dm/pkg/terror/adapter.go index d21261a8a4..a0248f2e3a 100644 --- a/dm/pkg/terror/adapter.go +++ b/dm/pkg/terror/adapter.go @@ -22,7 +22,7 @@ import ( // DBErrorAdaptArgs is an adapter to change raw database error to *Error object. // If err is already an *Error object, return it directly. -func DBErrorAdaptArgs(err error, defaultErr *Error, args ...interface{}) error { +func DBErrorAdaptArgs(err error, defaultErr *Error, args ...any) error { if err == nil { return nil } @@ -42,6 +42,6 @@ func DBErrorAdaptArgs(err error, defaultErr *Error, args ...interface{}) error { // DBErrorAdapt is an adapter to change raw database error to *Error object. // If err is already an *Error object, return it directly. -func DBErrorAdapt(err error, scope ErrScope, defaultErr *Error, args ...interface{}) error { +func DBErrorAdapt(err error, scope ErrScope, defaultErr *Error, args ...any) error { return WithScope(DBErrorAdaptArgs(err, defaultErr, args...), scope) } diff --git a/dm/pkg/terror/terror.go b/dm/pkg/terror/terror.go index 974a3a6094..de3a0933aa 100644 --- a/dm/pkg/terror/terror.go +++ b/dm/pkg/terror/terror.go @@ -155,7 +155,7 @@ type Error struct { level ErrLevel message string workaround string - args []interface{} + args []any rawCause error stack errors.StackTracer } @@ -279,7 +279,7 @@ func (e *Error) Equal(err error) bool { func (e *Error) SetMessage(message string) *Error { err := *e err.message = message - err.args = append([]interface{}{}, e.args...) + err.args = append([]any{}, e.args...) return &err } @@ -289,17 +289,17 @@ func (e *Error) New(message string) error { } // Generate generates a new *Error with the same class and code, and new arguments. -func (e *Error) Generate(args ...interface{}) error { +func (e *Error) Generate(args ...any) error { return e.stackLevelGeneratef(1, e.message, args...) } // Generatef generates a new *Error with the same class and code, and a new formatted message. -func (e *Error) Generatef(format string, args ...interface{}) error { +func (e *Error) Generatef(format string, args ...any) error { return e.stackLevelGeneratef(1, format, args...) } // stackLevelGeneratef is an inner interface to generate new *Error. -func (e *Error) stackLevelGeneratef(stackSkipLevel int, format string, args ...interface{}) error { +func (e *Error) stackLevelGeneratef(stackSkipLevel int, format string, args ...any) error { return &Error{ code: e.code, class: e.class, @@ -314,7 +314,7 @@ func (e *Error) stackLevelGeneratef(stackSkipLevel int, format string, args ...i // Delegate creates a new *Error with the same fields of the give *Error, // except for new arguments, it also sets the err as raw cause of *Error. -func (e *Error) Delegate(err error, args ...interface{}) error { +func (e *Error) Delegate(err error, args ...any) error { if err == nil { return nil } @@ -339,7 +339,7 @@ func (e *Error) Delegate(err error, args ...interface{}) error { } // AnnotateDelegate resets the message of *Error and Delegate with error and new args. -func (e *Error) AnnotateDelegate(err error, message string, args ...interface{}) error { +func (e *Error) AnnotateDelegate(err error, message string, args ...any) error { if err == nil { return nil } @@ -362,7 +362,7 @@ func Annotate(err error, message string) error { } // Annotatef tries to convert err to *Error and adds a message to it. -func Annotatef(err error, format string, args ...interface{}) error { +func Annotatef(err error, format string, args ...any) error { if err == nil { return nil } diff --git a/dm/pkg/terror/terror_test.go b/dm/pkg/terror/terror_test.go index a08efd014a..f50b12ef3e 100644 --- a/dm/pkg/terror/terror_test.go +++ b/dm/pkg/terror/terror_test.go @@ -60,7 +60,7 @@ func TestTError(t *testing.T) { setMsgErr := err.SetMessage(messageArgs) require.Equal(t, messageArgs, setMsgErr.getMsg()) - setMsgErr.args = []interface{}{"1062"} + setMsgErr.args = []any{"1062"} require.Equal(t, fmt.Sprintf(messageArgs, setMsgErr.args...), setMsgErr.getMsg()) // test Error Generate/Generatef @@ -141,12 +141,12 @@ func TestTErrorStackTrace(t *testing.T) { testCases := []struct { fn string message string - args []interface{} + args []any stackFingerprint string }{ {"new", "new error", nil, ".*\\(\\*Error\\)\\.New"}, - {"generate", "", []interface{}{"parma1"}, ".*\\(\\*Error\\)\\.Generate"}, - {"generatef", "generatef error %s %d", []interface{}{"param1", 12}, ".*\\(\\*Error\\)\\.Generatef"}, + {"generate", "", []any{"parma1"}, ".*\\(\\*Error\\)\\.Generate"}, + {"generatef", "generatef error %s %d", []any{"param1", 12}, ".*\\(\\*Error\\)\\.Generatef"}, } for _, tc := range testCases { diff --git a/dm/simulator/mcp/mcp_test.go b/dm/simulator/mcp/mcp_test.go index 20f6a9016f..0bf58caa31 100644 --- a/dm/simulator/mcp/mcp_test.go +++ b/dm/simulator/mcp/mcp_test.go @@ -33,10 +33,10 @@ func (s *testMCPSuite) SetupSuite() { func (s *testMCPSuite) SetupTest() { mcp := NewModificationCandidatePool(8192) - for i := 0; i < 4096; i++ { + for i := range 4096 { mcp.keyPool = append(mcp.keyPool, &UniqueKey{ rowID: i, - value: map[string]interface{}{ + value: map[string]any{ "id": i, }, }) @@ -47,7 +47,7 @@ func (s *testMCPSuite) SetupTest() { func (s *testMCPSuite) TestNextUK() { allHitRowIDs := map[int]int{} repeatCnt := 20 - for i := 0; i < repeatCnt; i++ { + for range repeatCnt { theUK := s.mcp.NextUK() s.Require().NotNil(theUK, "the picked UK should not be nil") theRowID := theUK.GetRowID() @@ -74,10 +74,10 @@ func (s *testMCPSuite) TestParallelNextUK() { rowIDCh := make(chan int, workerCnt) var wg sync.WaitGroup wg.Add(workerCnt) - for i := 0; i < workerCnt; i++ { + for range workerCnt { go func() { defer wg.Done() - for i := 0; i < repeatCnt; i++ { + for range repeatCnt { theUK := s.mcp.NextUK() if theUK != nil { rowIDCh <- theUK.GetRowID() @@ -122,7 +122,7 @@ func (s *testMCPSuite) TestMCPAddDeleteBasic() { startPoolSize := curPoolSize repeatCnt = 5 for i := 0; i < repeatCnt; i++ { - theUK := NewUniqueKey(-1, map[string]interface{}{ + theUK := NewUniqueKey(-1, map[string]any{ "id": rand.Int(), }) err = s.mcp.AddUK(theUK) @@ -188,8 +188,8 @@ func (s *testMCPSuite) TestMCPAddDeleteInParallel() { defer func() { ch <- err }() - for i := 0; i < 5; i++ { - theUK := NewUniqueKey(-1, map[string]interface{}{ + for range 5 { + theUK := NewUniqueKey(-1, map[string]any{ "id": rand.Int(), }) err = s.mcp.AddUK(theUK) @@ -209,7 +209,7 @@ func (s *testMCPSuite) TestMCPAddDeleteInParallel() { defer func() { ch <- err }() - for i := 0; i < 5; i++ { + for range 5 { theDelUK := s.mcp.NextUK() deletedRowID := theDelUK.rowID err = s.mcp.DeleteUK(theDelUK) diff --git a/dm/simulator/mcp/uk.go b/dm/simulator/mcp/uk.go index 73f300a149..ac3ba3e17e 100644 --- a/dm/simulator/mcp/uk.go +++ b/dm/simulator/mcp/uk.go @@ -15,6 +15,7 @@ package mcp import ( "fmt" + "maps" "sort" "strings" "sync" @@ -30,20 +31,18 @@ type UniqueKey struct { rowID int // value is the real value of all the UK columns. // The key is the column name, the value is the real value. - value map[string]interface{} + value map[string]any } // NewUniqueKey creates a new unique key instance. // the map values are cloned into the new UK instance, // so that the further changes in the value map won't affect the values inside the UK. -func NewUniqueKey(rowID int, value map[string]interface{}) *UniqueKey { +func NewUniqueKey(rowID int, value map[string]any) *UniqueKey { result := &UniqueKey{ rowID: rowID, - value: make(map[string]interface{}), - } - for k, v := range value { - result.value[k] = v + value: make(map[string]any), } + maps.Copy(result.value, value) return result } @@ -65,13 +64,11 @@ func (uk *UniqueKey) SetRowID(rowID int) { // GetValue gets the UK value map of a unique key. // The returned value is cloned, so that further modifications won't affect the value inside the UK. -func (uk *UniqueKey) GetValue() map[string]interface{} { +func (uk *UniqueKey) GetValue() map[string]any { uk.RLock() defer uk.RUnlock() - result := make(map[string]interface{}) - for k, v := range uk.value { - result[k] = v - } + result := make(map[string]any) + maps.Copy(result, uk.value) return result } @@ -96,13 +93,11 @@ func (uk *UniqueKey) GetValueHash() string { // SetValue sets the UK value map. // The input values are cloned into the UK, // and further modifications on the input map won't affect the values inside the UK. -func (uk *UniqueKey) SetValue(value map[string]interface{}) { +func (uk *UniqueKey) SetValue(value map[string]any) { uk.Lock() defer uk.Unlock() - uk.value = make(map[string]interface{}) - for k, v := range value { - uk.value[k] = v - } + uk.value = make(map[string]any) + maps.Copy(uk.value, value) } // Clone is to clone a UK into a new one. @@ -112,11 +107,9 @@ func (uk *UniqueKey) Clone() *UniqueKey { defer uk.RUnlock() result := &UniqueKey{ rowID: uk.rowID, - value: map[string]interface{}{}, - } - for k, v := range uk.value { - result.value[k] = v + value: map[string]any{}, } + maps.Copy(result.value, uk.value) return result } diff --git a/dm/simulator/mcp/uk_test.go b/dm/simulator/mcp/uk_test.go index 4fdfae4233..9a69e5a640 100644 --- a/dm/simulator/mcp/uk_test.go +++ b/dm/simulator/mcp/uk_test.go @@ -34,7 +34,7 @@ func (s *testUniqueKeySuite) TestUKClone() { origUKCol2Value := "COL1" originalUK := &UniqueKey{ rowID: -1, - value: map[string]interface{}{ + value: map[string]any{ "col1": origUKCol1Value, "col2": origUKCol2Value, }, @@ -56,7 +56,7 @@ func (s *testUniqueKeySuite) TestUKClone() { func (s *testUniqueKeySuite) TestUKChangeBasic() { col1Value := 111 col2Value := "aaa" - theValueMap := map[string]interface{}{ + theValueMap := map[string]any{ "col1": col1Value, "col2": col2Value, } @@ -79,7 +79,7 @@ func (s *testUniqueKeySuite) TestUKChangeBasic() { newCol1Value := 333 newCol2Value := "ccc" - newValueMap := map[string]interface{}{ + newValueMap := map[string]any{ "col1": newCol1Value, "col2": newCol2Value, } @@ -102,13 +102,13 @@ func (s *testUniqueKeySuite) TestUKParallelChange() { targetID := 100 workerCnt := 10 wg.Add(workerCnt) - for i := 0; i < workerCnt; i++ { + for range workerCnt { go func() { defer wg.Done() <-pendingCh for i := 1; i <= targetID; i++ { theUK.SetRowID(i) - theUK.SetValue(map[string]interface{}{ + theUK.SetValue(map[string]any{ "id": i, }) } @@ -127,14 +127,14 @@ func (s *testUniqueKeySuite) TestUKValueEqual() { col2Value := "aaa" uk1 := &UniqueKey{ rowID: -1, - value: map[string]interface{}{ + value: map[string]any{ "col1": col1Value, "col2": col2Value, }, } uk2 := &UniqueKey{ rowID: 100, - value: map[string]interface{}{ + value: map[string]any{ "col1": col1Value, "col2": col2Value, }, @@ -143,7 +143,7 @@ func (s *testUniqueKeySuite) TestUKValueEqual() { s.Equal(true, uk2.IsValueEqual(uk1), "uk2 should equal uk1 on value") uk3 := &UniqueKey{ rowID: 100, - value: map[string]interface{}{ + value: map[string]any{ "col1": col1Value, "col2": "bbb", }, @@ -152,7 +152,7 @@ func (s *testUniqueKeySuite) TestUKValueEqual() { s.Equal(false, uk3.IsValueEqual(uk1), "uk3 should not equal uk1 on value") uk4 := &UniqueKey{ rowID: 100, - value: map[string]interface{}{ + value: map[string]any{ "col3": 321, }, } @@ -160,7 +160,7 @@ func (s *testUniqueKeySuite) TestUKValueEqual() { s.Equal(false, uk4.IsValueEqual(uk1), "uk4 should not equal uk1 on value") uk5 := &UniqueKey{ rowID: 100, - value: map[string]interface{}{ + value: map[string]any{ "col3": 321, "col1": col1Value, "col2": col2Value, diff --git a/engine/executor/worker/task_committer.go b/engine/executor/worker/task_committer.go index 21ac6976c6..6284e9c0f2 100644 --- a/engine/executor/worker/task_committer.go +++ b/engine/executor/worker/task_committer.go @@ -85,11 +85,9 @@ func newTaskCommitterWithClock( requestTTL: requestTTL, } - committer.wg.Add(1) - go func() { - defer committer.wg.Done() + committer.wg.Go(func() { committer.runTTLChecker() - }() + }) return committer } diff --git a/engine/executor/worker/task_runner.go b/engine/executor/worker/task_runner.go index 4632279daf..2c78cf8119 100644 --- a/engine/executor/worker/task_runner.go +++ b/engine/executor/worker/task_runner.go @@ -124,7 +124,7 @@ func (r *TaskRunner) cancelAll() { } r.canceled = true - r.tasks.Range(func(key, value interface{}) bool { + r.tasks.Range(func(key, value any) bool { id := key.(RunnableID) t := value.(*taskEntry) t.cancel() diff --git a/engine/executor/worker/task_runner_test.go b/engine/executor/worker/task_runner_test.go index afb0845cde..80ba789177 100644 --- a/engine/executor/worker/task_runner_test.go +++ b/engine/executor/worker/task_runner_test.go @@ -39,16 +39,14 @@ func TestTaskRunnerBasics(t *testing.T) { tr := NewTaskRunner(workerNum+1, 1) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := tr.Run(ctx) require.Error(t, err) require.Regexp(t, "context canceled", err.Error()) - }() + }) var workers []*dummyWorker - for i := 0; i < workerNum; i++ { + for i := range workerNum { worker := &dummyWorker{ id: fmt.Sprintf("worker-%d", i), } @@ -95,13 +93,11 @@ func TestTaskRunnerSubmitTime(t *testing.T) { mockClock.Add(time.Hour) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := tr.Run(ctx) require.Error(t, err) require.Regexp(t, "context canceled", err.Error()) - }() + }) require.Eventually(t, func() bool { return worker.SubmitTime() == clock.ToMono(submitTime) @@ -117,19 +113,17 @@ func TestTaskStopReceiver(t *testing.T) { tr := NewTaskRunner(workerNum+1, 1) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := tr.Run(ctx) require.Error(t, err) require.Regexp(t, "context canceled", err.Error()) - }() + }) var ( workers []*dummyWorker running sync.Map ) - for i := 0; i < workerNum; i++ { + for i := range workerNum { worker := &dummyWorker{ id: fmt.Sprintf("worker-%d", i), } diff --git a/engine/framework/internal/eventloop/runner_test.go b/engine/framework/internal/eventloop/runner_test.go index 45db21dd2d..e328ace423 100644 --- a/engine/framework/internal/eventloop/runner_test.go +++ b/engine/framework/internal/eventloop/runner_test.go @@ -118,14 +118,12 @@ func TestRunnerNormalPath(t *testing.T) { task.On("Close", mock.Anything).Return(nil).Once() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := runner.Run(context.Background()) require.Error(t, err) require.Regexp(t, "injected error", err) - }() + }) require.Eventually(t, func() bool { return task.status.Load() == toyTaskRunning @@ -153,14 +151,12 @@ func TestRunnerForcefulExit(t *testing.T) { task.On("Close", mock.Anything).Return(nil).Once() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := runner.Run(context.Background()) require.Error(t, err) require.Regexp(t, "ErrWorkerSuicide", err) - }() + }) require.Eventually(t, func() bool { return task.status.Load() == toyTaskRunning @@ -208,13 +204,11 @@ func TestRunnerStopByCancel(t *testing.T) { task.On("Stop", mock.Anything).Return(nil).Once() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := runner.Run(context.Background()) require.Error(t, err) require.Regexp(t, "worker is canceled", err) - }() + }) require.Eventually(t, func() bool { return task.status.Load() == toyTaskRunning diff --git a/engine/framework/model/master.go b/engine/framework/model/master.go index 63d6f593da..7965e35a12 100644 --- a/engine/framework/model/master.go +++ b/engine/framework/model/master.go @@ -69,7 +69,7 @@ func (e MasterMetaExt) Value() (driver.Value, error) { } // Scan implements sql.Scanner. -func (e *MasterMetaExt) Scan(rawInput interface{}) error { +func (e *MasterMetaExt) Scan(rawInput any) error { // Zero the fields. *e = MasterMetaExt{} diff --git a/engine/framework/model/master_test.go b/engine/framework/model/master_test.go index 0ea8ef3624..fbd04b1806 100644 --- a/engine/framework/model/master_test.go +++ b/engine/framework/model/master_test.go @@ -98,7 +98,6 @@ func TestMasterMetaExtScan(t *testing.T) { } for i := range cases { - i := i t.Run(fmt.Sprintf("subcase-%d", i), func(t *testing.T) { t.Parallel() var ext MasterMetaExt diff --git a/engine/framework/model/worker.go b/engine/framework/model/worker.go index 14df407af7..7f7aa0354b 100644 --- a/engine/framework/model/worker.go +++ b/engine/framework/model/worker.go @@ -105,8 +105,8 @@ func (s *WorkerStatus) Unmarshal(bytes []byte) error { } // Map is used for update the orm model -func (s *WorkerStatus) Map() map[string]interface{} { - return map[string]interface{}{ +func (s *WorkerStatus) Map() map[string]any { + return map[string]any{ "project_id": s.ProjectID, "job_id": s.JobID, "id": s.ID, diff --git a/engine/jobmaster/dm/bootstrap/upgrade.go b/engine/jobmaster/dm/bootstrap/upgrade.go index 8dd5733957..d51047c788 100644 --- a/engine/jobmaster/dm/bootstrap/upgrade.go +++ b/engine/jobmaster/dm/bootstrap/upgrade.go @@ -15,6 +15,7 @@ package bootstrap import ( "context" + "slices" "sort" "github.com/coreos/go-semver/semver" @@ -66,8 +67,8 @@ func (upgrader *DefaultUpgrader) Upgrade(ctx context.Context, fromVer semver.Ver } } if err != nil { - for i := len(rollbackFuncs) - 1; i >= 0; i-- { - rollback := rollbackFuncs[i] + for _, rollback := range slices.Backward(rollbackFuncs) { + if rollback != nil { if err2 := rollback(ctx); err2 != nil { upgrader.logger.Error("rollback failed", zap.Error(err2)) diff --git a/engine/pkg/client/internal/call_test.go b/engine/pkg/client/internal/call_test.go index ca82928f25..286662f36a 100644 --- a/engine/pkg/client/internal/call_test.go +++ b/engine/pkg/client/internal/call_test.go @@ -59,15 +59,13 @@ func TestCallFuncCancel(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { resp, err := call.Do(ctx) require.Nil(t, resp) require.Error(t, err) require.ErrorIs(t, err, context.Canceled) - }() + }) cancel() wg.Wait() @@ -84,15 +82,13 @@ func TestCallRetryCancel(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { resp, err := call.Do(ctx) require.Nil(t, resp) require.Error(t, err) require.ErrorIs(t, err, context.Canceled) - }() + }) cancel() wg.Wait() diff --git a/engine/pkg/client/internal/leader_resolver.go b/engine/pkg/client/internal/leader_resolver.go index 704bf5728a..631c8d3075 100644 --- a/engine/pkg/client/internal/leader_resolver.go +++ b/engine/pkg/client/internal/leader_resolver.go @@ -75,11 +75,9 @@ func newLeaderResolverWithFollowerSorter( doneCh: make(chan struct{}), FollowerSorter: followerSorter, } - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { ret.bgUpdateServerList() - }() + }) return ret } diff --git a/engine/pkg/client/internal/leader_resolver_test.go b/engine/pkg/client/internal/leader_resolver_test.go index 23d19b9b0f..b3d66f1e4a 100644 --- a/engine/pkg/client/internal/leader_resolver_test.go +++ b/engine/pkg/client/internal/leader_resolver_test.go @@ -110,7 +110,7 @@ func TestLeaderResolverFrequentUpdate(t *testing.T) { _, err := leaderResolver.Build(resolver.Target{}, mockConn, resolver.BuildOptions{}) require.NoError(t, err) - for i := 0; i < 1000; i++ { + for range 1000 { leaderResolver.UpdateServerList(map[string]bool{ "leader": true, "follower-1": false, @@ -150,7 +150,7 @@ func TestLeaderResolverUpdateAfterClose(t *testing.T) { // Updating the server list after the resolver is closed // should not panic or deadlock. - for i := 0; i < 1000; i++ { + for range 1000 { leaderResolver.UpdateServerList(map[string]bool{ "leader": true, "follower-1": false, diff --git a/engine/pkg/containers/slice_queue_test.go b/engine/pkg/containers/slice_queue_test.go index 6077bed0c2..269e8f18e1 100644 --- a/engine/pkg/containers/slice_queue_test.go +++ b/engine/pkg/containers/slice_queue_test.go @@ -71,12 +71,12 @@ func TestSliceQueueManyElements(t *testing.T) { const numElems = 10000 q := NewSliceQueue[int]() - for i := 0; i < numElems; i++ { + for i := range numElems { q.Push(i) } require.Equal(t, numElems, q.Size()) - for i := 0; i < numElems; i++ { + for i := range numElems { val, ok := q.Pop() require.True(t, ok) require.Equal(t, i, val) @@ -84,12 +84,12 @@ func TestSliceQueueManyElements(t *testing.T) { require.Equal(t, 0, q.Size()) // Repeat the test - for i := 0; i < numElems; i++ { + for i := range numElems { q.Push(i) } require.Equal(t, numElems, q.Size()) - for i := 0; i < numElems; i++ { + for i := range numElems { val, ok := q.Pop() require.True(t, ok) require.Equal(t, i, val) @@ -102,18 +102,14 @@ func TestSliceQueueConcurrentWriteAndRead(t *testing.T) { q := NewSliceQueue[int]() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { - for i := 0; i < numElems; i++ { + for i := range numElems { q.Push(i) } - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { counter := 0 for { @@ -131,7 +127,7 @@ func TestSliceQueueConcurrentWriteAndRead(t *testing.T) { } } } - }() + }) wg.Wait() require.Equal(t, 0, q.Size()) diff --git a/engine/pkg/deps/deps.go b/engine/pkg/deps/deps.go index 689da3774f..7019cdb087 100644 --- a/engine/pkg/deps/deps.go +++ b/engine/pkg/deps/deps.go @@ -36,7 +36,7 @@ func NewDeps() *Deps { } // Provide accepts a constructor and build a value into container -func (d *Deps) Provide(constructor interface{}) error { +func (d *Deps) Provide(constructor any) error { return d.container.Provide(constructor) } @@ -44,7 +44,7 @@ func (d *Deps) Provide(constructor interface{}) error { // `func(arg1 Type1, arg2 Type2,...) (ret, error)`. // The arguments to the function is automatically filled with // the dependency injection functionality. -func (d *Deps) Construct(fn interface{}) (interface{}, error) { +func (d *Deps) Construct(fn any) (any, error) { fnTp := reflect.TypeOf(fn) if fnTp.NumOut() != 2 { log.Panic("Unexpected input type", zap.Any("type", reflect.TypeOf(fn))) @@ -73,10 +73,10 @@ func (d *Deps) Construct(fn interface{}) (interface{}, error) { } // Fill injects dependencies from Deps to params -func (d *Deps) Fill(params interface{}) error { +func (d *Deps) Fill(params any) error { invokeFnTp := reflect.FuncOf( []reflect.Type{reflect.TypeOf(params).Elem()}, - []reflect.Type{reflect.TypeOf(new(error))}, + []reflect.Type{reflect.TypeFor[*error]()}, false) invokeFn := reflect.MakeFunc(invokeFnTp, func(args []reflect.Value) (results []reflect.Value) { defer func() { diff --git a/engine/pkg/dm/ticker/ticker_test.go b/engine/pkg/dm/ticker/ticker_test.go index f0f50d9f19..06788f5581 100644 --- a/engine/pkg/dm/ticker/ticker_test.go +++ b/engine/pkg/dm/ticker/ticker_test.go @@ -34,10 +34,8 @@ func TestDefaultTicker(t *testing.T) { tickError := errors.New("tick error") dummyTicker.SetResult([]error{tickError, tickError, nil}) - wg.Add(1) // run task manager - go func() { - defer wg.Done() + wg.Go(func() { t := time.NewTicker(50 * time.Millisecond) for { select { @@ -47,7 +45,7 @@ func TestDefaultTicker(t *testing.T) { dummyTicker.DoTick(ctx) } } - }() + }) // first tick when start require.Eventually(t, dummyTicker.ResultAllMeet, 5*time.Second, 100*time.Millisecond) diff --git a/engine/pkg/errctx/center_test.go b/engine/pkg/errctx/center_test.go index 11675a4ad4..50d5e14b79 100644 --- a/engine/pkg/errctx/center_test.go +++ b/engine/pkg/errctx/center_test.go @@ -26,17 +26,15 @@ func TestErrCenterMultipleErrCtx(t *testing.T) { center := NewErrCenter() var wg sync.WaitGroup - for i := 0; i < 10; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range 10 { + wg.Go(func() { ctx, cancel := center.WithCancelOnFirstError(context.Background()) defer cancel() <-ctx.Done() require.Error(t, ctx.Err()) require.EqualError(t, ctx.Err(), "fake error") - }() + }) } center.OnError(errors.New("fake error")) @@ -53,15 +51,13 @@ func TestErrCenterSingleErrCtx(t *testing.T) { defer cancel() var wg sync.WaitGroup - for i := 0; i < 10; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range 10 { + wg.Go(func() { <-ctx.Done() require.Error(t, ctx.Err()) require.EqualError(t, ctx.Err(), "fake error") - }() + }) } center.OnError(errors.New("fake error")) diff --git a/engine/pkg/notifier/notifier.go b/engine/pkg/notifier/notifier.go index cf6ba251c2..be5d7f448a 100644 --- a/engine/pkg/notifier/notifier.go +++ b/engine/pkg/notifier/notifier.go @@ -83,11 +83,9 @@ func NewNotifier[T any]() *Notifier[T] { synchronizeCh: make(chan struct{}), } - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { ret.run() - }() + }) return ret } diff --git a/engine/pkg/notifier/notifier_test.go b/engine/pkg/notifier/notifier_test.go index 5e90fc17a5..a2ab27b6e7 100644 --- a/engine/pkg/notifier/notifier_test.go +++ b/engine/pkg/notifier/notifier_test.go @@ -34,10 +34,8 @@ func TestNotifierBasics(t *testing.T) { ) var wg sync.WaitGroup - for i := 0; i < numReceivers; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range numReceivers { + wg.Go(func() { r := n.NewReceiver() defer r.Close() @@ -55,7 +53,7 @@ func TestNotifierBasics(t *testing.T) { } lastEv = ev } - }() + }) } for i := 1; i <= numEvents; i++ { @@ -78,17 +76,15 @@ func TestNotifierClose(t *testing.T) { ) var wg sync.WaitGroup - for i := 0; i < numReceivers; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range numReceivers { + wg.Go(func() { r := n.NewReceiver() defer r.Close() _, ok := <-r.C require.False(t, ok) - }() + }) } time.Sleep(1 * time.Second) @@ -102,7 +98,7 @@ func TestReceiverClose(t *testing.T) { r := n.NewReceiver() // Send enough events to make sure the receiver channel is full. - for i := 0; i < 64; i++ { + for i := range 64 { n.Notify(i) } time.Sleep(time.Second) diff --git a/engine/pkg/orm/model/common.go b/engine/pkg/orm/model/common.go index 8bd190e839..b4a82fd6cd 100644 --- a/engine/pkg/orm/model/common.go +++ b/engine/pkg/orm/model/common.go @@ -26,4 +26,4 @@ type Model struct { } // KeyValueMap alias to key value map when updating data in gorm -type KeyValueMap = map[string]interface{} +type KeyValueMap = map[string]any diff --git a/engine/pkg/orm/model/executor.go b/engine/pkg/orm/model/executor.go index f0c0f4c107..29b29e875c 100644 --- a/engine/pkg/orm/model/executor.go +++ b/engine/pkg/orm/model/executor.go @@ -42,7 +42,7 @@ func (s LabelSet) ToMap() map[string]string { } // Scan implements the sql.Scanner interface. -func (s *LabelSet) Scan(rawInput interface{}) error { +func (s *LabelSet) Scan(rawInput any) error { *s = make(LabelSet) if rawInput == nil { return nil @@ -88,8 +88,8 @@ type Executor struct { } // Map is used in gorm update. -func (e *Executor) Map() map[string]interface{} { - return map[string]interface{}{ +func (e *Executor) Map() map[string]any { + return map[string]any{ "id": e.ID, "name": e.Name, "address": e.Address, diff --git a/engine/pkg/orm/model/jobop.go b/engine/pkg/orm/model/jobop.go index 5b1f814b5d..8e3598122d 100644 --- a/engine/pkg/orm/model/jobop.go +++ b/engine/pkg/orm/model/jobop.go @@ -46,8 +46,8 @@ type JobOp struct { } // Map is used for update in orm model -func (op *JobOp) Map() map[string]interface{} { - return map[string]interface{}{ +func (op *JobOp) Map() map[string]any { + return map[string]any{ "op": op.Op, } } diff --git a/engine/pkg/p2p/message_sender.go b/engine/pkg/p2p/message_sender.go index 1d9eebbd4a..4b53a08472 100644 --- a/engine/pkg/p2p/message_sender.go +++ b/engine/pkg/p2p/message_sender.go @@ -28,10 +28,10 @@ type MessageSender interface { // SendToNode sends a message to a given node. Returns whether it is successful and a possible error. // A `would-block` error will not be returned. (false, nil) would be returned instead. - SendToNode(ctx context.Context, targetNodeID NodeID, topic Topic, message interface{}) (bool, error) + SendToNode(ctx context.Context, targetNodeID NodeID, topic Topic, message any) (bool, error) // SendToNodeB sends a message to a given node in a blocking way - SendToNodeB(ctx context.Context, targetNodeID NodeID, topic Topic, message interface{}) error + SendToNodeB(ctx context.Context, targetNodeID NodeID, topic Topic, message any) error } type messageSenderImpl struct { @@ -46,7 +46,7 @@ func NewMessageSender(router MessageRouter) MessageSender { // SendToNodeB implements MessageSender.SendToNodeB // Note the blocking send may have performance issue, BE CAUTION when using this function. func (m *messageSenderImpl) SendToNodeB( - ctx context.Context, targetNodeID NodeID, topic Topic, message interface{}, + ctx context.Context, targetNodeID NodeID, topic Topic, message any, ) error { client := m.router.GetClient(targetNodeID) if client == nil { @@ -58,7 +58,7 @@ func (m *messageSenderImpl) SendToNodeB( return err } -func (m *messageSenderImpl) SendToNode(ctx context.Context, targetNodeID NodeID, topic Topic, message interface{}) (bool, error) { +func (m *messageSenderImpl) SendToNode(ctx context.Context, targetNodeID NodeID, topic Topic, message any) (bool, error) { client := m.router.GetClient(targetNodeID) if client == nil { return false, nil diff --git a/engine/pkg/p2p/mock_message_handler_manager.go b/engine/pkg/p2p/mock_message_handler_manager.go index d78fb52f9e..3b3ddf8593 100644 --- a/engine/pkg/p2p/mock_message_handler_manager.go +++ b/engine/pkg/p2p/mock_message_handler_manager.go @@ -63,7 +63,7 @@ func (m *MockMessageHandlerManager) AssertNoHandler(t *testing.T, topic Topic) { // InvokeHandler gets the handler of given topic and invoke the handler to // simulate to send message from given sender -func (m *MockMessageHandlerManager) InvokeHandler(t *testing.T, topic Topic, senderID NodeID, message interface{}) error { +func (m *MockMessageHandlerManager) InvokeHandler(t *testing.T, topic Topic, senderID NodeID, message any) error { m.mu.RLock() defer m.mu.RUnlock() diff --git a/engine/pkg/p2p/mock_message_sender.go b/engine/pkg/p2p/mock_message_sender.go index c4c70dc051..64942bed52 100644 --- a/engine/pkg/p2p/mock_message_sender.go +++ b/engine/pkg/p2p/mock_message_sender.go @@ -50,7 +50,7 @@ func (m *MockMessageSender) SendToNodeB( ctx context.Context, targetNodeID NodeID, topic Topic, - message interface{}, + message any, ) error { m.mu.Lock() defer m.mu.Unlock() @@ -77,7 +77,7 @@ func (m *MockMessageSender) SendToNode( _ context.Context, targetNodeID NodeID, topic Topic, - message interface{}, + message any, ) (bool, error) { m.mu.Lock() defer m.mu.Unlock() @@ -104,7 +104,7 @@ func (m *MockMessageSender) SendToNode( } // TryPop tries to get a message from message sender -func (m *MockMessageSender) TryPop(targetNodeID NodeID, topic Topic) (interface{}, bool) { +func (m *MockMessageSender) TryPop(targetNodeID NodeID, topic Topic) (any, bool) { m.mu.Lock() defer m.mu.Unlock() diff --git a/engine/pkg/p2p/mock_message_sender_test.go b/engine/pkg/p2p/mock_message_sender_test.go index 4d714b0f2f..9c0902114e 100644 --- a/engine/pkg/p2p/mock_message_sender_test.go +++ b/engine/pkg/p2p/mock_message_sender_test.go @@ -33,11 +33,11 @@ func TestMockMessageSender(t *testing.T) { _, ok := sender.TryPop("dummy", "dummy") require.False(t, ok) - for i := 0; i < 50; i++ { + for i := range 50 { topicID := fmt.Sprintf("topic-%d", i) - for j := 0; j < 50; j++ { + for j := range 50 { nodeID := fmt.Sprintf("node-%d", j) - for k := 0; k < 50; k++ { + for k := range 50 { ok, err := sender.SendToNode(context.TODO(), nodeID, topicID, &msgForTesting{k}) require.True(t, ok) require.NoError(t, err) @@ -45,11 +45,11 @@ func TestMockMessageSender(t *testing.T) { } } - for i := 0; i < 50; i++ { + for i := range 50 { topicID := fmt.Sprintf("topic-%d", i) - for j := 0; j < 50; j++ { + for j := range 50 { nodeID := fmt.Sprintf("node-%d", j) - for k := 0; k < 50; k++ { + for k := range 50 { msg, ok := sender.TryPop(nodeID, topicID) require.True(t, ok) require.Equal(t, &msgForTesting{k}, msg) diff --git a/engine/pkg/p2p/server.go b/engine/pkg/p2p/server.go index 4b1c3ca01d..109c38a9c0 100644 --- a/engine/pkg/p2p/server.go +++ b/engine/pkg/p2p/server.go @@ -41,9 +41,9 @@ type ( type ( // TypeInformation is used to hold type data - TypeInformation = interface{} + TypeInformation = any // MessageValue is used to hold message object - MessageValue = interface{} + MessageValue = any // HandlerFunc alias to message handler function HandlerFunc = func(sender NodeID, value MessageValue) error ) diff --git a/engine/pkg/p2p/server_integration_test.go b/engine/pkg/p2p/server_integration_test.go index 67d4c2002c..a558ebf326 100644 --- a/engine/pkg/p2p/server_integration_test.go +++ b/engine/pkg/p2p/server_integration_test.go @@ -58,13 +58,11 @@ func TestMessageRPCServiceBasics(t *testing.T) { require.NoError(t, err) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := messageSrvc.Serve(ctx, l) require.Error(t, err) require.Regexp(t, ".*canceled.*", err.Error()) - }() + }) var called atomic.Bool handlerManager := messageSrvc.MakeHandlerManager() @@ -78,13 +76,11 @@ func TestMessageRPCServiceBasics(t *testing.T) { require.True(t, ok) client := p2pImpl.NewGrpcMessageClient("test-client-1", clientConfigForUnitTesting) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "tcp", addr, "test-node-1", &security.Credential{} /* no TLS */) require.Error(t, err) require.Regexp(t, ".*canceled.*", err.Error()) - }() + }) _, err = client.SendMessage(ctx, "test-topic-1", &msgContent{}) require.NoError(t, err) diff --git a/engine/pkg/rpcutil/middleware.go b/engine/pkg/rpcutil/middleware.go index 65513159d7..d375ba88f9 100644 --- a/engine/pkg/rpcutil/middleware.go +++ b/engine/pkg/rpcutil/middleware.go @@ -16,6 +16,7 @@ package rpcutil import ( "context" "reflect" + "slices" "strings" "time" @@ -208,10 +209,8 @@ func NormalizeError() grpc.UnaryServerInterceptor { // allowList is a list of methods that will be logged. limiter is used to limit the log rate. func Logger(allowList []string, limiter *rate.Limiter) grpc.UnaryServerInterceptor { allow := func(method string) bool { - for _, m := range allowList { - if m == method { - return true - } + if slices.Contains(allowList, method) { + return true } return limiter.Allow() } diff --git a/engine/servermaster/serverutil/watch_executors_test.go b/engine/servermaster/serverutil/watch_executors_test.go index 8b1305f985..2bd7adf15a 100644 --- a/engine/servermaster/serverutil/watch_executors_test.go +++ b/engine/servermaster/serverutil/watch_executors_test.go @@ -128,13 +128,11 @@ func TestWatchExecutors(t *testing.T) { } var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := WatchExecutors(ctx, watcher, user) require.ErrorIs(t, err, context.Canceled) - }() + }) for _, event := range events { evNotifier.Notify(event) @@ -187,12 +185,10 @@ func TestCloseWatchExecutors(t *testing.T) { user.On("UpdateExecutorList", snap).Return(nil).Times(1) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := WatchExecutors(ctx, watcher, user) require.ErrorIs(t, err, errors.ErrExecutorWatcherClosed) - }() + }) evNotifier.Close() wg.Wait() diff --git a/engine/test/mock/grpc.go b/engine/test/mock/grpc.go index 8a3e17266f..a0f84d847e 100644 --- a/engine/test/mock/grpc.go +++ b/engine/test/mock/grpc.go @@ -64,7 +64,7 @@ func (s *masterServerConn) Close() error { return nil } -func (s *masterServerConn) sendRequest(ctx context.Context, req interface{}) (interface{}, error) { +func (s *masterServerConn) sendRequest(ctx context.Context, req any) (any, error) { switch x := req.(type) { case *pb.RegisterExecutorRequest: return s.server.RegisterExecutor(ctx, x) @@ -127,7 +127,7 @@ func NewExecutorClient(conn Conn) pb.ExecutorServiceClient { return &executorClient{conn} } -func (s *executorServerConn) sendRequest(ctx context.Context, req interface{}) (interface{}, error) { +func (s *executorServerConn) sendRequest(ctx context.Context, req any) (any, error) { switch x := req.(type) { case *pb.PreDispatchTaskRequest: return s.server.PreDispatchTask(ctx, x) @@ -180,7 +180,7 @@ func NewExecutorServer(addr string, server pb.ExecutorServiceServer) (GrpcServer // Conn is a simple interface that support send gRPC requests and closeable type Conn interface { Close() error - sendRequest(ctx context.Context, req interface{}) (interface{}, error) + sendRequest(ctx context.Context, req any) (any, error) } // ResetGrpcCtx resets grpc servers diff --git a/engine/test/mock/test_server.go b/engine/test/mock/test_server.go index c918d9a738..9ac0ede495 100644 --- a/engine/test/mock/test_server.go +++ b/engine/test/mock/test_server.go @@ -55,18 +55,18 @@ type testStream struct { ctx context.Context data chan *pb.Record err error - closed int32 + closed atomic.Int32 } func (s *testStream) close() { - if atomic.CompareAndSwapInt32(&s.closed, 0, 1) { + if s.closed.CompareAndSwap(0, 1) { s.err = io.EOF close(s.data) } } func (s *testStream) Send(r *pb.Record) error { - if atomic.LoadInt32(&s.closed) == 1 { + if s.closed.Load() == 1 { return errors.New("stream has been closed") } s.data <- r @@ -97,11 +97,11 @@ func (s *testStream) SetTrailer(metadata.MD) {} func (s *testStream) Context() context.Context { return nil } -func (s *testStream) SendMsg(interface{}) error { +func (s *testStream) SendMsg(any) error { return errors.New("unimplemented") } -func (s *testStream) RecvMsg(interface{}) error { +func (s *testStream) RecvMsg(any) error { return errors.New("unimplemented") } @@ -115,7 +115,7 @@ func (s *testStream) CloseSend() error { return errors.New("unimplemented") } -func (s *testServerConn) sendRequest(ctx context.Context, req interface{}) (interface{}, error) { +func (s *testServerConn) sendRequest(ctx context.Context, req any) (any, error) { switch x := req.(type) { case *pb.TestBinlogRequest: stream := &testStream{ diff --git a/go.mod b/go.mod index 91893f2288..579e642f3b 100644 --- a/go.mod +++ b/go.mod @@ -459,6 +459,3 @@ replace sourcegraph.com/sourcegraph/appdash => github.com/sourcegraph/appdash v0 replace sourcegraph.com/sourcegraph/appdash-data => github.com/sourcegraph/appdash-data v0.0.0-20151005221446-73f23eafcf67 replace golang.org/x/text => golang.org/x/text v0.28.0 - -// tls10server=1 -godebug tlsrsakex=1 diff --git a/pkg/causality/conflict_detector.go b/pkg/causality/conflict_detector.go index 417fda4f21..5dc269354e 100644 --- a/pkg/causality/conflict_detector.go +++ b/pkg/causality/conflict_detector.go @@ -61,11 +61,9 @@ func NewConflictDetector[Txn txnEvent]( ret.resolvedTxnCaches[i] = newTxnCache[Txn](opt) } - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { ret.runBackgroundTasks() - }() + }) return ret } diff --git a/pkg/causality/internal/node.go b/pkg/causality/internal/node.go index cb2c6a7973..4975703282 100644 --- a/pkg/causality/internal/node.go +++ b/pkg/causality/internal/node.go @@ -58,8 +58,8 @@ type Node struct { // Following fields are used for notifying a node's dependers lock-free. totalDependencies int32 - removedDependencies int32 - resolvedDependencies int32 + removedDependencies atomic.Int32 + resolvedDependencies atomic.Int32 resolvedList []int64 // Following fields are protected by `mu`. @@ -103,14 +103,14 @@ func (n *Node) dependOn(dependencyNodes map[int64]*Node) { // The target has already been assigned to a cache. // In this case, record the cache ID in `resolvedList`, and this node // probably can be sent to the same cache and executed sequentially. - resolvedDependencies = atomic.AddInt32(&n.resolvedDependencies, 1) + resolvedDependencies = n.resolvedDependencies.Add(1) atomic.StoreInt64(&n.resolvedList[resolvedDependencies-1], target.assignedTo) } // Add the node to the target's dependers if the target has not been removed. if target.removed { // The target has already been removed. - atomic.AddInt32(&n.removedDependencies, 1) + n.removedDependencies.Add(1) } else if _, exist := target.getOrCreateDependers().ReplaceOrInsert(n); exist { // Should never depend on a target redundantly. log.Panic("should never exist") @@ -139,7 +139,7 @@ func (n *Node) remove() { if n.dependers != nil { // `mu` must be holded during accessing dependers. n.dependers.Ascend(func(node *Node) bool { - atomic.AddInt32(&node.removedDependencies, 1) + node.removedDependencies.Add(1) node.OnNotified(node.maybeResolve) return true }) @@ -170,7 +170,7 @@ func (n *Node) tryAssignTo(cacheID int64) bool { if n.dependers != nil { // `mu` must be holded during accessing dependers. n.dependers.Ascend(func(node *Node) bool { - resolvedDependencies := atomic.AddInt32(&node.resolvedDependencies, 1) + resolvedDependencies := node.resolvedDependencies.Add(1) atomic.StoreInt64(&node.resolvedList[resolvedDependencies-1], n.assignedTo) node.OnNotified(node.maybeResolve) return true @@ -209,13 +209,13 @@ func (n *Node) tryResolve() (int64, bool) { return assignedToAny, true } - removedDependencies := atomic.LoadInt32(&n.removedDependencies) + removedDependencies := n.removedDependencies.Load() if removedDependencies == n.totalDependencies { // All dependcies are removed, so assign the node to any cache is fine. return assignedToAny, true } - resolvedDependencies := atomic.LoadInt32(&n.resolvedDependencies) + resolvedDependencies := n.resolvedDependencies.Load() if resolvedDependencies == n.totalDependencies { firstDep := atomic.LoadInt64(&n.resolvedList[0]) hasDiffDep := false diff --git a/pkg/causality/internal/slots.go b/pkg/causality/internal/slots.go index 99e32ca429..15c2dabb2b 100644 --- a/pkg/causality/internal/slots.go +++ b/pkg/causality/internal/slots.go @@ -35,7 +35,7 @@ type Slots struct { // NewSlots creates a new Slots. func NewSlots(numSlots uint64) *Slots { slots := make([]slot, numSlots) - for i := uint64(0); i < numSlots; i++ { + for i := range numSlots { slots[i].nodes = make(map[uint64]*Node, 8) } return &Slots{ diff --git a/pkg/causality/internal/slots_test.go b/pkg/causality/internal/slots_test.go index 312523355a..e508b06d7b 100644 --- a/pkg/causality/internal/slots_test.go +++ b/pkg/causality/internal/slots_test.go @@ -29,13 +29,13 @@ func TestSlotsTrivial(t *testing.T) { slots := NewSlots(8) nodes := make([]*Node, 0, 1000) - for i := 0; i < count; i++ { + for range count { node := newNodeForTest(1, 2, 3, 4, 5) slots.Add(node) nodes = append(nodes, node) } - for i := 0; i < count; i++ { + for i := range count { slots.Remove(nodes[i]) } @@ -53,7 +53,7 @@ func TestSlotsConcurrentOps(t *testing.T) { slots := NewSlots(8) freeNodeChan := make(chan *Node, N) inuseNodeChan := make(chan *Node, N) - for i := 0; i < N; i++ { + for range N { freeNodeChan <- newNodeForTest(1, 9, 17, 25, 33) } @@ -62,9 +62,7 @@ func TestSlotsConcurrentOps(t *testing.T) { // test concurrent add and remove won't panic var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for { select { case <-ctx.Done(): @@ -75,11 +73,9 @@ func TestSlotsConcurrentOps(t *testing.T) { inuseNodeChan <- node } } - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for { select { case <-ctx.Done(): @@ -90,7 +86,7 @@ func TestSlotsConcurrentOps(t *testing.T) { freeNodeChan <- newNodeForTest(1, 9, 17, 25, 33) } } - }() + }) wg.Wait() } diff --git a/pkg/causality/tests/driver.go b/pkg/causality/tests/driver.go index bac3aa50c4..c06d02397e 100644 --- a/pkg/causality/tests/driver.go +++ b/pkg/causality/tests/driver.go @@ -43,7 +43,7 @@ func newConflictTestDriver( }) workers := make([]*workerForTest, 0, numWorkers) - for i := 0; i < numWorkers; i++ { + for i := range numWorkers { id := int64(i) workers = append(workers, newWorkerForTest(detector.GetOutChByCacheID(id))) } diff --git a/pkg/causality/tests/worker.go b/pkg/causality/tests/worker.go index 363fce7526..ba4aa84740 100644 --- a/pkg/causality/tests/worker.go +++ b/pkg/causality/tests/worker.go @@ -55,11 +55,9 @@ func newWorkerForTest(txnCh <-chan causality.TxnWithNotifier[*txnForTest]) *work closeCh: make(chan struct{}), } - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { ret.run(txnCh) - }() + }) return ret } diff --git a/pkg/causality/txn_cache_test.go b/pkg/causality/txn_cache_test.go index d83a937c5c..b3bdff1801 100644 --- a/pkg/causality/txn_cache_test.go +++ b/pkg/causality/txn_cache_test.go @@ -38,7 +38,7 @@ func TestBoundedWorker(t *testing.T) { Size: size, BlockStrategy: BlockStrategyWaitAvailable, }) - for i := 0; i < size; i++ { + for range size { // Add 10 events to the worker. ok := worker.add(TxnWithNotifier[txnEvent]{ TxnEvent: mockTxnEvent{}, @@ -66,7 +66,7 @@ func TestBoundedWorkerWithBlock(t *testing.T) { Size: size, BlockStrategy: BlockStrategyWaitEmpty, }) - for i := 0; i < size; i++ { + for range size { // Add 10 events to the worker. ok := worker.add(TxnWithNotifier[txnEvent]{ TxnEvent: mockTxnEvent{}, diff --git a/pkg/chann/chann_test.go b/pkg/chann/chann_test.go index 7b56f7e869..c7151ce9df 100644 --- a/pkg/chann/chann_test.go +++ b/pkg/chann/chann_test.go @@ -131,22 +131,22 @@ func TestChan(t *testing.T) { // ensure that we receive them non-corrupted in FIFO order. c := New[int](Cap(chanCap)) go func() { - for i := 0; i < 100; i++ { + for i := range 100 { c.In() <- i } }() - for i := 0; i < 100; i++ { + for i := range 100 { v := <-c.Out() require.Equalf(t, i, v, "chan[%d]", chanCap) } // Same, but using recv2. go func() { - for i := 0; i < 100; i++ { + for i := range 100 { c.In() <- i } }() - for i := 0; i < 100; i++ { + for i := range 100 { v, ok := <-c.Out() require.Truef(t, ok, "chan[%d]: receive failed, expected %v", chanCap, i) require.Equalf(t, i, v, "chan[%d]", chanCap) @@ -156,18 +156,18 @@ func TestChan(t *testing.T) { // ensure that we receive what we send. const P = 4 const L = 1000 - for p := 0; p < P; p++ { + for range P { go func() { - for i := 0; i < L; i++ { + for i := range L { c.In() <- i } }() } done := New[map[int]int](Cap(0)) - for p := 0; p < P; p++ { + for range P { go func() { recv := make(map[int]int) - for i := 0; i < L; i++ { + for range L { v := <-c.Out() recv[v] = recv[v] + 1 } @@ -175,7 +175,7 @@ func TestChan(t *testing.T) { }() } recv := make(map[int]int) - for p := 0; p < P; p++ { + for range P { for k, v := range <-done.Out() { recv[k] = recv[k] + v } @@ -242,7 +242,7 @@ const internalCacheSize = 16 + 1<<10 func TestNonblockSelectRace(t *testing.T) { n := 1000 done := New[bool](Cap(1)) - for i := 0; i < n; i++ { + for range n { c1 := New[int]() c2 := New[int]() // The input channel of an unbounded buffer have an internal @@ -250,7 +250,7 @@ func TestNonblockSelectRace(t *testing.T) { // queue both gets full, we are certain that once the next send // is complete, the out will be available for sure hence the // waiting time of a receive is bounded. - for i := 0; i < internalCacheSize; i++ { + for range internalCacheSize { c1.In() <- 1 } c1.In() <- 1 @@ -266,7 +266,7 @@ func TestNonblockSelectRace(t *testing.T) { done.In() <- true }() // Same for c2 - for i := 0; i < internalCacheSize; i++ { + for range internalCacheSize { c2.In() <- 1 } c2.In() <- 1 @@ -289,11 +289,11 @@ func TestNonblockSelectRace(t *testing.T) { func TestNonblockSelectRace2(t *testing.T) { n := 1000 done := make(chan bool, 1) - for i := 0; i < n; i++ { + for range n { c1 := New[int]() c2 := New[int]() // See TestNonblockSelectRace. - for i := 0; i < internalCacheSize; i++ { + for range internalCacheSize { c1.In() <- 1 } c1.In() <- 1 @@ -331,17 +331,15 @@ func TestUnboundedChann(t *testing.T) { t.Run("interface{}", func(t *testing.T) { t.Run("send", func(t *testing.T) { // Ensure send to an unbounded channel does not block. - c := New[interface{}]() + c := New[any]() blocked := false - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case c.In() <- true: default: blocked = true } - }() + }) wg.Wait() require.Falsef(t, blocked, "send op to an unbounded channel blocked") c.Close() @@ -350,23 +348,21 @@ func TestUnboundedChann(t *testing.T) { t.Run("recv", func(t *testing.T) { // Ensure that receive op from unbounded chan can happen on // the same goroutine of send op. - c := New[interface{}]() - wg.Add(1) - go func() { - defer wg.Done() + c := New[any]() + wg.Go(func() { c.In() <- true <-c.Out() - }() + }) wg.Wait() c.Close() }) t.Run("order", func(t *testing.T) { // Ensure that the unbounded channel processes everything FIFO. - c := New[interface{}]() - for i := 0; i < 1<<11; i++ { + c := New[any]() + for i := range 1 << 11 { c.In() <- i } - for i := 0; i < 1<<11; i++ { + for i := range 1 << 11 { val := <-c.Out() require.Equalf( t, @@ -383,15 +379,13 @@ func TestUnboundedChann(t *testing.T) { // Ensure send to an unbounded channel does not block. c := New[struct{}]() blocked := false - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case c.In() <- struct{}{}: default: blocked = true } - }() + }) <-c.Out() wg.Wait() require.Falsef(t, blocked, "send op to an unbounded channel blocked") @@ -402,23 +396,21 @@ func TestUnboundedChann(t *testing.T) { // Ensure that receive op from unbounded chan can happen on // the same goroutine of send op. c := New[struct{}]() - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { c.In() <- struct{}{} <-c.Out() - }() + }) wg.Wait() c.Close() }) t.Run("order", func(t *testing.T) { // Ensure that the unbounded channel processes everything FIFO. c := New[struct{}]() - for i := 0; i < 1<<11; i++ { + for range 1 << 11 { c.In() <- struct{}{} } n := 0 - for i := 0; i < 1<<11; i++ { + for range 1 << 11 { if _, ok := <-c.Out(); ok { n++ } @@ -433,7 +425,7 @@ func TestUnboundedChann(t *testing.T) { func TestUnboundedChannClose(t *testing.T) { t.Run("close-status", func(t *testing.T) { ch := New[any]() - for i := 0; i < 100; i++ { + for range 100 { ch.In() <- 0 } ch.Close() @@ -455,7 +447,7 @@ func TestUnboundedChannClose(t *testing.T) { n := 0 done := make(chan struct{}) ch := New[struct{}]() - for i := 0; i < N; i++ { + for range N { ch.In() <- struct{}{} } go func() { @@ -476,8 +468,8 @@ func TestUnboundedChannClose(t *testing.T) { N := 10 n := 0 done := make(chan struct{}) - ch := New[interface{}]() - for i := 0; i < N; i++ { + ch := New[any]() + for range N { ch.In() <- true } go func() { @@ -497,7 +489,7 @@ func TestUnboundedChannClose(t *testing.T) { func BenchmarkUnboundedChann(b *testing.B) { b.Run("interface{}", func(b *testing.B) { b.Run("sync", func(b *testing.B) { - c := New[interface{}]() + c := New[any]() defer c.Close() b.ResetTimer() b.ReportAllocs() @@ -507,7 +499,7 @@ func BenchmarkUnboundedChann(b *testing.B) { } }) b.Run("chann", func(b *testing.B) { - c := New[interface{}]() + c := New[any]() defer c.Close() b.ResetTimer() b.ReportAllocs() diff --git a/pkg/chann/drainable_chann_test.go b/pkg/chann/drainable_chann_test.go index e4dcd4b7e9..49490bece8 100644 --- a/pkg/chann/drainable_chann_test.go +++ b/pkg/chann/drainable_chann_test.go @@ -17,7 +17,7 @@ import "testing" func TestCloseAndDrain(t *testing.T) { ch := NewAutoDrainChann[int]() - for i := 0; i < 100; i++ { + for i := range 100 { ch.In() <- i } diff --git a/pkg/chdelay/channel_delayer_test.go b/pkg/chdelay/channel_delayer_test.go index 8433abbdf8..9d657d5ba8 100644 --- a/pkg/chdelay/channel_delayer_test.go +++ b/pkg/chdelay/channel_delayer_test.go @@ -38,19 +38,15 @@ func testChannelDelayer(t *testing.T, delayBy time.Duration, count int) { delayer := NewChannelDelayer(delayBy, inCh, 1024, 16) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { defer close(inCh) - for i := 0; i < count; i++ { + for range count { inCh <- time.Now() } - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { counter := 0 for ts := range delayer.Out() { @@ -59,7 +55,7 @@ func testChannelDelayer(t *testing.T, delayBy time.Duration, count int) { } require.Equal(t, count, counter) - }() + }) wg.Wait() delayer.Close() diff --git a/pkg/column-mapping/column.go b/pkg/column-mapping/column.go index 77e1a4fd28..923952c9f5 100644 --- a/pkg/column-mapping/column.go +++ b/pkg/column-mapping/column.go @@ -52,7 +52,7 @@ const ( // Exprs is some built-in expression for column mapping // only supports some poor expressions now, // we would unify tableInfo later and support more -var Exprs = map[Expr]func(*mappingInfo, []interface{}) ([]interface{}, error){ +var Exprs = map[Expr]func(*mappingInfo, []any) ([]any, error){ AddPrefix: addPrefix, // arguments contains prefix AddSuffix: addSuffix, // arguments contains suffix // arguments contains [instance_id, prefix of schema, prefix of table] @@ -240,7 +240,7 @@ func (m *Mapping) RemoveRule(rule *Rule) error { } // HandleRowValue handles row value -func (m *Mapping) HandleRowValue(schema, table string, columns []string, vals []interface{}) ([]interface{}, []int, error) { +func (m *Mapping) HandleRowValue(schema, table string, columns []string, vals []any) ([]any, []int, error) { if m == nil { return vals, nil, nil } @@ -408,7 +408,7 @@ func tableName(schema, table string) string { return fmt.Sprintf("`%s`.`%s`", schema, table) } -func addPrefix(info *mappingInfo, vals []interface{}) ([]interface{}, error) { +func addPrefix(info *mappingInfo, vals []any) ([]any, error) { prefix := info.rule.Arguments[0] originStr, ok := vals[info.targetPosition].(string) if !ok { @@ -424,7 +424,7 @@ func addPrefix(info *mappingInfo, vals []interface{}) ([]interface{}, error) { return vals, nil } -func addSuffix(info *mappingInfo, vals []interface{}) ([]interface{}, error) { +func addSuffix(info *mappingInfo, vals []any) ([]any, error) { suffix := info.rule.Arguments[0] originStr, ok := vals[info.targetPosition].(string) if !ok { @@ -439,7 +439,7 @@ func addSuffix(info *mappingInfo, vals []interface{}) ([]interface{}, error) { return vals, nil } -func partitionID(info *mappingInfo, vals []interface{}) ([]interface{}, error) { +func partitionID(info *mappingInfo, vals []any) ([]any, error) { // only int64 now var ( originID int64 diff --git a/pkg/column-mapping/column_test.go b/pkg/column-mapping/column_test.go index 6a8ddb98e6..886cca72ad 100644 --- a/pkg/column-mapping/column_test.go +++ b/pkg/column-mapping/column_test.go @@ -53,20 +53,20 @@ func TestHandle(t *testing.T) { require.Len(t, m.cache.infos, 0) // test add prefix, add suffix is similar - vals, poss, err := m.HandleRowValue("test", "xxx", []string{"age", "id"}, []interface{}{1, "1"}) + vals, poss, err := m.HandleRowValue("test", "xxx", []string{"age", "id"}, []any{1, "1"}) require.NoError(t, err) - require.Equal(t, []interface{}{1, "instance_id:1"}, vals) + require.Equal(t, []any{1, "instance_id:1"}, vals) require.Equal(t, []int{-1, 1}, poss) // test cache - vals, poss, err = m.HandleRowValue("test", "xxx", []string{"name"}, []interface{}{1, "1"}) + vals, poss, err = m.HandleRowValue("test", "xxx", []string{"name"}, []any{1, "1"}) require.NoError(t, err) - require.Equal(t, []interface{}{1, "instance_id:1"}, vals) + require.Equal(t, []any{1, "instance_id:1"}, vals) require.Equal(t, []int{-1, 1}, poss) // test resetCache m.resetCache() - _, _, err = m.HandleRowValue("test", "xxx", []string{"name"}, []interface{}{"1"}) + _, _, err = m.HandleRowValue("test", "xxx", []string{"name"}, []any{"1"}) require.Error(t, err) @@ -241,21 +241,21 @@ func TestPartitionID(t *testing.T) { } // test wrong type - _, err := partitionID(info, []interface{}{1, "ha"}) + _, err := partitionID(info, []any{1, "ha"}) require.Error(t, err) // test exceed maxOriginID - _, err = partitionID(info, []interface{}{"ha", 1 << 44}) + _, err = partitionID(info, []any{"ha", 1 << 44}) require.Error(t, err) - vals, err := partitionID(info, []interface{}{"ha", 1}) + vals, err := partitionID(info, []any{"ha", 1}) require.NoError(t, err) - require.Equal(t, []interface{}{"ha", int64(2<<59 | 1<<52 | 1<<44 | 1)}, vals) + require.Equal(t, []any{"ha", int64(2<<59 | 1<<52 | 1<<44 | 1)}, vals) info.instanceID = 0 - vals, err = partitionID(info, []interface{}{"ha", "123"}) + vals, err = partitionID(info, []any{"ha", "123"}) require.NoError(t, err) - require.Equal(t, []interface{}{"ha", fmt.Sprintf("%d", int64(1<<52|1<<44|123))}, vals) + require.Equal(t, []any{"ha", fmt.Sprintf("%d", int64(1<<52|1<<44|123))}, vals) } func TestCaseSensitive(t *testing.T) { @@ -271,8 +271,8 @@ func TestCaseSensitive(t *testing.T) { require.Len(t, m.cache.infos, 0) // test add prefix, add suffix is similar - vals, poss, err := m.HandleRowValue("test", "xxx", []string{"age", "id"}, []interface{}{1, "1"}) + vals, poss, err := m.HandleRowValue("test", "xxx", []string{"age", "id"}, []any{1, "1"}) require.NoError(t, err) - require.Equal(t, []interface{}{1, "1"}, vals) + require.Equal(t, []any{1, "1"}, vals) require.Nil(t, poss) } diff --git a/pkg/compression/compress.go b/pkg/compression/compress.go index 70a3274c88..4d8229b674 100644 --- a/pkg/compression/compress.go +++ b/pkg/compression/compress.go @@ -35,13 +35,13 @@ const ( var ( lz4ReaderPool = sync.Pool{ - New: func() interface{} { + New: func() any { return lz4.NewReader(nil) }, } bufferPool = sync.Pool{ - New: func() interface{} { + New: func() any { return new(bytes.Buffer) }, } diff --git a/pkg/container/queue/chunkqueue.go b/pkg/container/queue/chunkqueue.go index f7cc2da942..524c2c6056 100644 --- a/pkg/container/queue/chunkqueue.go +++ b/pkg/container/queue/chunkqueue.go @@ -69,10 +69,7 @@ func NewChunkQueueLeastCapacity[T any](minCapacity int) *ChunkQueue[T] { elementSize = 1 } - chunkLength := int(defaultSizePerChunk / elementSize) - if chunkLength < minimumChunkLen { - chunkLength = minimumChunkLen - } + chunkLength := max(int(defaultSizePerChunk/elementSize), minimumChunkLen) q := &ChunkQueue[T]{ head: 0, @@ -159,7 +156,7 @@ func (q *ChunkQueue[T]) addSpace(n int) { q.adjustChunksArray(chunksNum) } - for i := 0; i < chunksNum; i++ { + for range chunksNum { c := q.chunkPool.Get().(*chunk[T]) c.queue = q q.chunks[q.tail] = c @@ -192,10 +189,7 @@ func (q *ChunkQueue[T]) adjustChunksArray(extend int) { } case extend < 0: // for shrink, the new length is max(defaultLength, tail - head + 1) - newLen = used + 1 - if newLen < defaultPitchArrayLen { - newLen = defaultPitchArrayLen - } + newLen = max(used+1, defaultPitchArrayLen) } if newLen != len(q.chunks) { // If the length changed, allocate a new array and do copy @@ -241,10 +235,7 @@ func (q *ChunkQueue[T]) PushMany(vals ...T) { var addLen int for n > 0 { - addLen = q.chunkLength - c.r - if addLen > n { - addLen = n - } + addLen = min(q.chunkLength-c.r, n) copy(c.data[c.r:c.r+addLen], vals[cnt:cnt+addLen]) c.r += addLen q.size += addLen @@ -308,10 +299,7 @@ func (q *ChunkQueue[T]) PopMany(n int) ([]T, bool) { cnt := 0 for i := q.head; i < q.tail && cnt < n; i++ { c := q.chunks[i] - popLen := c.len() - if n-cnt < popLen { - popLen = n - cnt - } + popLen := min(n-cnt, c.len()) for j := 0; j < popLen; j++ { res[cnt+j] = c.data[c.l+j] c.data[c.l+j] = q.defaultValue diff --git a/pkg/container/queue/chunkqueue_test.go b/pkg/container/queue/chunkqueue_test.go index 7138d46ee8..e161763cbb 100644 --- a/pkg/container/queue/chunkqueue_test.go +++ b/pkg/container/queue/chunkqueue_test.go @@ -47,7 +47,7 @@ func TestChunkQueueCommon(t *testing.T) { // PushMany & PopMany elements := make([]int, 0, testCaseSize) require.True(t, q.Empty()) - for i := 0; i < testCaseSize; i++ { + for i := range testCaseSize { elements = append(elements, i) } q.PushMany(elements...) @@ -66,7 +66,7 @@ func TestChunkQueueCommon(t *testing.T) { q.PushMany(elements...) require.Equal(t, testCaseSize, q.Len()) require.False(t, q.Empty()) - for j := 0; j < testCaseSize; j++ { + for range testCaseSize { i := rand.Intn(testCaseSize) v := q.Peek(i) it := q.GetIterator(i) @@ -89,7 +89,7 @@ func TestChunkQueueCommon(t *testing.T) { require.True(t, ok) // Pop one by one - for i := 0; i < testCaseSize; i++ { + for i := range testCaseSize { h, ok := q.Head() require.Equal(t, i, h) require.True(t, ok) @@ -161,7 +161,7 @@ func doRandomTest[T comparable](t *testing.T, getVal func() T) { q := NewChunkQueue[T]() slice := make([]T, 0, 100) var val T - for i := 0; i < 100; i++ { + for i := range 100 { op := rand.Intn(4) if i == 99 { op = opPopAll @@ -174,7 +174,7 @@ func doRandomTest[T comparable](t *testing.T, getVal func() T) { case opPushMany: n := rand.Intn(1024) + 1 vals := make([]T, n) - for j := 0; j < n; j++ { + for range n { vals = append(vals, getVal()) } q.PushMany(vals...) @@ -201,14 +201,14 @@ func doRandomTest[T comparable](t *testing.T, getVal func() T) { popSlice := slice[0:n] slice = append(make([]T, 0, len(slice[n:])), slice[n:]...) - for i := 0; i < len(pops); i++ { + for i := range pops { require.Equal(t, popSlice[i], pops[i]) } } case opPopAll: pops := q.PopAll() require.Equal(t, len(pops), len(slice)) - for i := 0; i < len(pops); i++ { + for i := range pops { require.Equal(t, slice[i], pops[i]) } slice = slice[:0] @@ -231,7 +231,7 @@ func TestExpand(t *testing.T) { t.Parallel() q := NewChunkQueue[int]() - for i := 0; i < testCaseSize; i++ { + for range testCaseSize { q.Push(1) require.Equal(t, 1, q.Len()) freeSpace := q.Cap() - q.Len() @@ -248,7 +248,7 @@ func TestDequeueMany(t *testing.T) { q := NewChunkQueue[int]() x := testCaseSize - for v := 0; v < x; v++ { + for v := range x { q.Push(v) } f := 0 @@ -280,7 +280,7 @@ func TestRange(t *testing.T) { t.Parallel() q := NewChunkQueue[int]() - for i := 0; i < testCaseSize; i++ { + for i := range testCaseSize { q.Push(i) } @@ -329,7 +329,7 @@ func TestRangeAndPop(t *testing.T) { t.Parallel() q := NewChunkQueue[int]() - for i := 0; i < testCaseSize; i++ { + for i := range testCaseSize { q.Push(i) } @@ -393,7 +393,7 @@ func TestChunkQueuePushMany(t *testing.T) { func prepareSlice(n int) []int { data := make([]int, 0, n) - for i := 0; i < n; i++ { + for i := range n { data = append(data, i) } return data @@ -401,7 +401,7 @@ func prepareSlice(n int) []int { func prepareChunkQueue(n int) *ChunkQueue[int] { q := NewChunkQueue[int]() - for i := 0; i < n; i++ { + for i := range n { q.Push(i) } return q @@ -488,7 +488,7 @@ func BenchmarkPopMany(b *testing.B) { b.Run("PopMany-3rdPartyDeque", func(b *testing.B) { x := b.N q := deque.NewDeque() - for i := 0; i < x; i++ { + for i := range x { q.Enqueue(i) } ls := []int{x / 5, x / 5, x / 5, x / 5, x - x/5*4} @@ -542,7 +542,7 @@ func BenchmarkChunkQueueLoopPop(b *testing.B) { q.RangeAndPop(func(val int) bool { return val < 0 }) - for i := 0; i < x; i++ { + for range x { v, _ := q.Head() if v < 0 { break diff --git a/pkg/container/queue/iterator_test.go b/pkg/container/queue/iterator_test.go index 64e2ef6462..eef071ed53 100644 --- a/pkg/container/queue/iterator_test.go +++ b/pkg/container/queue/iterator_test.go @@ -28,7 +28,7 @@ const ( func TestChunkQueueIteratorPrevNext(t *testing.T) { t.Parallel() q := NewChunkQueue[int]() - for i := 0; i < iterTestSize; i++ { + for i := range iterTestSize { q.Push(i) } @@ -57,7 +57,7 @@ func BenchmarkIterate(b *testing.B) { b.Run("Iterate-ChunkQueue-by-iterator", func(b *testing.B) { q := NewChunkQueue[int]() n := b.N - for i := 0; i < n; i++ { + for i := range n { q.Push(i) } b.ResetTimer() @@ -75,7 +75,7 @@ func BenchmarkIterate(b *testing.B) { b.Run("Iterate-ChunkQueue-by-Peek", func(b *testing.B) { q := NewChunkQueue[int]() n := b.N - for i := 0; i < n; i++ { + for i := range n { q.Push(i) } b.ResetTimer() @@ -91,7 +91,7 @@ func BenchmarkIterate(b *testing.B) { b.Run("Iterate-ChunkQueue-by-Range", func(b *testing.B) { q := NewChunkQueue[int]() n := b.N - for i := 0; i < n; i++ { + for i := range n { q.Push(i) } b.ResetTimer() @@ -107,12 +107,12 @@ func BenchmarkIterate(b *testing.B) { b.Run("Iterate-Slice-byLoop", func(b *testing.B) { n := b.N q := make([]int, n) - for i := 0; i < n; i++ { + for i := range n { q[i] = i } b.ResetTimer() - for i := 0; i < len(q); i++ { + for i := range q { if q[i] != i { panic("error") } @@ -123,7 +123,7 @@ func BenchmarkIterate(b *testing.B) { q := deque.NewDeque() n := b.N - for i := 0; i < n; i++ { + for i := range n { q.Enqueue(i) } b.ResetTimer() @@ -140,12 +140,12 @@ func BenchmarkIterate(b *testing.B) { q := deque.NewDeque() n := b.N - for i := 0; i < n; i++ { + for i := range n { q.Enqueue(i) } b.ResetTimer() - for i := 0; i < n; i++ { + for i := range n { val := q.Peek(i) if val != i { panic("not equal") @@ -169,7 +169,7 @@ func TestChunkQueueGetIterator(t *testing.T) { require.False(t, oldIt.Valid(), oldIt.Prev()) require.True(t, q.Empty()) - for i := 0; i < iterTestSize; i++ { + for i := range iterTestSize { q.Push(i) } require.True(t, q.End().Index() < 0) @@ -179,7 +179,7 @@ func TestChunkQueueGetIterator(t *testing.T) { }) require.NotPanics(t, func() { - for i := 0; i < iterTestSize; i++ { + for i := range iterTestSize { it = q.GetIterator(i) require.Equal(t, i, it.Index(), it.Value(), q.Peek(i)) } diff --git a/pkg/container/sortmap/sort.go b/pkg/container/sortmap/sort.go index 1cb04e6db5..d577a3cf16 100644 --- a/pkg/container/sortmap/sort.go +++ b/pkg/container/sortmap/sort.go @@ -14,19 +14,18 @@ package sortmap import ( + "cmp" "sort" - - "golang.org/x/exp/constraints" ) // Pair represents the KV pairs in the input map of Sort. -type Pair[K constraints.Ordered, V any] struct { +type Pair[K cmp.Ordered, V any] struct { Key K Value V } // Sort converts an unordered golang map to a slice sorted by map key. -func Sort[K constraints.Ordered, V any](m map[K]V) []Pair[K, V] { +func Sort[K cmp.Ordered, V any](m map[K]V) []Pair[K, V] { s := make([]Pair[K, V], 0, len(m)) for k, v := range m { s = append(s, Pair[K, V]{k, v}) diff --git a/pkg/errors/helper.go b/pkg/errors/helper.go index 0bbd574fa5..ee184b4c84 100644 --- a/pkg/errors/helper.go +++ b/pkg/errors/helper.go @@ -27,7 +27,7 @@ import ( // as cause error. // If given `err` is nil, returns a nil error, which a the different behavior // against `Wrap` function in pingcap/errors. -func WrapError(rfcError *errors.Error, err error, args ...interface{}) error { +func WrapError(rfcError *errors.Error, err error, args ...any) error { if err == nil { return nil } @@ -170,7 +170,7 @@ func IsCliUnprintableError(err error) bool { } // WrapChangefeedUnretryableErr wraps an error into ErrChangefeedUnRetryable. -func WrapChangefeedUnretryableErr(err error, args ...interface{}) error { +func WrapChangefeedUnretryableErr(err error, args ...any) error { return WrapError(ErrChangefeedUnretryable, err, args...) } diff --git a/pkg/errors/helper_test.go b/pkg/errors/helper_test.go index 6c705f8325..8fc417eee4 100644 --- a/pkg/errors/helper_test.go +++ b/pkg/errors/helper_test.go @@ -33,13 +33,13 @@ func TestWrapError(t *testing.T) { err error isNil bool expected string - args []interface{} + args []any }{ {ErrDecodeFailed, nil, true, "", nil}, { ErrDecodeFailed, err, false, "[CDC:ErrDecodeFailed]decode failed: args data: cause error", - []interface{}{"args data"}, + []any{"args data"}, }, } ) diff --git a/pkg/label/label_test.go b/pkg/label/label_test.go index fb6799cd6a..55b1c23201 100644 --- a/pkg/label/label_test.go +++ b/pkg/label/label_test.go @@ -51,7 +51,6 @@ func TestNewKey(t *testing.T) { t.Parallel() for _, tc := range cases { - tc := tc t.Run(tc.str, func(t *testing.T) { t.Parallel() res, err := NewKey(tc.str) @@ -69,7 +68,6 @@ func TestNewValue(t *testing.T) { t.Parallel() for _, tc := range cases { - tc := tc t.Run(tc.str, func(t *testing.T) { t.Parallel() res, err := NewValue(tc.str) diff --git a/pkg/label/selector_test.go b/pkg/label/selector_test.go index f764498bec..d80934a7f0 100644 --- a/pkg/label/selector_test.go +++ b/pkg/label/selector_test.go @@ -140,7 +140,6 @@ func TestSelectorMatches(t *testing.T) { } for idx, tc := range cases { - tc := tc t.Run(strconv.Itoa(idx), func(t *testing.T) { t.Parallel() require.Equal(t, tc.shouldMatch, tc.selector.Matches(tc.labels)) @@ -161,13 +160,11 @@ func TestSelectorRegexLazyCompile(t *testing.T) { labelSetNotMatch := map[Key]Value{"tenant": "abcdef", "node_type": "2"} var wg sync.WaitGroup - for i := 0; i < 10; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range 10 { + wg.Go(func() { require.True(t, selector.Matches(labelSetMatch)) require.False(t, selector.Matches(labelSetNotMatch)) - }() + }) } wg.Wait() @@ -235,7 +232,6 @@ func TestSelectorValidate(t *testing.T) { } for idx, tc := range cases { - tc := tc t.Run(strconv.Itoa(idx), func(t *testing.T) { t.Parallel() tc.checkErr(tc.selector.Validate()) diff --git a/pkg/leakutil/leak_helper_test.go b/pkg/leakutil/leak_helper_test.go index 940cc065cb..622f49a7b3 100644 --- a/pkg/leakutil/leak_helper_test.go +++ b/pkg/leakutil/leak_helper_test.go @@ -20,7 +20,7 @@ import ( ) func TestSetUpLeakTest(t *testing.T) { - leakChan := make(chan interface{}) + leakChan := make(chan any) go func() { <-leakChan diff --git a/pkg/notify/notify_test.go b/pkg/notify/notify_test.go index f64f2a232f..2704c6991b 100644 --- a/pkg/notify/notify_test.go +++ b/pkg/notify/notify_test.go @@ -36,7 +36,7 @@ func TestNotifyHub(t *testing.T) { require.Nil(t, err) finishedCh := make(chan struct{}) go func() { - for i := 0; i < 5; i++ { + for range 5 { time.Sleep(time.Second) notifier.Notify() } @@ -82,11 +82,11 @@ func TestContinusStop(t *testing.T) { n := 50 receivers := make([]*Receiver, n) var err error - for i := 0; i < n; i++ { + for i := range n { receivers[i], err = notifier.NewReceiver(10 * time.Millisecond) require.Nil(t, err) } - for i := 0; i < n; i++ { + for i := range n { i := i go func() { for { @@ -98,7 +98,7 @@ func TestContinusStop(t *testing.T) { } }() } - for i := 0; i < n; i++ { + for i := range n { receivers[i].Stop() } <-ctx.Done() @@ -122,9 +122,7 @@ func TestNotifierMultiple(t *testing.T) { counter := atomic.NewInt32(0) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for { _, ok := <-receiver.C if !ok { @@ -132,15 +130,13 @@ func TestNotifierMultiple(t *testing.T) { } counter.Add(1) } - }() + }) receiver1, err := notifier.NewReceiver(time.Minute) require.NoError(t, err) counter1 := atomic.NewInt32(0) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for { _, ok := <-receiver1.C if !ok { @@ -148,10 +144,10 @@ func TestNotifierMultiple(t *testing.T) { } counter1.Add(1) } - }() + }) N := 5 - for i := 0; i < N; i++ { + for range N { notifier.Notify() time.Sleep(time.Millisecond * 100) } diff --git a/pkg/p2p/client.go b/pkg/p2p/client.go index 9b67424d66..1cbad9cd3a 100644 --- a/pkg/p2p/client.go +++ b/pkg/p2p/client.go @@ -30,10 +30,10 @@ type MessageClient interface { Run(ctx context.Context, network string, addr string, receiverID NodeID, credential *security.Credential) (ret error) // SendMessage sends a message of a given topic. It would block if the inner channel is congested. - SendMessage(ctx context.Context, topic Topic, value interface{}) (seq Seq, ret error) + SendMessage(ctx context.Context, topic Topic, value any) (seq Seq, ret error) // TrySendMessage tries to send a message of a given topic. It will return an error if the inner channel is congested. - TrySendMessage(ctx context.Context, topic Topic, value interface{}) (seq Seq, ret error) + TrySendMessage(ctx context.Context, topic Topic, value any) (seq Seq, ret error) // CurrentAck is used to query the latest sequence number for a topic that is acknowledged by the server. // Note: currently only used for test. @@ -87,7 +87,7 @@ func (c *localMessageClient) Run( return nil } -func (c *localMessageClient) SendMessage(ctx context.Context, topic Topic, value interface{}) (Seq, error) { +func (c *localMessageClient) SendMessage(ctx context.Context, topic Topic, value any) (Seq, error) { select { case <-ctx.Done(): return 0, ctx.Err() @@ -98,7 +98,7 @@ func (c *localMessageClient) SendMessage(ctx context.Context, topic Topic, value } } -func (c *localMessageClient) TrySendMessage(ctx context.Context, topic Topic, value interface{}) (Seq, error) { +func (c *localMessageClient) TrySendMessage(ctx context.Context, topic Topic, value any) (Seq, error) { select { case <-ctx.Done(): return 0, ctx.Err() diff --git a/pkg/p2p/client_batch_sender.go b/pkg/p2p/client_batch_sender.go index 3527a77fe6..8070cc0353 100644 --- a/pkg/p2p/client_batch_sender.go +++ b/pkg/p2p/client_batch_sender.go @@ -46,10 +46,7 @@ type grpcClientBatchSender struct { } func newClientBatchSender(stream MessageClientStream, maxEntryCount, maxSizeBytes int) clientBatchSender[MessageEntry] { - sliceCap := maxEntryCount - if sliceCap > maxPreallocBatchSize { - sliceCap = maxPreallocBatchSize - } + sliceCap := min(maxEntryCount, maxPreallocBatchSize) return &grpcClientBatchSender{ stream: stream, buffer: make([]MessageEntry, 0, sliceCap), diff --git a/pkg/p2p/client_batch_sender_test.go b/pkg/p2p/client_batch_sender_test.go index aa035a36b1..e6fbeb07bd 100644 --- a/pkg/p2p/client_batch_sender_test.go +++ b/pkg/p2p/client_batch_sender_test.go @@ -14,7 +14,6 @@ package p2p import ( - "context" "fmt" "math" "testing" @@ -25,8 +24,7 @@ import ( ) func TestClientBatchSenderMaxCount(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() + ctx := t.Context() grpcStream := newMockSendMessageClient(ctx) sender := newClientBatchSender(grpcStream, 100, math.MaxInt64) @@ -61,8 +59,7 @@ func TestClientBatchSenderMaxCount(t *testing.T) { } func TestClientBatchSenderMaxSize(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() + ctx := t.Context() grpcStream := newMockSendMessageClient(ctx) sender := newClientBatchSender(grpcStream, math.MaxInt64, 1000) @@ -100,8 +97,7 @@ func TestClientBatchSenderMaxSize(t *testing.T) { } func TestClientBatchSenderFlush(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() + ctx := t.Context() grpcStream := newMockSendMessageClient(ctx) sender := newClientBatchSender(grpcStream, math.MaxInt64, 1000) diff --git a/pkg/p2p/client_connector_test.go b/pkg/p2p/client_connector_test.go index 1777f707cf..dc464ec311 100644 --- a/pkg/p2p/client_connector_test.go +++ b/pkg/p2p/client_connector_test.go @@ -30,11 +30,11 @@ import ( ) type mockService struct { - callCount int32 + callCount atomic.Int32 } func (s *mockService) SendMessage(server p2p.CDCPeerToPeer_SendMessageServer) error { - atomic.AddInt32(&s.callCount, 1) + s.callCount.Add(1) return nil } @@ -52,11 +52,9 @@ func TestClientConnector(t *testing.T) { p2p.RegisterCDCPeerToPeerServer(grpcServer, mockService) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { _ = grpcServer.Serve(lis) - }() + }) cc := newClientConnector() @@ -72,7 +70,7 @@ func TestClientConnector(t *testing.T) { require.NoError(t, err) require.Eventually(t, func() bool { - return atomic.LoadInt32(&mockService.callCount) == 1 + return mockService.callCount.Load() == 1 }, time.Second*5, time.Millisecond*100) cancel() diff --git a/pkg/p2p/grpc_client.go b/pkg/p2p/grpc_client.go index a926d11b18..d8d46cd5b7 100644 --- a/pkg/p2p/grpc_client.go +++ b/pkg/p2p/grpc_client.go @@ -15,6 +15,7 @@ package p2p import ( "context" + "maps" "sync" "time" @@ -251,9 +252,7 @@ func (c *grpcMessageClient) runTx(ctx context.Context, stream MessageClientStrea func (c *grpcMessageClient) retrySending(ctx context.Context, stream MessageClientStream) error { topicsCloned := make(map[string]*topicEntry) c.topicMu.RLock() - for k, v := range c.topics { - topicsCloned[k] = v - } + maps.Copy(topicsCloned, c.topics) c.topicMu.RUnlock() batcher := c.newSenderFn(stream) @@ -355,13 +354,13 @@ func (c *grpcMessageClient) runRx(ctx context.Context, stream MessageClientStrea // SendMessage sends a message. It will block if the client is not ready to // accept the message for now. Once the function returns without an error, // the client will try its best to send the message, until `Run` is canceled. -func (c *grpcMessageClient) SendMessage(ctx context.Context, topic Topic, value interface{}) (seq Seq, ret error) { +func (c *grpcMessageClient) SendMessage(ctx context.Context, topic Topic, value any) (seq Seq, ret error) { return c.sendMessage(ctx, topic, value, false) } // TrySendMessage tries to send a message. It will return ErrPeerMessageSendTryAgain // if the client is not ready to accept the message. -func (c *grpcMessageClient) TrySendMessage(ctx context.Context, topic Topic, value interface{}) (seq Seq, ret error) { +func (c *grpcMessageClient) TrySendMessage(ctx context.Context, topic Topic, value any) (seq Seq, ret error) { // FIXME (zixiong): This is a temporary way for testing client congestion. // This failpoint will be removed once we abstract the MessageClient as an interface. failpoint.Inject("ClientInjectSendMessageTryAgain", func() { @@ -376,7 +375,7 @@ func (c *grpcMessageClient) TrySendMessage(ctx context.Context, topic Topic, val return c.sendMessage(ctx, topic, value, true) } -func (c *grpcMessageClient) sendMessage(ctx context.Context, topic Topic, value interface{}, nonblocking bool) (seq Seq, ret error) { +func (c *grpcMessageClient) sendMessage(ctx context.Context, topic Topic, value any, nonblocking bool) (seq Seq, ret error) { if c.isClosed.Load() { return 0, cerrors.ErrPeerMessageClientClosed.GenWithStackByArgs() } diff --git a/pkg/p2p/grpc_client_test.go b/pkg/p2p/grpc_client_test.go index 378b82a1a9..3fd3d94a25 100644 --- a/pkg/p2p/grpc_client_test.go +++ b/pkg/p2p/grpc_client_test.go @@ -32,12 +32,12 @@ import ( type mockClientBatchSender struct { mock.Mock - sendCnt int32 // atomic + sendCnt atomic.Int32 // atomic } func (s *mockClientBatchSender) Append(msg MessageEntry) error { args := s.Called(msg) - atomic.AddInt32(&s.sendCnt, 1) + s.sendCnt.Add(1) return args.Error(0) } @@ -82,16 +82,16 @@ func TestMessageClientBasics(t *testing.T) { connector := &mockClientConnector{} grpcClient := &mockCDCPeerToPeerClient{} client.connector = connector - var closed int32 + var closed atomic.Int32 connector.On("Connect", mock.Anything).Return( grpcClient, func() { - require.Equal(t, int32(0), atomic.LoadInt32(&closed)) - atomic.StoreInt32(&closed, 1) + require.Equal(t, int32(0), closed.Load()) + closed.Store(1) }, nil, ).Run(func(_ mock.Arguments) { - atomic.StoreInt32(&closed, 0) + closed.Store(0) }) // Test point 1: Connecting to the server and sends the meta @@ -113,17 +113,15 @@ func TestMessageClientBasics(t *testing.T) { grpcStream.On("Recv").Return(nil, nil) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "", "", "node-2", &security.Credential{}) require.Error(t, err) require.Regexp(t, "context canceled", err.Error()) - }() + }) // wait for the stream meta to be received require.Eventuallyf(t, func() bool { - return atomic.LoadInt32(&grpcStream.msgCount) > 0 + return grpcStream.msgCount.Load() > 0 }, time.Second*1, time.Millisecond*10, "meta should have been received") connector.AssertExpectations(t) @@ -139,7 +137,7 @@ func TestMessageClientBasics(t *testing.T) { require.NoError(t, err) require.Equal(t, int64(1), seq) require.Eventuallyf(t, func() bool { - return atomic.LoadInt32(&sender.sendCnt) == 1 + return sender.sendCnt.Load() == 1 }, time.Second*1, time.Millisecond*10, "message should have been received") sender.AssertExpectations(t) @@ -176,7 +174,7 @@ func TestMessageClientBasics(t *testing.T) { require.NoError(t, err) require.Equal(t, int64(2), seq) require.Eventuallyf(t, func() bool { - return atomic.LoadInt32(&sender.sendCnt) == 2 + return sender.sendCnt.Load() == 2 }, time.Second*1, time.Millisecond*10, "message should have been received") sender.AssertExpectations(t) @@ -209,7 +207,7 @@ func TestMessageClientBasics(t *testing.T) { }).Once() // Resets the sentCnt - atomic.StoreInt32(&sender.sendCnt, 0) + sender.sendCnt.Store(0) grpcStream.replyCh <- &p2p.SendMessageResponse{ ExitReason: p2p.ExitReason_OK, Ack: []*p2p.Ack{{ @@ -219,7 +217,7 @@ func TestMessageClientBasics(t *testing.T) { } // We expect the message to be resent require.Eventually(t, func() bool { - return atomic.LoadInt32(&sender.sendCnt) == 1 + return sender.sendCnt.Load() == 1 }, time.Second*1, time.Millisecond*10, "message should have been resent") sender.AssertExpectations(t) @@ -263,13 +261,11 @@ func TestClientPermanentFailure(t *testing.T) { }, nil) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "", "", "node-2", &security.Credential{}) require.Error(t, err) require.Regexp(t, ".*ErrPeerMessageClientPermanentFail.*", err.Error()) - }() + }) wg.Wait() @@ -324,13 +320,11 @@ func TestClientSendAnomalies(t *testing.T) { sender.On("Append", mock.Anything).Return(nil) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(runCtx, "", "", "node-2", &security.Credential{}) require.Error(t, err) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) // Test point 1: ErrPeerMessageSendTryAgain _, err := client.TrySendMessage(ctx, "test-topic", &testMessage{Value: 1}) diff --git a/pkg/p2p/internal/send_chan_test.go b/pkg/p2p/internal/send_chan_test.go index f35d4814ba..c7e1dab0a0 100644 --- a/pkg/p2p/internal/send_chan_test.go +++ b/pkg/p2p/internal/send_chan_test.go @@ -40,10 +40,8 @@ func TestSendChanBasics(t *testing.T) { var wg sync.WaitGroup // Runs the producers - for i := 0; i < numProducers; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range numProducers { + wg.Go(func() { lastSeq := int64(0) for j := 0; j < numMsgPerProducer; { ok, seq := c.SendAsync( @@ -59,13 +57,11 @@ func TestSendChanBasics(t *testing.T) { require.Greater(t, seq, lastSeq) lastSeq = seq } - }() + }) } // Runs the consumer - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { ticker := time.NewTicker(time.Millisecond * 10) recvCount := 0 @@ -83,7 +79,7 @@ func TestSendChanBasics(t *testing.T) { return } } - }() + }) wg.Wait() cancel() @@ -101,12 +97,10 @@ func TestSendChanSendSync(t *testing.T) { var wg sync.WaitGroup // Runs the producers - for i := 0; i < numProducers; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range numProducers { + wg.Go(func() { lastSeq := int64(0) - for j := 0; j < numMsgPerProducerForSync; j++ { + for range numMsgPerProducerForSync { seq, err := c.SendSync( ctx, "test-topic", @@ -119,13 +113,11 @@ func TestSendChanSendSync(t *testing.T) { require.Greater(t, seq, lastSeq) lastSeq = seq } - }() + }) } // Runs the consumer - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { ticker := time.NewTicker(time.Millisecond * 10) recvCount := 0 @@ -143,7 +135,7 @@ func TestSendChanSendSync(t *testing.T) { return } } - }() + }) wg.Wait() cancel() @@ -155,9 +147,7 @@ func BenchmarkSendChanSendAsyncSPSC(b *testing.B) { seq := atomic.NewInt64(0) c := NewSendChan(defaultSendChanCap) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for j := 0; j < b.N; { ok, _ := c.SendAsync("test-topic", []byte("test-value"), func() int64 { return seq.Inc() @@ -167,7 +157,7 @@ func BenchmarkSendChanSendAsyncSPSC(b *testing.B) { } j++ } - }() + }) recvCount := 0 dummyTicker := make(chan time.Time) @@ -196,9 +186,7 @@ func BenchmarkSendChanSendSyncSPSC(b *testing.B) { seq := atomic.NewInt64(0) c := NewSendChan(defaultSendChanCap) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for j := 0; j < b.N; j++ { _, _ = c.SendSync( context.TODO(), @@ -208,7 +196,7 @@ func BenchmarkSendChanSendSyncSPSC(b *testing.B) { return seq.Inc() }) } - }() + }) recvCount := 0 dummyTicker := make(chan time.Time) @@ -235,10 +223,8 @@ func BenchmarkSendChanSendAsyncMPSC8(b *testing.B) { seq := atomic.NewInt64(0) c := NewSendChan(defaultSendChanCap) - for i := 0; i < 8; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range 8 { + wg.Go(func() { for j := 0; j < b.N; { ok, _ := c.SendAsync("test-topic", []byte("test-value"), func() int64 { return seq.Inc() @@ -248,7 +234,7 @@ func BenchmarkSendChanSendAsyncMPSC8(b *testing.B) { } j++ } - }() + }) } recvCount := 0 @@ -277,10 +263,8 @@ func BenchmarkSendChanSendSyncMPSC8(b *testing.B) { c := NewSendChan(defaultSendChanCap) dummyCloseCh := make(chan struct{}) - for i := 0; i < 8; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for range 8 { + wg.Go(func() { for j := 0; j < b.N; j++ { _, _ = c.SendSync( context.TODO(), @@ -290,7 +274,7 @@ func BenchmarkSendChanSendSyncMPSC8(b *testing.B) { return seq.Inc() }) } - }() + }) } recvCount := 0 diff --git a/pkg/p2p/message_router.go b/pkg/p2p/message_router.go index 6178bb73e2..3276a424e0 100644 --- a/pkg/p2p/message_router.go +++ b/pkg/p2p/message_router.go @@ -171,9 +171,7 @@ func (m *messageRouterImpl) GetClient(target NodeID) MessageClient { MessageClient: client, cancelFn: cancel, } - m.wg.Add(1) - go func() { - defer m.wg.Done() + m.wg.Go(func() { defer cancel() err := client.Run(ctx, "tcp", addr, target, m.credentials) if err != nil { @@ -198,7 +196,7 @@ func (m *messageRouterImpl) GetClient(target NodeID) MessageClient { m.mu.Lock() defer m.mu.Unlock() delete(m.clients, target) - }() + }) } m.clients[target] = cliWrapper diff --git a/pkg/p2p/message_router_test.go b/pkg/p2p/message_router_test.go index 355c92c9ff..359b964fcd 100644 --- a/pkg/p2p/message_router_test.go +++ b/pkg/p2p/message_router_test.go @@ -78,22 +78,18 @@ func (s *messageRouterTestSuite) addServer(ctx context.Context, t *testing.T, id s.messageRouter.AddPeer(id, addr) - s.wg.Add(1) - go func() { - defer s.wg.Done() + s.wg.Go(func() { _ = grpcServer.Serve(lis) - }() + }) - s.wg.Add(1) - go func() { - defer s.wg.Done() + s.wg.Go(func() { defer grpcServer.Stop() defer s.messageRouter.RemovePeer(id) err := newServer.Run(ctx, nil) if err != nil { require.Regexp(t, ".*context canceled.*", err.Error()) } - }() + }) } func (s *messageRouterTestSuite) close() { @@ -123,7 +119,7 @@ func TestMessageRouterBasic(t *testing.T) { require.Nilf(t, noClient, "no client should have been created") var lastIndex [3]int64 - mustAddHandler(ctx, t, suite.getServer("server-1"), "test-topic", &testTopicContent{}, func(senderID string, i interface{}) error { + mustAddHandler(ctx, t, suite.getServer("server-1"), "test-topic", &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) @@ -132,7 +128,7 @@ func TestMessageRouterBasic(t *testing.T) { return nil }) - mustAddHandler(ctx, t, suite.getServer("server-2"), "test-topic", &testTopicContent{}, func(senderID string, i interface{}) error { + mustAddHandler(ctx, t, suite.getServer("server-2"), "test-topic", &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) @@ -141,7 +137,7 @@ func TestMessageRouterBasic(t *testing.T) { return nil }) - mustAddHandler(ctx, t, suite.getServer("server-3"), "test-topic", &testTopicContent{}, func(senderID string, i interface{}) error { + mustAddHandler(ctx, t, suite.getServer("server-3"), "test-topic", &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) @@ -151,7 +147,7 @@ func TestMessageRouterBasic(t *testing.T) { }) var lastSeq [3]Seq - for i := 0; i < defaultMessageBatchSizeLarge; i++ { + for i := range defaultMessageBatchSizeLarge { serverIdx := i % 3 serverID := fmt.Sprintf("server-%d", serverIdx+1) Seq, err := suite.messageRouter.GetClient(serverID).SendMessage(ctx, "test-topic", &testTopicContent{int64(i/3) + 1}) @@ -197,7 +193,7 @@ func TestMessageRouterRemovePeer(t *testing.T) { suite.addServer(ctx, t, "server-2") var lastIndex [3]int64 - mustAddHandler(ctx, t, suite.getServer("server-1"), "test-topic", &testTopicContent{}, func(senderID string, i interface{}) error { + mustAddHandler(ctx, t, suite.getServer("server-1"), "test-topic", &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) @@ -206,7 +202,7 @@ func TestMessageRouterRemovePeer(t *testing.T) { return nil }) - mustAddHandler(ctx, t, suite.getServer("server-2"), "test-topic", &testTopicContent{}, func(senderID string, i interface{}) error { + mustAddHandler(ctx, t, suite.getServer("server-2"), "test-topic", &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) @@ -216,11 +212,9 @@ func TestMessageRouterRemovePeer(t *testing.T) { }) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { var lastSeq Seq - for i := 0; i < defaultMessageBatchSizeLarge; i++ { + for i := range defaultMessageBatchSizeLarge { var err error lastSeq, err = suite.messageRouter.GetClient("server-1"). SendMessage(ctx, "test-topic", &testTopicContent{int64(i + 1)}) @@ -233,14 +227,12 @@ func TestMessageRouterRemovePeer(t *testing.T) { } return seq >= lastSeq }, time.Second*10, time.Millisecond*20) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { client := suite.messageRouter.GetClient("server-2") require.NotNil(t, client) - for i := 0; i < defaultMessageBatchSizeSmall; i++ { + for i := range defaultMessageBatchSizeSmall { var err error _, err = client.SendMessage(ctx, "test-topic", &testTopicContent{int64(i + 1)}) require.NoError(t, err) @@ -253,7 +245,7 @@ func TestMessageRouterRemovePeer(t *testing.T) { return err != nil }, time.Millisecond*500, time.Millisecond*50) require.Regexp(t, ".*ErrPeerMessageClientClosed.*", err.Error()) - }() + }) wg.Wait() suite.close() diff --git a/pkg/p2p/mock_cluster.go b/pkg/p2p/mock_cluster.go index 1c9a28c1ae..3aa2fde44e 100644 --- a/pkg/p2p/mock_cluster.go +++ b/pkg/p2p/mock_cluster.go @@ -85,28 +85,22 @@ func newMockNode(t *testing.T, id NodeID) *MockNode { grpcServer := grpc.NewServer() proto.RegisterCDCPeerToPeerServer(grpcServer, ret.Server) - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { lis, err := net.Listen("tcp", addr) require.NoError(t, err) _ = grpcServer.Serve(lis) - }() + }) - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { err := ret.Server.Run(ctx, nil) require.Error(t, err) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) - ret.wg.Add(1) - go func() { - defer ret.wg.Done() + ret.wg.Go(func() { <-ctx.Done() grpcServer.Stop() - }() + }) return ret } @@ -124,7 +118,7 @@ func NewMockCluster(t *testing.T, nodeCount int) *MockCluster { Nodes: make(map[NodeID]*MockNode), } - for i := 0; i < nodeCount; i++ { + for i := range nodeCount { id := fmt.Sprintf("capture-%d", i) ret.Nodes[id] = newMockNode(t, id) } diff --git a/pkg/p2p/mock_grpc_client.go b/pkg/p2p/mock_grpc_client.go index f9121e716d..02d008f293 100644 --- a/pkg/p2p/mock_grpc_client.go +++ b/pkg/p2p/mock_grpc_client.go @@ -30,7 +30,7 @@ type mockSendMessageClient struct { p2p.CDCPeerToPeer_SendMessageClient ctx context.Context - msgCount int32 + msgCount atomic.Int32 replyCh chan *p2p.SendMessageResponse } @@ -46,7 +46,7 @@ func (s *mockSendMessageClient) Send(packet *p2p.MessagePacket) error { defer s.mu.Unlock() args := s.Called(packet) - atomic.AddInt32(&s.msgCount, 1) + s.msgCount.Add(1) return args.Error(0) } diff --git a/pkg/p2p/model.go b/pkg/p2p/model.go index 0de5676421..71c42e17fd 100644 --- a/pkg/p2p/model.go +++ b/pkg/p2p/model.go @@ -37,5 +37,5 @@ type MessageEntry = *proto.MessageEntry // RawMessageEntry is an alias for the protobuf-generated type for a message. type RawMessageEntry struct { topic Topic - value interface{} + value any } diff --git a/pkg/p2p/serializer.go b/pkg/p2p/serializer.go index bf787c6fad..aa43721896 100644 --- a/pkg/p2p/serializer.go +++ b/pkg/p2p/serializer.go @@ -22,14 +22,14 @@ type Serializable interface { Unmarshal(data []byte) error } -func marshalMessage(value interface{}) ([]byte, error) { +func marshalMessage(value any) ([]byte, error) { if value, ok := value.(Serializable); ok { return value.Marshal() } return json.Marshal(value) } -func unmarshalMessage(data []byte, value interface{}) error { +func unmarshalMessage(data []byte, value any) error { if value, ok := value.(Serializable); ok { return value.Unmarshal(data) } diff --git a/pkg/p2p/server.go b/pkg/p2p/server.go index 8c88467669..4261a3d001 100755 --- a/pkg/p2p/server.go +++ b/pkg/p2p/server.go @@ -150,12 +150,12 @@ type MessageServer struct { // taskQueue is used to store internal tasks MessageServer // needs to execute serially. - taskQueue chan interface{} + taskQueue chan any // The WorkerPool instance used to execute message handlers. pool workerpool.WorkerPool - isRunning int32 // atomic + isRunning atomic.Int32 // atomic closeCh chan struct{} config *MessageServerConfig // read only @@ -204,7 +204,7 @@ func NewMessageServer(serverID NodeID, config *MessageServerConfig) *MessageServ peers: make(map[string]*cdcPeer), pendingMessages: make(map[topicSenderPair][]pendingMessageEntry), acks: newAckManager(), - taskQueue: make(chan interface{}, config.MaxPendingTaskCount), + taskQueue: make(chan any, config.MaxPendingTaskCount), pool: workerpool.NewDefaultWorkerPool(config.WorkerPoolSize), closeCh: make(chan struct{}), config: config, @@ -214,9 +214,9 @@ func NewMessageServer(serverID NodeID, config *MessageServerConfig) *MessageServ // Run starts the MessageServer's worker goroutines. // It must be running to provide the gRPC service. func (m *MessageServer) Run(ctx context.Context, localCh <-chan RawMessageEntry) error { - atomic.StoreInt32(&m.isRunning, 1) + m.isRunning.Store(1) defer func() { - atomic.StoreInt32(&m.isRunning, 0) + m.isRunning.Store(0) close(m.closeCh) }() @@ -406,7 +406,7 @@ func (m *MessageServer) ScheduleDeregisterPeerTask(ctx context.Context, peerID s // We pass an object of the desired type, and use `reflect.TypeOf` to extract the type, // and then when we need it, we can use `reflect.New` to allocate a new object of this // type. -type typeInformation = interface{} +type typeInformation = any // SyncAddHandler registers a handler for messages in a given topic and waits for the operation // to complete. @@ -414,7 +414,7 @@ func (m *MessageServer) SyncAddHandler( ctx context.Context, topic string, tpi typeInformation, - fn func(string, interface{}) error, + fn func(string, any) error, ) (<-chan error, error) { doneCh, errCh, err := m.AddHandler(ctx, topic, tpi, fn) if err != nil { @@ -435,7 +435,7 @@ func (m *MessageServer) AddHandler( ctx context.Context, topic string, tpi typeInformation, - fn func(string, interface{}) error, + fn func(string, any) error, ) (chan struct{}, <-chan error, error) { tp := reflect.TypeOf(tpi) @@ -443,7 +443,7 @@ func (m *MessageServer) AddHandler( "topic": topic, }) - poolHandle := m.pool.RegisterEvent(func(ctx context.Context, argsI interface{}) error { + poolHandle := m.pool.RegisterEvent(func(ctx context.Context, argsI any) error { args, ok := argsI.(poolEventArgs) if !ok { // Handle message from local. @@ -637,7 +637,7 @@ func (m *MessageServer) registerPeer( return nil } -func (m *MessageServer) scheduleTask(ctx context.Context, task interface{}) error { +func (m *MessageServer) scheduleTask(ctx context.Context, task any) error { select { case <-ctx.Done(): return errors.Trace(ctx.Err()) @@ -648,7 +648,7 @@ func (m *MessageServer) scheduleTask(ctx context.Context, task interface{}) erro return nil } -func (m *MessageServer) scheduleTaskBlocking(ctx context.Context, task interface{}) error { +func (m *MessageServer) scheduleTaskBlocking(ctx context.Context, task any) error { select { case <-ctx.Done(): return errors.Trace(ctx.Err()) diff --git a/pkg/p2p/server_ack_manager.go b/pkg/p2p/server_ack_manager.go index 54789fefa1..7e49adcd33 100644 --- a/pkg/p2p/server_ack_manager.go +++ b/pkg/p2p/server_ack_manager.go @@ -101,7 +101,7 @@ func (m *ackManager) Range(senderID NodeID, fn func(topic Topic, seq Seq) bool) // RemoveTopic removes a topic for all nodes. // We do not support removing a topic from a specific node. func (m *ackManager) RemoveTopic(topic Topic) { - m.peers.Range(func(key, value interface{}) bool { + m.peers.Range(func(key, value any) bool { ackList := value.(*peerAckList) ackList.mu.Lock() defer ackList.mu.Unlock() diff --git a/pkg/p2p/server_client_integration_test.go b/pkg/p2p/server_client_integration_test.go index d0206461c2..e1ad26735c 100644 --- a/pkg/p2p/server_client_integration_test.go +++ b/pkg/p2p/server_client_integration_test.go @@ -65,11 +65,9 @@ func newServerForIntegrationTesting(t *testing.T, serverID string, configOpts .. p2p.RegisterCDCPeerToPeerServer(grpcServer, server) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { _ = grpcServer.Serve(lis) - }() + }) cancel = func() { grpcServer.Stop() @@ -95,9 +93,7 @@ func runP2PIntegrationTest( defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for { err := server.Run(ctx, nil) if cerror.ErrPeerMessageInjectedServerRestart.Equal(err) { @@ -107,12 +103,12 @@ func runP2PIntegrationTest( require.Regexp(t, ".*context canceled.*", err.Error()) break } - }() + }) - for j := 0; j < numTopics; j++ { + for j := range numTopics { topicName := fmt.Sprintf("test-topic-%d", j) var lastIndex int64 - errCh := mustAddHandler(ctx, t, server, topicName, &testTopicContent{}, func(senderID string, i interface{}) error { + errCh := mustAddHandler(ctx, t, server, topicName, &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) @@ -123,27 +119,23 @@ func runP2PIntegrationTest( return nil }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case <-ctx.Done(): case err := <-errCh: require.NoError(t, err) } - }() + }) } client := NewGrpcMessageClient("test-client-1", clientConfig4Testing) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "tcp", addr, "test-server-1", &security.Credential{}) if err != nil { log.Warn("client returned error", zap.Error(err)) require.Regexp(t, ".*context canceled.*", err.Error()) } - }() + }) var wg1 sync.WaitGroup wg1.Add(numTopics * clientConcurrency) @@ -152,7 +144,7 @@ func runP2PIntegrationTest( go func() { defer wg1.Done() var oldSeq Seq - for i := 0; i < size; i++ { + for i := range size { content := &testTopicContent{Index: int64(i + 1)} seq, err := client.SendMessage(ctx, topicName, content) require.NoError(t, err) @@ -260,46 +252,40 @@ func TestMessageClientBasicNonblocking(t *testing.T) { defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) if err != nil { require.Regexp(t, ".*context canceled.*", err.Error()) } - }() + }) - var lastIndex int64 - errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i interface{}) error { + var lastIndex atomic.Int64 + errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) - swapped := atomic.CompareAndSwapInt64(&lastIndex, content.Index-1, content.Index) + swapped := lastIndex.CompareAndSwap(content.Index-1, content.Index) require.True(t, swapped) return nil }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case <-ctx.Done(): case err := <-errCh: require.NoError(t, err) } - }() + }) client := NewGrpcMessageClient("test-client-1", clientConfig4Testing) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "tcp", addr, "test-server-1", &security.Credential{}) require.Error(t, err) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) var oldSeq Seq - for i := 0; i < defaultMessageBatchSizeSmall; i++ { + for i := range defaultMessageBatchSizeSmall { content := &testTopicContent{Index: int64(i + 1)} var ( seq Seq @@ -337,49 +323,43 @@ func TestMessageBackPressure(t *testing.T) { defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) if err != nil { require.Regexp(t, ".*context canceled.*", err.Error()) } - }() + }) // No-op handler. We are only testing for back-pressure. - errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i interface{}) error { + errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i any) error { return nil }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case <-ctx.Done(): case err := <-errCh: require.NoError(t, err) } - }() + }) client := NewGrpcMessageClient("test-client-1", clientConfig4Testing) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "tcp", addr, "test-server-1", &security.Credential{}) require.Error(t, err) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) _ = failpoint.Enable("github.com/pingcap/tiflow/pkg/p2p/ServerInjectTaskDelay", "sleep(1)") defer func() { _ = failpoint.Disable("github.com/pingcap/tiflow/pkg/p2p/ServerInjectTaskDelay") }() - var lastSeq Seq - for i := 0; i < defaultMessageBatchSizeLarge; i++ { + var lastSeq atomic.Int64 + for range defaultMessageBatchSizeLarge { seq, err := client.SendMessage(ctx, "test-topic-1", &testTopicContent{}) require.NoError(t, err) - atomic.StoreInt64(&lastSeq, seq) + lastSeq.Store(seq) } require.Eventually(t, func() bool { @@ -388,7 +368,7 @@ func TestMessageBackPressure(t *testing.T) { return false } log.Info("checked ack", zap.Int64("ack", latestAck)) - return latestAck == atomic.LoadInt64(&lastSeq) + return latestAck == lastSeq.Load() }, time.Second*10, time.Millisecond*20) cancel() wg.Wait() @@ -405,43 +385,37 @@ func TestTopicCongested(t *testing.T) { defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) if err != nil { require.Regexp(t, ".*context canceled.*", err.Error()) } - }() + }) newClientConfig := *clientConfig4Testing newClientConfig.MaxBatchCount = 1 newClientConfig.RetryRateLimitPerSecond = 100 client := NewGrpcMessageClient("test-client-1", clientConfig4Testing) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := client.Run(ctx, "tcp", addr, "test-server-1", &security.Credential{}) require.Error(t, err) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) - var lastSeq Seq - wg.Add(1) - go func() { - defer wg.Done() + var lastSeq atomic.Int64 + wg.Go(func() { - for i := 0; i < 100; i++ { + for range 100 { seq, err := client.SendMessage(ctx, "test-topic-1", &testTopicContent{}) require.NoError(t, err) - atomic.StoreInt64(&lastSeq, seq) + lastSeq.Store(seq) time.Sleep(10 * time.Millisecond) } - }() + }) // No-op handler. _ = mustAddHandler(ctx, t, server, "test-topic-1", - &testTopicContent{}, func(senderID string, i interface{}) error { + &testTopicContent{}, func(senderID string, i any) error { return nil }) @@ -453,7 +427,7 @@ func TestTopicCongested(t *testing.T) { // No-op handler. _ = mustAddHandler(ctx, t, server, "test-topic-1", - &testTopicContent{}, func(senderID string, i interface{}) error { + &testTopicContent{}, func(senderID string, i any) error { return nil }) diff --git a/pkg/p2p/server_stream_handle_test.go b/pkg/p2p/server_stream_handle_test.go index 1034c5811a..a5221e1365 100644 --- a/pkg/p2p/server_stream_handle_test.go +++ b/pkg/p2p/server_stream_handle_test.go @@ -39,12 +39,10 @@ func TestStreamHandleSend(t *testing.T) { defer cancel() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { msg := <-sendCh require.Equal(t, "test", msg.ErrorMessage) - }() + }) err := h.Send(ctx, proto.SendMessageResponse{ ErrorMessage: "test", @@ -68,13 +66,11 @@ func TestStreamHandleCloseWhileSending(t *testing.T) { defer cancel() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := h.Send(ctx, proto.SendMessageResponse{}) require.Error(t, err) require.Regexp(t, "ErrPeerMessageInternalSenderClosed", err.Error()) - }() + }) time.Sleep(100 * time.Millisecond) h.Close() diff --git a/pkg/p2p/server_test.go b/pkg/p2p/server_test.go index 017991e413..3225dd5e0a 100644 --- a/pkg/p2p/server_test.go +++ b/pkg/p2p/server_test.go @@ -65,11 +65,9 @@ func newServerForTesting(t *testing.T, serverID string) (server *MessageServer, p2p.RegisterCDCPeerToPeerServer(grpcServer, server) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { _ = grpcServer.Serve(lis) - }() + }) cancel = func() { grpcServer.Stop() @@ -93,7 +91,7 @@ func newServerForTesting(t *testing.T, serverID string) (server *MessageServer, return } -func mustAddHandler(ctx context.Context, t *testing.T, server *MessageServer, topic string, tpi interface{}, f func(string, interface{}) error) <-chan error { +func mustAddHandler(ctx context.Context, t *testing.T, server *MessageServer, topic string, tpi any, f func(string, any) error) <-chan error { doneCh, errCh, err := server.AddHandler(ctx, topic, tpi, f) require.NoError(t, err) @@ -123,15 +121,13 @@ func TestServerMultiClientSingleTopic(t *testing.T) { localCh := make(chan RawMessageEntry, defaultMessageBatchSizeMedium) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, localCh) require.Regexp(t, ".*context canceled.*", err) - }() + }) var ackWg sync.WaitGroup - for i := 0; i < defaultMultiClientCount; i++ { + for i := range defaultMultiClientCount { wg.Add(1) ackWg.Add(1) i := i @@ -170,7 +166,7 @@ func TestServerMultiClientSingleTopic(t *testing.T) { } }() - for j := 0; j < defaultMessageBatchSizeMedium; j++ { + for j := range defaultMessageBatchSizeMedium { content := &testTopicContent{Index: int64(j + 1)} bytes, err := json.Marshal(content) require.NoError(t, err) @@ -192,7 +188,7 @@ func TestServerMultiClientSingleTopic(t *testing.T) { time.Sleep(1 * time.Second) lastIndices := sync.Map{} - errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i interface{}) error { + errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i any) error { if strings.Contains(senderID, "server") { require.Equal(t, serverID, senderID) } else { @@ -216,7 +212,7 @@ func TestServerMultiClientSingleTopic(t *testing.T) { ackWg.Add(1) go func() { defer wg.Done() - for j := 0; j < defaultMessageBatchSizeLarge; j++ { + for j := range defaultMessageBatchSizeLarge { content := &testTopicContent{Index: int64(j + 1)} select { case <-ctx.Done(): @@ -249,16 +245,14 @@ func TestServerMultiClientSingleTopic(t *testing.T) { }() }() - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case <-ctx.Done(): case err := <-errCh: require.Error(t, err) require.Regexp(t, ".*ErrWorkerPoolHandleCancelled.*", err.Error()) } - }() + }) ackWg.Wait() @@ -283,36 +277,32 @@ func TestServerDeregisterHandler(t *testing.T) { defer closer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) var ( - lastIndex int64 - removed int32 + lastIndex atomic.Int64 + removed atomic.Int32 ) - errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i interface{}) error { - require.Equal(t, int32(0), atomic.LoadInt32(&removed)) + errCh := mustAddHandler(ctx, t, server, "test-topic-1", &testTopicContent{}, func(senderID string, i any) error { + require.Equal(t, int32(0), removed.Load()) require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) - swapped := atomic.CompareAndSwapInt64(&lastIndex, content.Index-1, content.Index) + swapped := lastIndex.CompareAndSwap(content.Index-1, content.Index) require.True(t, swapped) return nil }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { select { case <-ctx.Done(): case err := <-errCh: require.Regexp(t, ".*ErrWorkerPoolHandleCancelled.*", err.Error()) } - }() + }) client, closeClient := newClient() defer closeClient() @@ -330,9 +320,7 @@ func TestServerDeregisterHandler(t *testing.T) { require.NoError(t, err) removeHandler := func() { - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { doneCh, err := server.RemoveHandler(ctx, "test-topic-1") require.NoError(t, err) select { @@ -340,13 +328,11 @@ func TestServerDeregisterHandler(t *testing.T) { require.FailNow(t, "RemoveHandler timed out") case <-doneCh: } - atomic.StoreInt32(&removed, 1) - }() + removed.Store(1) + }) } - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { defer cancel() defer closer() var lastAck int64 @@ -362,14 +348,14 @@ func TestServerDeregisterHandler(t *testing.T) { if lastAck >= defaultMessageBatchSizeSmall/3 { removeHandler() time.Sleep(time.Millisecond * 500) - require.Equal(t, int32(1), atomic.LoadInt32(&removed)) + require.Equal(t, int32(1), removed.Load()) time.Sleep(time.Millisecond * 500) return } } - }() + }) - for i := 0; i < defaultMessageBatchSizeSmall; i++ { + for i := range defaultMessageBatchSizeSmall { content := &testTopicContent{Index: int64(i + 1)} bytes, err := json.Marshal(content) require.NoError(t, err) @@ -398,12 +384,10 @@ func TestServerClosed(t *testing.T) { cctx, cancelServer := context.WithCancel(ctx) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(cctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) client, closeClient := newClient() defer closeClient() @@ -440,12 +424,10 @@ func TestServerTopicCongestedDueToNoHandler(t *testing.T) { defer closer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) client, closeClient := newClient() defer closeClient() @@ -462,9 +444,7 @@ func TestServerTopicCongestedDueToNoHandler(t *testing.T) { }) require.NoError(t, err) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { for { resp, err := stream.Recv() require.NoError(t, err) @@ -475,9 +455,9 @@ func TestServerTopicCongestedDueToNoHandler(t *testing.T) { cancel() return } - }() + }) - for i := 0; i < defaultMessageBatchSizeMedium; i++ { + for i := range defaultMessageBatchSizeMedium { content := &testTopicContent{Index: int64(i + 1)} bytes, err := json.Marshal(content) require.NoError(t, err) @@ -508,12 +488,10 @@ func TestServerIncomingConnectionStale(t *testing.T) { defer closer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) client, closeClient := newClient() defer closeClient() @@ -574,12 +552,10 @@ func TestServerOldConnectionStale(t *testing.T) { defer closer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) client, closeClient := newClient() defer closeClient() @@ -639,21 +615,19 @@ func TestServerRepeatedMessages(t *testing.T) { defer closer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) - var lastIndex int64 + var lastIndex atomic.Int64 _ = mustAddHandler(ctx, t, server, "test-topic-1", - &testTopicContent{}, func(senderID string, i interface{}) error { + &testTopicContent{}, func(senderID string, i any) error { require.Equal(t, "test-client-1", senderID) require.IsType(t, &testTopicContent{}, i) content := i.(*testTopicContent) - require.Equal(t, content.Index-1, atomic.LoadInt64(&lastIndex)) - atomic.StoreInt64(&lastIndex, content.Index) + require.Equal(t, content.Index-1, lastIndex.Load()) + lastIndex.Store(content.Index) return nil }) @@ -672,9 +646,7 @@ func TestServerRepeatedMessages(t *testing.T) { }) require.NoError(t, err) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { defer cancel() for { resp, err := stream.Recv() @@ -690,9 +662,9 @@ func TestServerRepeatedMessages(t *testing.T) { return } } - }() + }) - for i := 0; i < defaultMessageBatchSizeSmall; i++ { + for i := range defaultMessageBatchSizeSmall { content := &testTopicContent{Index: int64(i + 1)} bytes, err := json.Marshal(content) require.NoError(t, err) @@ -740,41 +712,33 @@ func TestServerExitWhileAddingHandler(t *testing.T) { defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(serverCtx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) waitCh := make(chan struct{}) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.scheduleTask(ctx, taskDebugDelay{ doneCh: waitCh, }) require.NoError(t, err) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { time.Sleep(time.Millisecond * 100) - _, err := server.SyncAddHandler(ctx, "test-topic", &testTopicContent{}, func(s string, i interface{}) error { + _, err := server.SyncAddHandler(ctx, "test-topic", &testTopicContent{}, func(s string, i any) error { return nil }) require.Error(t, err) require.Regexp(t, ".*ErrPeerMessageServerClosed.*", err.Error()) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { time.Sleep(time.Millisecond * 300) cancelServer() - }() + }) wg.Wait() } @@ -790,19 +754,15 @@ func TestServerExitWhileRemovingHandler(t *testing.T) { defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(serverCtx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) waitCh := make(chan struct{}) - wg.Add(1) - go func() { - defer wg.Done() - _, err := server.SyncAddHandler(ctx, "test-topic", &testTopicContent{}, func(s string, i interface{}) error { + wg.Go(func() { + _, err := server.SyncAddHandler(ctx, "test-topic", &testTopicContent{}, func(s string, i any) error { return nil }) require.NoError(t, err) @@ -813,14 +773,12 @@ func TestServerExitWhileRemovingHandler(t *testing.T) { time.Sleep(time.Millisecond * 100) err = server.SyncRemoveHandler(ctx, "test-topic") require.NoError(t, err) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { time.Sleep(time.Millisecond * 500) cancelServer() - }() + }) wg.Wait() } @@ -833,12 +791,10 @@ func TestReceiverIDMismatch(t *testing.T) { defer closer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) client, closeClient := newClient() defer closeClient() @@ -874,16 +830,14 @@ func TestServerDataLossAfterUnregisterHandle(t *testing.T) { defer cancelServer() var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(serverCtx, nil) require.Regexp(t, ".*context canceled.*", err.Error()) - }() + }) - var called int32 - mustAddHandler(ctx, t, server, "blocking-handler", &testTopicContent{}, func(_ string, _ interface{}) error { - if atomic.AddInt32(&called, 1) == 2 { + var called atomic.Int32 + mustAddHandler(ctx, t, server, "blocking-handler", &testTopicContent{}, func(_ string, _ any) error { + if called.Add(1) == 2 { time.Sleep(1 * time.Second) } return nil @@ -926,7 +880,7 @@ func TestServerDataLossAfterUnregisterHandle(t *testing.T) { }) require.NoError(t, err) require.Eventually(t, func() bool { - return atomic.LoadInt32(&called) == 2 + return called.Load() == 2 }, time.Millisecond*500, time.Millisecond*10) err = server.SyncRemoveHandler(ctx, "blocking-handler") @@ -934,7 +888,7 @@ func TestServerDataLossAfterUnregisterHandle(t *testing.T) { require.NoError(t, err) // re-registers the handler - errCh := mustAddHandler(ctx, t, server, "blocking-handler", &testTopicContent{}, func(_ string, msg interface{}) error { + errCh := mustAddHandler(ctx, t, server, "blocking-handler", &testTopicContent{}, func(_ string, msg any) error { require.Fail(t, "should not have been called", "value: %v", msg) return nil }) @@ -975,12 +929,10 @@ func TestServerDeregisterPeer(t *testing.T) { server.config.MaxPendingMessageCountPerTopic = math.MaxInt64 var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx, nil) require.Regexp(t, ".*context canceled.*", err) - }() + }) var sendGroup sync.WaitGroup sendGroup.Add(1) diff --git a/pkg/p2p/server_wrapper_test.go b/pkg/p2p/server_wrapper_test.go index af517ab24f..112f480040 100644 --- a/pkg/p2p/server_wrapper_test.go +++ b/pkg/p2p/server_wrapper_test.go @@ -37,12 +37,12 @@ import ( type mockGrpcService struct { mock.Mock t *testing.T - streamCount int64 + streamCount atomic.Int64 } func (s *mockGrpcService) SendMessage(stream MessageServerStream) error { - atomic.AddInt64(&s.streamCount, 1) - defer atomic.AddInt64(&s.streamCount, -1) + s.streamCount.Add(1) + defer s.streamCount.Add(-1) go func() { for { @@ -75,11 +75,9 @@ func newServerWrapperForTesting(t *testing.T) (server *ServerWrapper, newClient p2p.RegisterCDCPeerToPeerServer(grpcServer, server) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { _ = grpcServer.Serve(lis) - }() + }) cancel = func() { grpcServer.Stop() @@ -138,7 +136,7 @@ func TestServerWrapperBasics(t *testing.T) { time.Sleep(100 * time.Millisecond) innerServer.AssertExpectations(t) - require.Equal(t, int64(1), atomic.LoadInt64(&innerServer.streamCount)) + require.Equal(t, int64(1), innerServer.streamCount.Load()) serverWrapper.Reset(nil) _, err = clientStream.Recv() diff --git a/pkg/retry/retry_test.go b/pkg/retry/retry_test.go index 2080e7cb34..8a36a05807 100644 --- a/pkg/retry/retry_test.go +++ b/pkg/retry/retry_test.go @@ -148,7 +148,7 @@ func TestDoCornerCases(t *testing.T) { require.Equal(t, callCount, 2) var i uint64 - for i = 0; i < 10; i++ { + for i = range 10 { callCount = 0 err = Do(context.Background(), f, WithBackoffBaseDelay(int64(i)), WithBackoffMaxDelay(int64(i)), WithMaxTries(i)) diff --git a/pkg/security/credential.go b/pkg/security/credential.go index ef454bacb6..ea507f411d 100644 --- a/pkg/security/credential.go +++ b/pkg/security/credential.go @@ -54,7 +54,7 @@ func (s Credential) Value() (driver.Value, error) { } // Scan implements the sql.Scanner interface -func (s *Credential) Scan(value interface{}) error { +func (s *Credential) Scan(value any) error { b, ok := value.([]byte) if !ok { return errors.New("type assertion to []byte failed") diff --git a/pkg/security/sasl_test.go b/pkg/security/sasl_test.go index ad8546965b..71f3c90754 100644 --- a/pkg/security/sasl_test.go +++ b/pkg/security/sasl_test.go @@ -76,7 +76,6 @@ func TestSASLMechanismFromString(t *testing.T) { }, } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { t.Parallel() mechanism, err := SASLMechanismFromString(test.s) @@ -129,7 +128,6 @@ func TestAuthTypeFromString(t *testing.T) { } for _, test := range tests { - test := test t.Run(test.name, func(t *testing.T) { t.Parallel() diff --git a/pkg/tcpserver/tcp_server_test.go b/pkg/tcpserver/tcp_server_test.go index 5d53a13591..220238e7f5 100644 --- a/pkg/tcpserver/tcp_server_test.go +++ b/pkg/tcpserver/tcp_server_test.go @@ -51,20 +51,16 @@ func TestTCPServerInsecureHTTP1(t *testing.T) { var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx) require.Error(t, err) require.Regexp(t, ".*ErrTCPServerClosed.*", err.Error()) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { testWithHTTPWorkload(ctx, t, server, addr, &security.Credential{}) cancel() - }() + }) wg.Wait() } @@ -88,20 +84,16 @@ func TestTCPServerTLSHTTP1(t *testing.T) { var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx) require.Error(t, err) require.Regexp(t, ".*ErrTCPServerClosed.*", err.Error()) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { defer cancel() testWithHTTPWorkload(ctx, t, server, addr, makeCredential4Testing(t)) - }() + }) wg.Wait() } @@ -124,20 +116,16 @@ func TestTCPServerInsecureGrpc(t *testing.T) { var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx) require.Error(t, err) require.Regexp(t, ".*ErrTCPServerClosed.*", err.Error()) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { testWithGrpcWorkload(ctx, t, server, addr, &security.Credential{}) cancel() - }() + }) wg.Wait() } @@ -161,20 +149,16 @@ func TestTCPServerTLSGrpc(t *testing.T) { var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx) require.Error(t, err) require.Regexp(t, ".*ErrTCPServerClosed.*", err.Error()) - }() + }) - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { testWithGrpcWorkload(ctx, t, server, addr, makeCredential4Testing(t)) cancel() - }() + }) wg.Wait() } @@ -236,9 +220,7 @@ func testWithHTTPWorkload(_ context.Context, t *testing.T, server TCPServer, add var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := httpServer.Serve(server.HTTP1Listener()) if err != nil && err != http.ErrServerClosed { require.FailNow(t, @@ -246,7 +228,7 @@ func testWithHTTPWorkload(_ context.Context, t *testing.T, server TCPServer, add "%d", err.Error()) } - }() + }) scheme := "http" if credentials.IsTLSEnabled() { @@ -281,12 +263,10 @@ func testWithGrpcWorkload(ctx context.Context, t *testing.T, server TCPServer, a var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := grpcServer.Serve(server.GrpcListener()) require.NoError(t, err) - }() + }) var conn *grpc.ClientConn if credentials.IsTLSEnabled() { @@ -305,7 +285,7 @@ func testWithGrpcWorkload(ctx context.Context, t *testing.T, server TCPServer, a client := grpcTestingProto.NewTestServiceClient(conn) - for i := 0; i < 5; i++ { + for i := range 5 { result, err := client.Ping(ctx, &grpcTestingProto.PingRequest{ Value: fmt.Sprintf("%d", i), }) @@ -313,15 +293,13 @@ func testWithGrpcWorkload(ctx context.Context, t *testing.T, server TCPServer, a require.Equal(t, fmt.Sprintf("%d", i), result.Value) } - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { defer grpcServer.GracefulStop() stream, err := client.PingStream(ctx) require.NoError(t, err) - for i := 0; i < 10; i++ { + for i := range 10 { err := stream.Send(&grpcTestingProto.PingRequest{ Value: fmt.Sprintf("%d", i), }) @@ -331,7 +309,7 @@ func testWithGrpcWorkload(ctx context.Context, t *testing.T, server TCPServer, a require.NoError(t, err) require.Equal(t, fmt.Sprintf("%d", i), received.Value) } - }() + }) wg.Wait() } @@ -348,13 +326,11 @@ func TestTcpServerClose(t *testing.T) { require.NoError(t, err) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := server.Run(ctx) require.Error(t, err) require.Regexp(t, ".*ErrTCPServerClosed.*", err.Error()) - }() + }) httpServer := &http.Server{} http.HandleFunc("/", func(writer http.ResponseWriter, _ *http.Request) { @@ -366,13 +342,11 @@ func TestTcpServerClose(t *testing.T) { http.DefaultServeMux = http.NewServeMux() }() - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := httpServer.Serve(server.HTTP1Listener()) require.Error(t, err) require.Regexp(t, ".*mux: server closed.*", err.Error()) - }() + }) cli, err := httputil.NewClient(&security.Credential{}) require.NoError(t, err) @@ -386,7 +360,7 @@ func TestTcpServerClose(t *testing.T) { require.Equal(t, 200, resp.StatusCode) // Close should be idempotent. - for i := 0; i < 3; i++ { + for range 3 { err := server.Close() require.NoError(t, err) } diff --git a/pkg/util/seahash/seahash.go b/pkg/util/seahash/seahash.go index eb6a1a953a..2611221d9d 100644 --- a/pkg/util/seahash/seahash.go +++ b/pkg/util/seahash/seahash.go @@ -8,6 +8,7 @@ package seahash // import "blainsmith.com/go/seahash" import ( "encoding/binary" + "slices" ) // Size of a SeaHash checksum in bytes. @@ -151,9 +152,9 @@ func readInt(b []uint8) uint64 { } var x uint64 - for i := len(b) - 1; i >= 0; i-- { + for _, v := range slices.Backward(b) { x <<= 8 - x |= uint64(b[i]) + x |= uint64(v) } return x } diff --git a/pkg/util/seahash/seahash_test.go b/pkg/util/seahash/seahash_test.go index f4c6a78dfd..47acd460d2 100644 --- a/pkg/util/seahash/seahash_test.go +++ b/pkg/util/seahash/seahash_test.go @@ -33,7 +33,7 @@ func ExampleSum64() { func TestRandom(t *testing.T) { expected := "d30e85ff891306b8" str := []byte("abcdegfhijklmnabcdegfhijklmnabcdegfhijklmn") - for i := 0; i < 1000; i++ { + for i := range 1000 { r := rand.NewSource(int64(i)) s := str h := New() diff --git a/pkg/uuid/uuid_test.go b/pkg/uuid/uuid_test.go index 2cb4672b2d..dd1e5057f3 100644 --- a/pkg/uuid/uuid_test.go +++ b/pkg/uuid/uuid_test.go @@ -47,7 +47,7 @@ func TestConstGenerator(t *testing.T) { uid := "const-uuid" gen := NewConstGenerator(uid) - for i := 0; i < 3; i++ { + for range 3 { require.Equal(t, uid, gen.NewString()) } } diff --git a/pkg/workerpool/async_pool_impl.go b/pkg/workerpool/async_pool_impl.go index 87c027e56b..b7ab7cd938 100644 --- a/pkg/workerpool/async_pool_impl.go +++ b/pkg/workerpool/async_pool_impl.go @@ -31,8 +31,8 @@ const ( type defaultAsyncPoolImpl struct { workers []*asyncWorker - nextWorkerID int32 - isRunning int32 + nextWorkerID atomic.Int32 + isRunning atomic.Int32 runningLock sync.RWMutex } @@ -68,17 +68,17 @@ func (p *defaultAsyncPoolImpl) doGo(ctx context.Context, f func()) error { p.runningLock.RLock() defer p.runningLock.RUnlock() - if atomic.LoadInt32(&p.isRunning) == 0 { + if p.isRunning.Load() == 0 { return cerrors.ErrAsyncPoolExited.GenWithStackByArgs() } task := &asyncTask{f: f} - worker := p.workers[int(atomic.AddInt32(&p.nextWorkerID, 1))%len(p.workers)] + worker := p.workers[int(p.nextWorkerID.Add(1))%len(p.workers)] worker.chLock.RLock() defer worker.chLock.RUnlock() - if atomic.LoadInt32(&worker.isClosed) == 1 { + if worker.isClosed.Load() == 1 { return cerrors.ErrAsyncPoolExited.GenWithStackByArgs() } @@ -96,12 +96,12 @@ func (p *defaultAsyncPoolImpl) Run(ctx context.Context) error { errg := errgroup.Group{} p.runningLock.Lock() - atomic.StoreInt32(&p.isRunning, 1) + p.isRunning.Store(1) p.runningLock.Unlock() defer func() { p.runningLock.Lock() - atomic.StoreInt32(&p.isRunning, 0) + p.isRunning.Store(0) p.runningLock.Unlock() }() @@ -149,7 +149,7 @@ type asyncTask struct { type asyncWorker struct { inputCh chan *asyncTask - isClosed int32 + isClosed atomic.Int32 chLock sync.RWMutex } @@ -168,7 +168,7 @@ func (w *asyncWorker) run() error { } func (w *asyncWorker) close() { - if atomic.SwapInt32(&w.isClosed, 1) == 1 { + if w.isClosed.Swap(1) == 1 { return } diff --git a/pkg/workerpool/async_pool_test.go b/pkg/workerpool/async_pool_test.go index 68ca2c015d..c4c2ce6dd3 100644 --- a/pkg/workerpool/async_pool_test.go +++ b/pkg/workerpool/async_pool_test.go @@ -40,7 +40,7 @@ func TestBasic(t *testing.T) { var sum int32 var wg sync.WaitGroup - for i := 0; i < 100; i++ { + for i := range 100 { wg.Add(1) finalI := i err := pool.Go(ctx, func() { @@ -70,7 +70,7 @@ func TestEventuallyRun(t *testing.T) { pool := newDefaultAsyncPoolImpl(4) errg.Go(func() error { defer cancelLoop() - for i := 0; i < 10; i++ { + for range 10 { log.Info("running pool") err := runForDuration(ctx, time.Millisecond*500, func(ctx context.Context) error { return pool.Run(ctx) diff --git a/pkg/workerpool/pool.go b/pkg/workerpool/pool.go index 8558c2c70a..3ba8c63d7e 100644 --- a/pkg/workerpool/pool.go +++ b/pkg/workerpool/pool.go @@ -24,7 +24,7 @@ type WorkerPool interface { // RegisterEvent returns a handle that can be used to trigger the execution of `f`. // `f` will be called with a context that is a child of the context with which Run is called. // TODO more reasonable usage of contexts, potentially involving context merging. - RegisterEvent(f func(ctx context.Context, event interface{}) error) EventHandle + RegisterEvent(f func(ctx context.Context, event any) error) EventHandle // Run runs the WorkerPool. // Internally several Goroutines are spawned. @@ -39,10 +39,10 @@ type EventHandle interface { // Note: events are always processed in the order they are added. // Unregistering the EventHandle MAY CAUSE EVENT LOSSES. But for an event lost, any event after it is guaranteed to be lost too. // Cancelling `ctx` here will cancel the on-going or next execution of the event. - AddEvent(ctx context.Context, event interface{}) error + AddEvent(ctx context.Context, event any) error // AddEvents is like AddEvent but retrieves a slice instead of an object. - AddEvents(ctx context.Context, events []interface{}) error + AddEvents(ctx context.Context, events []any) error // SetTimer is used to provide a function that is periodic called, as long as the EventHandle has not been unregistered. // The current implementation uses as the base clock source a ticker whose interval is the const workerPoolDefaultClockSourceInterval. diff --git a/pkg/workerpool/pool_impl.go b/pkg/workerpool/pool_impl.go index 0a10addebb..ae236c46f9 100644 --- a/pkg/workerpool/pool_impl.go +++ b/pkg/workerpool/pool_impl.go @@ -39,7 +39,7 @@ type defaultPoolImpl struct { // do not resize this slice after creating the pool workers []*worker // used to generate handler IDs, must be accessed atomically - nextHandlerID int64 + nextHandlerID atomic.Int64 } // NewDefaultWorkerPool creates a new WorkerPool that uses the default implementation @@ -49,7 +49,7 @@ func NewDefaultWorkerPool(numWorkers int) WorkerPool { func newDefaultPoolImpl(hasher Hasher, numWorkers int) *defaultPoolImpl { workers := make([]*worker, numWorkers) - for i := 0; i < numWorkers; i++ { + for i := range numWorkers { workers[i] = newWorker() } return &defaultPoolImpl{ @@ -75,11 +75,11 @@ func (p *defaultPoolImpl) Run(ctx context.Context) error { return errg.Wait() } -func (p *defaultPoolImpl) RegisterEvent(f func(ctx context.Context, event interface{}) error) EventHandle { +func (p *defaultPoolImpl) RegisterEvent(f func(ctx context.Context, event any) error) EventHandle { handler := &defaultEventHandle{ f: f, errCh: make(chan error, 1), - id: atomic.AddInt64(&p.nextHandlerID, 1) - 1, + id: p.nextHandlerID.Add(1) - 1, } workerID := p.hasher.Hash(handler) % int64(len(p.workers)) @@ -99,7 +99,7 @@ const ( type defaultEventHandle struct { // the function to be run each time the event is triggered - f func(ctx context.Context, event interface{}) error + f func(ctx context.Context, event any) error // must be accessed atomically status handleStatus // channel for the error returned by f @@ -112,7 +112,7 @@ type defaultEventHandle struct { id int64 // whether there is a valid timer handler, must be accessed atomically - hasTimer int32 + hasTimer atomic.Int32 // the time when timer was triggered the last time lastTimer time.Time // minimum interval between two timer calls @@ -121,12 +121,12 @@ type defaultEventHandle struct { timerHandler func(ctx context.Context) error // whether this is a valid errorHandler, must be accessed atomically - hasErrorHandler int32 + hasErrorHandler atomic.Int32 // the error handler, called when the handle meets an error (which is returned by f) errorHandler func(err error) } -func (h *defaultEventHandle) AddEvent(ctx context.Context, event interface{}) error { +func (h *defaultEventHandle) AddEvent(ctx context.Context, event any) error { status := atomic.LoadInt32(&h.status) if status != handleRunning { return cerrors.ErrWorkerPoolHandleCancelled.GenWithStackByArgs() @@ -149,7 +149,7 @@ func (h *defaultEventHandle) AddEvent(ctx context.Context, event interface{}) er return nil } -func (h *defaultEventHandle) AddEvents(ctx context.Context, events []interface{}) error { +func (h *defaultEventHandle) AddEvents(ctx context.Context, events []any) error { status := atomic.LoadInt32(&h.status) if status != handleRunning { return cerrors.ErrWorkerPoolHandleCancelled.GenWithStackByArgs() @@ -180,7 +180,7 @@ func (h *defaultEventHandle) AddEvents(ctx context.Context, events []interface{} func (h *defaultEventHandle) SetTimer(ctx context.Context, interval time.Duration, f func(ctx context.Context) error) EventHandle { // mark the timer handler function as invalid - atomic.StoreInt32(&h.hasTimer, 0) + h.hasTimer.Store(0) // wait for `hasTimer` to take effect, otherwise we might have a data race, if there was a previous handler. h.worker.synchronize() @@ -189,7 +189,7 @@ func (h *defaultEventHandle) SetTimer(ctx context.Context, interval time.Duratio return f(ctx) } // mark the timer handler function as valid - atomic.StoreInt32(&h.hasTimer, 1) + h.hasTimer.Store(1) return h } @@ -257,7 +257,7 @@ func (h *defaultEventHandle) GracefulUnregister(ctx context.Context, timeout tim func (h *defaultEventHandle) doCancel(err error) { h.worker.removeHandle(h) - if atomic.LoadInt32(&h.hasErrorHandler) == 1 { + if h.hasErrorHandler.Load() == 1 { h.errorHandler(err) } @@ -270,10 +270,10 @@ func (h *defaultEventHandle) ErrCh() <-chan error { } func (h *defaultEventHandle) OnExit(f func(err error)) EventHandle { - atomic.StoreInt32(&h.hasErrorHandler, 0) + h.hasErrorHandler.Store(0) h.worker.synchronize() h.errorHandler = f - atomic.StoreInt32(&h.hasErrorHandler, 1) + h.hasErrorHandler.Store(1) return h } @@ -295,7 +295,7 @@ func (h *defaultEventHandle) durationSinceLastTimer() time.Duration { } func (h *defaultEventHandle) doTimer(ctx context.Context) error { - if atomic.LoadInt32(&h.hasTimer) == 0 { + if h.hasTimer.Load() == 0 { return nil } diff --git a/pkg/workerpool/pool_test.go b/pkg/workerpool/pool_test.go index 5a0480dd15..f53dd780b6 100644 --- a/pkg/workerpool/pool_test.go +++ b/pkg/workerpool/pool_test.go @@ -39,7 +39,7 @@ func TestTaskError(t *testing.T) { return pool.Run(ctx) }) - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { if event.(int) == 3 { return errors.New("test error") } @@ -49,16 +49,14 @@ func TestTaskError(t *testing.T) { }) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() - for i := 0; i < 10; i++ { + wg.Go(func() { + for i := range 10 { err := handle.AddEvent(ctx, i) if err != nil { require.Regexp(t, ".*ErrWorkerPoolHandleCancelled.*", err) } } - }() + }) select { case <-ctx.Done(): @@ -86,7 +84,7 @@ func TestTimerError(t *testing.T) { }) counter := 0 - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { return nil }).SetTimer(ctx, time.Millisecond*200, func(ctx context.Context) error { if counter == 3 { @@ -117,7 +115,7 @@ func TestMultiError(t *testing.T) { return pool.Run(ctx) }) - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { if event.(int) >= 3 { return errors.New("test error") } @@ -125,16 +123,14 @@ func TestMultiError(t *testing.T) { }) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() - for i := 0; i < 10; i++ { + wg.Go(func() { + for i := range 10 { err := handle.AddEvent(ctx, i) if err != nil { require.Regexp(t, ".*ErrWorkerPoolHandleCancelled.*", err) } } - }() + }) select { case <-ctx.Done(): @@ -161,9 +157,9 @@ func TestCancelHandle(t *testing.T) { return pool.Run(ctx) }) - var num int32 - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { - atomic.StoreInt32(&num, int32(event.(int))) + var num atomic.Int32 + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { + num.Store(int32(event.(int))) return nil }) @@ -191,7 +187,7 @@ func TestCancelHandle(t *testing.T) { require.FailNow(t, "fail") default: } - if atomic.LoadInt32(&num) > 5000 { + if num.Load() > 5000 { break } } @@ -206,9 +202,9 @@ func TestCancelHandle(t *testing.T) { handle.Unregister() // Unregistering many times does not matter handle.Unregister() - lastNum := atomic.LoadInt32(&num) + lastNum := num.Load() for i := 0; i <= 1000; i++ { - require.Equal(t, atomic.LoadInt32(&num), lastNum) + require.Equal(t, num.Load(), lastNum) } time.Sleep(1 * time.Second) @@ -234,7 +230,7 @@ func TestCancelTimer(t *testing.T) { _ = failpoint.Disable("github.com/pingcap/tiflow/pkg/workerpool/unregisterDelayPoint") }() - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { return nil }).SetTimer(ctx, 200*time.Millisecond, func(ctx context.Context) error { return nil @@ -270,7 +266,7 @@ func TestErrorAndCancelRace(t *testing.T) { }) var racedVar int - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { return errors.New("fake") }).OnExit(func(err error) { time.Sleep(100 * time.Millisecond) @@ -301,7 +297,7 @@ func TestTimer(t *testing.T) { time.Sleep(200 * time.Millisecond) - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { if event.(int) == 3 { return errors.New("test error") } @@ -343,10 +339,10 @@ func TestBasics(t *testing.T) { var wg sync.WaitGroup wg.Add(16) - for i := 0; i < 16; i++ { + for i := range 16 { finalI := i resultCh := make(chan int, 128) - handler := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handler := pool.RegisterEvent(func(ctx context.Context, event any) error { select { case <-ctx.Done(): return ctx.Err() @@ -357,7 +353,7 @@ func TestBasics(t *testing.T) { }) errg.Go(func() error { - for j := 0; j < 256; j++ { + for j := range 256 { err := handler.AddEvent(ctx, j) if err != nil { return errors.Trace(err) @@ -396,8 +392,7 @@ func TestBasics(t *testing.T) { // TestCancelByAddEventContext makes sure that the event handle can be cancelled by the context used // to call `AddEvent`. func TestCancelByAddEventContext(t *testing.T) { - poolCtx, poolCancel := context.WithCancel(context.Background()) - defer poolCancel() + poolCtx := t.Context() pool := newDefaultPoolImpl(&defaultHasher{}, 4) go func() { err := pool.Run(poolCtx) @@ -408,14 +403,14 @@ func TestCancelByAddEventContext(t *testing.T) { defer cancel() errg, ctx := errgroup.WithContext(ctx) - for i := 0; i < 8; i++ { - handler := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + for range 8 { + handler := pool.RegisterEvent(func(ctx context.Context, event any) error { <-ctx.Done() return ctx.Err() }) errg.Go(func() error { - for j := 0; j < 64; j++ { + for j := range 64 { err := handler.AddEvent(ctx, j) if err != nil { return nil @@ -441,8 +436,7 @@ func TestCancelByAddEventContext(t *testing.T) { } func TestGracefulUnregister(t *testing.T) { - poolCtx, poolCancel := context.WithCancel(context.Background()) - defer poolCancel() + poolCtx := t.Context() pool := newDefaultPoolImpl(&defaultHasher{}, 4) go func() { err := pool.Run(poolCtx) @@ -454,8 +448,8 @@ func TestGracefulUnregister(t *testing.T) { waitCh := make(chan struct{}) - var lastEventIdx int64 - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + var lastEventIdx atomic.Int64 + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { select { case <-ctx.Done(): return errors.Trace(ctx.Err()) @@ -463,15 +457,13 @@ func TestGracefulUnregister(t *testing.T) { } idx := event.(int64) - old := atomic.SwapInt64(&lastEventIdx, idx) + old := lastEventIdx.Swap(idx) require.Equal(t, old+1, idx) return nil }) var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { var maxEventIdx int64 for i := int64(0); ; i++ { err := handle.AddEvent(ctx, i+1) @@ -484,9 +476,9 @@ func TestGracefulUnregister(t *testing.T) { } require.Eventually(t, func() (success bool) { - return atomic.LoadInt64(&lastEventIdx) == maxEventIdx + return lastEventIdx.Load() == maxEventIdx }, time.Millisecond*500, time.Millisecond*10) - }() + }) time.Sleep(time.Millisecond * 200) go func() { @@ -504,8 +496,7 @@ func TestGracefulUnregister(t *testing.T) { } func TestGracefulUnregisterTimeout(t *testing.T) { - poolCtx, poolCancel := context.WithCancel(context.Background()) - defer poolCancel() + poolCtx := t.Context() pool := newDefaultPoolImpl(&defaultHasher{}, 4) go func() { err := pool.Run(poolCtx) @@ -517,7 +508,7 @@ func TestGracefulUnregisterTimeout(t *testing.T) { waitCh := make(chan struct{}) - handle := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handle := pool.RegisterEvent(func(ctx context.Context, event any) error { select { case <-waitCh: return nil @@ -573,14 +564,13 @@ func TestSynchronizeLog(t *testing.T) { // Benchmark workerpool with ping-pong workflow. // go test -benchmem -run='^$' -bench '^(BenchmarkWorkerpool)$' github.com/pingcap/tiflow/pkg/workerpool func BenchmarkWorkerpool(b *testing.B) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() + ctx := b.Context() pool := newDefaultPoolImpl(&defaultHasher{}, 4) go func() { _ = pool.Run(ctx) }() ch := make(chan int) - handler := pool.RegisterEvent(func(ctx context.Context, event interface{}) error { + handler := pool.RegisterEvent(func(ctx context.Context, event any) error { ch <- event.(int) return nil }) diff --git a/tests/integration_tests/bank/case.go b/tests/integration_tests/bank/case.go index b13e391510..deeccf4e08 100644 --- a/tests/integration_tests/bank/case.go +++ b/tests/integration_tests/bank/case.go @@ -138,7 +138,7 @@ func (s *sequenceTest) prepare(ctx context.Context, db *sql.DB, accounts, tableI )`, tableID) batchInsertSQLF := func(batchSize, offset int) string { args := make([]string, batchSize) - for j := 0; j < batchSize; j++ { + for j := range batchSize { args[j] = fmt.Sprintf("(%d, 0, 0, 0)", offset+j) } return fmt.Sprintf("INSERT IGNORE INTO accounts_seq%d (id, counter, sequence, startts) VALUES %s", tableID, strings.Join(args, ",")) @@ -254,7 +254,7 @@ func (s *bankTest) prepare(ctx context.Context, db *sql.DB, accounts, tableID, c )`, tableID) batchInsertSQLF := func(batchSize, offset int) string { args := make([]string, batchSize) - for j := 0; j < batchSize; j++ { + for j := range batchSize { args[j] = fmt.Sprintf("(%d, %d, 0)", offset+j, initBalance) } return fmt.Sprintf("INSERT IGNORE INTO accounts%d (id, balance, startts) VALUES %s", tableID, strings.Join(args, ",")) @@ -345,7 +345,7 @@ func prepareImpl( g := new(errgroup.Group) ch := make(chan int, jobCount) - for i := 0; i < concurrency; i++ { + for range concurrency { g.Go(func() error { for { startIndex, ok := <-ch @@ -468,7 +468,7 @@ func run( tests := []testcase{&sequenceTest{}, &bankTest{}} if cleanupOnly { - for tableID := 0; tableID < tables; tableID++ { + for tableID := range tables { for i := range tests { tests[i].cleanup(ctx, upstreamDB, accounts, tableID, true) tests[i].cleanup(ctx, downstreamDB, accounts, tableID, true) @@ -484,7 +484,7 @@ func run( // prepare data for upstream db. for _, test := range tests { - for tableID := 0; tableID < tables; tableID++ { + for tableID := range tables { if err := test.prepare(ctx, upstreamDB, accounts, tableID, concurrency); err != nil { log.Panic("prepare failed", zap.Error(err)) } @@ -510,7 +510,7 @@ func run( valid, tried int64 = 0, 0 ) - for id := 0; id < tables; id++ { + for id := range tables { tableID := id // Workload g.Go(func() error { diff --git a/tests/integration_tests/ddl_wait/test.go b/tests/integration_tests/ddl_wait/test.go index 204e385a03..247e704b3d 100644 --- a/tests/integration_tests/ddl_wait/test.go +++ b/tests/integration_tests/ddl_wait/test.go @@ -72,11 +72,11 @@ func run(host string, port string) { } var wg sync.WaitGroup - for k := 0; k < concurrency; k++ { + for k := range concurrency { wg.Add(1) go func(k int) { defer wg.Done() - for i := 0; i < num; i++ { + for i := range num { val := k*num + i _, err = db.Exec(insertDML, val, val) if err != nil { diff --git a/tests/integration_tests/ddl_with_exists/test.go b/tests/integration_tests/ddl_with_exists/test.go index e7c018e49d..68c288ed12 100644 --- a/tests/integration_tests/ddl_with_exists/test.go +++ b/tests/integration_tests/ddl_with_exists/test.go @@ -54,7 +54,7 @@ func main() { db.SetMaxOpenConns(concurrency) start := time.Now() - for i := 0; i < maxTableCnt; i++ { + for i := range maxTableCnt { _, err := db.Exec(fmt.Sprintf(createTable, i)) if err != nil { log.Fatal("create table failed:", i, ", err: ", err) @@ -63,12 +63,10 @@ func main() { log.Println("create table cost:", time.Since(start).Seconds(), "s") var wg sync.WaitGroup - for i := 0; i < concurrency; i++ { - wg.Add(1) - go func() { - defer wg.Done() + for i := range concurrency { + wg.Go(func() { log.Println("worker start:", i) - for j := 0; j < 20; j++ { + for range 20 { idx := rand.Intn(maxTableCnt) ddl := fmt.Sprintf(createTable, idx) switch rand.Intn(5) { @@ -88,7 +86,7 @@ func main() { } } log.Println("worker exit:", i) - }() + }) } wg.Wait() } diff --git a/tests/integration_tests/http_proxies/run-proxy.go b/tests/integration_tests/http_proxies/run-proxy.go index b7d244426f..e323efe912 100644 --- a/tests/integration_tests/http_proxies/run-proxy.go +++ b/tests/integration_tests/http_proxies/run-proxy.go @@ -48,7 +48,7 @@ func main() { fmt.Println("proxy started") } -func intercept(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error { +func intercept(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error { fmt.Println(info.FullMethod) err := handler(srv, ss) if err != nil { diff --git a/tests/mq_protocol_tests/cases/case_alter.go b/tests/mq_protocol_tests/cases/case_alter.go index 5cb2b03854..fa58966e49 100644 --- a/tests/mq_protocol_tests/cases/case_alter.go +++ b/tests/mq_protocol_tests/cases/case_alter.go @@ -45,7 +45,7 @@ func (c *AlterCase) Run(ctx *framework.TaskContext) error { return err } - for i := 0; i < 20; i++ { + for i := range 20 { _, err := ctx.Upstream.ExecContext(ctx.Ctx, fmt.Sprintf("alter table test add column (value%d int)", i)) if err != nil { return err @@ -53,8 +53,8 @@ func (c *AlterCase) Run(ctx *framework.TaskContext) error { table := ctx.SQLHelper().GetTable("test") reqs := make([]framework.Awaitable, 0) - for j := 0; j < 1000; j++ { - rowData := make(map[string]interface{}, i+1) + for j := range 1000 { + rowData := make(map[string]any, i+1) rowData["id"] = i*1000 + j for k := 0; k <= i; k++ { rowData[fmt.Sprintf("value%d", k)] = rand.Int31() diff --git a/tests/mq_protocol_tests/cases/case_composite_pkey.go b/tests/mq_protocol_tests/cases/case_composite_pkey.go index 8c49f39d23..45594c0bc2 100644 --- a/tests/mq_protocol_tests/cases/case_composite_pkey.go +++ b/tests/mq_protocol_tests/cases/case_composite_pkey.go @@ -45,7 +45,7 @@ func (s *CompositePKeyCase) Run(ctx *framework.TaskContext) error { // Get a handle of an existing table table := ctx.SQLHelper().GetTable("test") // Create an SQL request, send it to the upstream, wait for completion and check the correctness of replication - err = table.Insert(map[string]interface{}{ + err = table.Insert(map[string]any{ "id1": 0, "id2": 1, "value": 0, @@ -54,7 +54,7 @@ func (s *CompositePKeyCase) Run(ctx *framework.TaskContext) error { return errors.AddStack(err) } - err = table.Upsert(map[string]interface{}{ + err = table.Upsert(map[string]any{ "id1": 0, "id2": 1, "value": 1, @@ -63,7 +63,7 @@ func (s *CompositePKeyCase) Run(ctx *framework.TaskContext) error { return err } - err = table.Delete(map[string]interface{}{ + err = table.Delete(map[string]any{ "id1": 0, "id2": 1, }).Send().Wait().Check() diff --git a/tests/mq_protocol_tests/cases/case_date_time.go b/tests/mq_protocol_tests/cases/case_date_time.go index 65c23c1b3c..b0bbfa7143 100644 --- a/tests/mq_protocol_tests/cases/case_date_time.go +++ b/tests/mq_protocol_tests/cases/case_date_time.go @@ -80,7 +80,7 @@ func (s *DateTimeCase) Run(ctx *framework.TaskContext) error { // Zero value case zeroValue := time.Unix(0, 0) - data := map[string]interface{}{ + data := map[string]any{ "id": 0, "t_date": zeroValue, "t_datetime": zeroValue, diff --git a/tests/mq_protocol_tests/cases/case_delete.go b/tests/mq_protocol_tests/cases/case_delete.go index 3a0e6702a1..5447c11ed0 100644 --- a/tests/mq_protocol_tests/cases/case_delete.go +++ b/tests/mq_protocol_tests/cases/case_delete.go @@ -49,9 +49,9 @@ func (c *DeleteCase) Run(ctx *framework.TaskContext) error { // To wait on a batch of SQL requests, create a slice of Awaitables reqs := make([]framework.Awaitable, 0) - for i := 0; i < 1000; i++ { + for i := range 1000 { // Only send, do not wait - req := table.Insert(map[string]interface{}{ + req := table.Insert(map[string]any{ "id": i, "value": i, }).Send() @@ -64,8 +64,8 @@ func (c *DeleteCase) Run(ctx *framework.TaskContext) error { } deletes := make([]framework.Awaitable, 0, 1000) - for i := 0; i < 1000; i++ { - req := table.Delete(map[string]interface{}{ + for i := range 1000 { + req := table.Delete(map[string]any{ "id": i, }).Send() deletes = append(deletes, req) diff --git a/tests/mq_protocol_tests/cases/case_handle_key.go b/tests/mq_protocol_tests/cases/case_handle_key.go index 50f50a13e0..a2679823df 100644 --- a/tests/mq_protocol_tests/cases/case_handle_key.go +++ b/tests/mq_protocol_tests/cases/case_handle_key.go @@ -45,7 +45,7 @@ func (s *HandleKeyCase) Run(ctx *framework.TaskContext) error { // Get a handle of an existing table table := ctx.SQLHelper().GetTable("test") // Create an SQL request, send it to the upstream, wait for completion and check the correctness of replication - err = table.Insert(map[string]interface{}{ + err = table.Insert(map[string]any{ "id": 0, "value": 0, }).Send().Wait().Check() @@ -53,7 +53,7 @@ func (s *HandleKeyCase) Run(ctx *framework.TaskContext) error { return errors.AddStack(err) } - err = table.Upsert(map[string]interface{}{ + err = table.Upsert(map[string]any{ "id": 0, "value": 1, }).Send().Wait().Check() @@ -61,7 +61,7 @@ func (s *HandleKeyCase) Run(ctx *framework.TaskContext) error { return err } - err = table.Delete(map[string]interface{}{ + err = table.Delete(map[string]any{ "id": 0, }).Send().Wait().Check() return err diff --git a/tests/mq_protocol_tests/cases/case_many_types.go b/tests/mq_protocol_tests/cases/case_many_types.go index 63548ea8f2..0d88162efb 100644 --- a/tests/mq_protocol_tests/cases/case_many_types.go +++ b/tests/mq_protocol_tests/cases/case_many_types.go @@ -152,7 +152,7 @@ func (s *ManyTypesCase) Run(ctx *framework.TaskContext) error { // Get a handle of an existing table table := ctx.SQLHelper().GetTable("test") - data := map[string]interface{}{ + data := map[string]any{ "id": 0, "t_boolean": true, "t_bigint": math.MaxInt64, diff --git a/tests/mq_protocol_tests/cases/case_simple.go b/tests/mq_protocol_tests/cases/case_simple.go index d9f10a45e2..957b9341f4 100644 --- a/tests/mq_protocol_tests/cases/case_simple.go +++ b/tests/mq_protocol_tests/cases/case_simple.go @@ -45,7 +45,7 @@ func (s *SimpleCase) Run(ctx *framework.TaskContext) error { // Get a handle of an existing table table := ctx.SQLHelper().GetTable("test") // Create an SQL request, send it to the upstream, wait for completion and check the correctness of replication - err = table.Insert(map[string]interface{}{ + err = table.Insert(map[string]any{ "id": 0, "value": 0, }).Send().Wait().Check() @@ -57,7 +57,7 @@ func (s *SimpleCase) Run(ctx *framework.TaskContext) error { reqs := make([]framework.Awaitable, 0) for i := 1; i < 1000; i++ { // Only send, do not wait - req := table.Insert(map[string]interface{}{ + req := table.Insert(map[string]any{ "id": i, "value": i, }).Send() @@ -70,7 +70,7 @@ func (s *SimpleCase) Run(ctx *framework.TaskContext) error { return err } - err = table.Upsert(map[string]interface{}{ + err = table.Upsert(map[string]any{ "id": 0, "value": 1, }).Send().Wait().Check() @@ -78,7 +78,7 @@ func (s *SimpleCase) Run(ctx *framework.TaskContext) error { return err } - err = table.Delete(map[string]interface{}{ + err = table.Delete(map[string]any{ "id": 0, }).Send().Wait().Check() return err diff --git a/tests/mq_protocol_tests/cases/case_unsigned.go b/tests/mq_protocol_tests/cases/case_unsigned.go index 3e9c7f7d14..a1757f8bf7 100644 --- a/tests/mq_protocol_tests/cases/case_unsigned.go +++ b/tests/mq_protocol_tests/cases/case_unsigned.go @@ -61,7 +61,7 @@ func (s *UnsignedCase) Run(ctx *framework.TaskContext) error { // Get a handle of an existing table table := ctx.SQLHelper().GetTable("test") - return table.Insert(map[string]interface{}{ + return table.Insert(map[string]any{ "id": 0, "t_int": 0xFEEDBEEF, "t_bigint": uint64(0xFEEDBEEFFEEDBEEF), diff --git a/tests/mq_protocol_tests/framework/avro/kafka_docker_env.go b/tests/mq_protocol_tests/framework/avro/kafka_docker_env.go index ea5006439f..4d93ebb108 100644 --- a/tests/mq_protocol_tests/framework/avro/kafka_docker_env.go +++ b/tests/mq_protocol_tests/framework/avro/kafka_docker_env.go @@ -54,7 +54,7 @@ func NewKafkaDockerEnv(dockerComposeFile string) *KafkaDockerEnv { return err } - m := make(map[string]interface{}) + m := make(map[string]any) err = json.Unmarshal(bytes, &m) if err != nil { return err diff --git a/tests/mq_protocol_tests/framework/docker_env.go b/tests/mq_protocol_tests/framework/docker_env.go index 06d7365ee9..3260949be3 100644 --- a/tests/mq_protocol_tests/framework/docker_env.go +++ b/tests/mq_protocol_tests/framework/docker_env.go @@ -121,7 +121,7 @@ func (e *DockerEnv) RunTest(task Task) { } // SetListener implements Environment. Currently unfinished, will be used to monitor Kafka output -func (e *DockerEnv) SetListener(states interface{}, listener MqListener) { +func (e *DockerEnv) SetListener(states any, listener MqListener) { // TODO } diff --git a/tests/mq_protocol_tests/framework/env.go b/tests/mq_protocol_tests/framework/env.go index 1bf466c7fa..f5a8a83a1a 100644 --- a/tests/mq_protocol_tests/framework/env.go +++ b/tests/mq_protocol_tests/framework/env.go @@ -14,7 +14,7 @@ package framework // MqListener represents a callback function for listening on the MQ output -type MqListener func(states interface{}, topic string, key []byte, value []byte) error +type MqListener func(states any, topic string, key []byte, value []byte) error // Environment is an abstract of the CDC-Upstream-Downstream-MQ complex to be tested type Environment interface { @@ -22,5 +22,5 @@ type Environment interface { TearDown() Reset() RunTest(Task) - SetListener(states interface{}, listener MqListener) + SetListener(states any, listener MqListener) } diff --git a/tests/mq_protocol_tests/framework/sql_batch_op.go b/tests/mq_protocol_tests/framework/sql_batch_op.go index e05c9072c9..a3cc1e4be9 100644 --- a/tests/mq_protocol_tests/framework/sql_batch_op.go +++ b/tests/mq_protocol_tests/framework/sql_batch_op.go @@ -32,8 +32,8 @@ const ( type sqlAllAwaiter struct { helper *SQLHelper - data map[interface{}]sqlRowContainer - retrievedValues []map[string]interface{} + data map[any]sqlRowContainer + retrievedValues []map[string]any table *Table } @@ -46,8 +46,8 @@ func All(helper *SQLHelper, awaitables []Awaitable) Awaitable { ret := &sqlAllAwaiter{ helper: helper, - data: make(map[interface{}]sqlRowContainer, len(awaitables)), - retrievedValues: make([]map[string]interface{}, 0), + data: make(map[any]sqlRowContainer, len(awaitables)), + retrievedValues: make([]map[string]any, 0), table: awaitables[0].(sqlRowContainer).getTable(), } @@ -71,8 +71,8 @@ func (s *sqlAllAwaiter) poll(ctx context.Context) (bool, error) { batchSize := 0 counter := 0 - indexValues := make([]interface{}, 0) - s.retrievedValues = make([]map[string]interface{}, 0) + indexValues := make([]any, 0) + s.retrievedValues = make([]map[string]any, 0) for k, v := range s.data { indexValues = append(indexValues, k) batchSize++ @@ -101,7 +101,7 @@ func (s *sqlAllAwaiter) poll(ctx context.Context) (bool, error) { s.retrievedValues = append(s.retrievedValues, m) } batchSize = 0 - indexValues = make([]interface{}, 0) + indexValues = make([]any, 0) } } @@ -130,7 +130,7 @@ func (s *sqlAllAwaiter) Check() error { return nil } -func normalizeKeys(key interface{}) interface{} { +func normalizeKeys(key any) any { switch key.(type) { case int, int8, int16, int32, int64: return reflect.ValueOf(key).Int() diff --git a/tests/mq_protocol_tests/framework/sql_helper.go b/tests/mq_protocol_tests/framework/sql_helper.go index d05e8b4dd8..7fd3024560 100644 --- a/tests/mq_protocol_tests/framework/sql_helper.go +++ b/tests/mq_protocol_tests/framework/sql_helper.go @@ -61,7 +61,7 @@ func (h *SQLHelper) GetTable(tableName string) *Table { return &Table{tableName: tableName, uniqueIndex: idxCol, helper: h} } -func (t *Table) makeSQLRequest(requestType sqlRequestType, rowData map[string]interface{}) (*sqlRequest, error) { +func (t *Table) makeSQLRequest(requestType sqlRequestType, rowData map[string]any) (*sqlRequest, error) { if t.err != nil { return nil, t.err } @@ -77,7 +77,7 @@ func (t *Table) makeSQLRequest(requestType sqlRequestType, rowData map[string]in } // Insert returns a Sendable object that represents an Insert clause -func (t *Table) Insert(rowData map[string]interface{}) Sendable { +func (t *Table) Insert(rowData map[string]any) Sendable { basicReq, err := t.makeSQLRequest(sqlRequestTypeInsert, rowData) if err != nil { return &errorSender{err: err} @@ -87,7 +87,7 @@ func (t *Table) Insert(rowData map[string]interface{}) Sendable { } // Upsert returns a Sendable object that represents a Replace Into clause -func (t *Table) Upsert(rowData map[string]interface{}) Sendable { +func (t *Table) Upsert(rowData map[string]any) Sendable { basicReq, err := t.makeSQLRequest(sqlRequestTypeUpsert, rowData) if err != nil { return &errorSender{err: err} @@ -97,7 +97,7 @@ func (t *Table) Upsert(rowData map[string]interface{}) Sendable { } // Delete returns a Sendable object that represents a Delete from clause -func (t *Table) Delete(rowData map[string]interface{}) Sendable { +func (t *Table) Delete(rowData map[string]any) Sendable { basicReq, err := t.makeSQLRequest(sqlRequestTypeDelete, rowData) if err != nil { return &errorSender{err: err} @@ -107,7 +107,7 @@ func (t *Table) Delete(rowData map[string]interface{}) Sendable { } type sqlRowContainer interface { - getData() map[string]interface{} + getData() map[string]any getComparableKey() string getTable() *Table } @@ -127,12 +127,12 @@ const ( type sqlRequest struct { tableName string - data map[string]interface{} - result map[string]interface{} + data map[string]any + result map[string]any uniqueIndex []string helper *SQLHelper requestType sqlRequestType - hasReadBack uint32 + hasReadBack atomic.Uint32 } // MarshalLogObjects helps printing the sqlRequest @@ -146,9 +146,9 @@ func (s *sqlRequest) getPrimaryKeyTuple() string { return makeColumnTuple(s.uniqueIndex) } -func (s *sqlRequest) getWhereCondition() []interface{} { +func (s *sqlRequest) getWhereCondition() []any { builder := strings.Builder{} - args := make([]interface{}, 1, len(s.uniqueIndex)+1) + args := make([]any, 1, len(s.uniqueIndex)+1) builder.WriteString(s.getPrimaryKeyTuple() + " = (") for i, col := range s.uniqueIndex { builder.WriteString("?") @@ -168,7 +168,7 @@ func (s *sqlRequest) getComparableKey() string { return s.uniqueIndex[0] } - ret := make(map[string]interface{}) + ret := make(map[string]any) for k, v := range s.data { for _, col := range s.uniqueIndex { if k == col { @@ -179,7 +179,7 @@ func (s *sqlRequest) getComparableKey() string { return fmt.Sprintf("%v", ret) } -func (s *sqlRequest) getData() map[string]interface{} { +func (s *sqlRequest) getData() map[string]any { return s.data } @@ -221,7 +221,7 @@ type syncSQLRequest struct { } func (r *syncSQLRequest) Send() Awaitable { - atomic.StoreUint32(&r.hasReadBack, 0) + r.hasReadBack.Store(0) var err error switch r.requestType { case sqlRequestTypeInsert: @@ -261,7 +261,7 @@ func (r *syncSQLRequest) Send() Awaitable { } } - atomic.StoreUint32(&r.hasReadBack, 1) + r.hasReadBack.Store(1) }() if err != nil { @@ -283,7 +283,7 @@ func (s *sqlRequest) insert(ctx context.Context) error { } keys := make([]string, len(s.data)) - values := make([]interface{}, len(s.data)) + values := make([]any, len(s.data)) i := 0 for k, v := range s.data { keys[i] = k @@ -304,7 +304,7 @@ func (s *sqlRequest) upsert(ctx context.Context) error { db := sqlx.NewDb(s.helper.upstream, "mysql") keys := make([]string, len(s.data)) - values := make([]interface{}, len(s.data)) + values := make([]any, len(s.data)) i := 0 for k, v := range s.data { keys[i] = k @@ -342,7 +342,7 @@ func (s *sqlRequest) delete(ctx context.Context) error { return nil } -func (s *sqlRequest) read(ctx context.Context) (map[string]interface{}, error) { +func (s *sqlRequest) read(ctx context.Context) (map[string]any, error) { db, err := sqlbuilder.New("mysql", s.helper.downstream) if err != nil { return nil, errors.AddStack(err) @@ -369,7 +369,7 @@ func (s *sqlRequest) getBasicAwaitable() basicAwaitable { } func (s *sqlRequest) poll(ctx context.Context) (bool, error) { - if atomic.LoadUint32(&s.hasReadBack) == 0 { + if s.hasReadBack.Load() == 0 { return false, nil } res, err := s.read(ctx) @@ -421,14 +421,14 @@ func (s *sqlRequest) Check() error { return errors.New("Check failed") } -func rowsToMap(rows *sql.Rows) (map[string]interface{}, error) { +func rowsToMap(rows *sql.Rows) (map[string]any, error) { colNames, err := rows.Columns() if err != nil { return nil, errors.AddStack(err) } - colData := make([]interface{}, len(colNames)) - colDataPtrs := make([]interface{}, len(colNames)) + colData := make([]any, len(colNames)) + colDataPtrs := make([]any, len(colNames)) for i := range colData { colDataPtrs[i] = &colData[i] } @@ -438,8 +438,8 @@ func rowsToMap(rows *sql.Rows) (map[string]interface{}, error) { return nil, errors.AddStack(err) } - ret := make(map[string]interface{}, len(colNames)) - for i := 0; i < len(colNames); i++ { + ret := make(map[string]any, len(colNames)) + for i := range colNames { ret[colNames[i]] = colData[i] } return ret, nil @@ -465,7 +465,7 @@ func getUniqueIndexColumn(ctx context.Context, db sqlbuilder.Database, dbName st return strings.Split(colName, " "), nil } -func compareMaps(m1 map[string]interface{}, m2 map[string]interface{}) bool { +func compareMaps(m1 map[string]any, m2 map[string]any) bool { // TODO better comparator if m2 == nil { return false From 78442d68f532330192193e0093206cf11d6257a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dani=C3=ABl=20van=20Eeden?= Date: Tue, 9 Jun 2026 17:08:59 +0200 Subject: [PATCH 2/2] Fix formatting --- engine/framework/internal/eventloop/runner_test.go | 2 -- engine/jobmaster/dm/bootstrap/upgrade.go | 1 - engine/pkg/client/internal/call_test.go | 2 -- engine/pkg/containers/slice_queue_test.go | 2 -- engine/pkg/errctx/center_test.go | 2 -- engine/pkg/notifier/notifier_test.go | 2 -- engine/servermaster/serverutil/watch_executors_test.go | 1 - pkg/chdelay/channel_delayer_test.go | 1 - pkg/p2p/server_client_integration_test.go | 1 - 9 files changed, 14 deletions(-) diff --git a/engine/framework/internal/eventloop/runner_test.go b/engine/framework/internal/eventloop/runner_test.go index e328ace423..614ec9236c 100644 --- a/engine/framework/internal/eventloop/runner_test.go +++ b/engine/framework/internal/eventloop/runner_test.go @@ -119,7 +119,6 @@ func TestRunnerNormalPath(t *testing.T) { var wg sync.WaitGroup wg.Go(func() { - err := runner.Run(context.Background()) require.Error(t, err) require.Regexp(t, "injected error", err) @@ -152,7 +151,6 @@ func TestRunnerForcefulExit(t *testing.T) { var wg sync.WaitGroup wg.Go(func() { - err := runner.Run(context.Background()) require.Error(t, err) require.Regexp(t, "ErrWorkerSuicide", err) diff --git a/engine/jobmaster/dm/bootstrap/upgrade.go b/engine/jobmaster/dm/bootstrap/upgrade.go index d51047c788..04bba1661b 100644 --- a/engine/jobmaster/dm/bootstrap/upgrade.go +++ b/engine/jobmaster/dm/bootstrap/upgrade.go @@ -68,7 +68,6 @@ func (upgrader *DefaultUpgrader) Upgrade(ctx context.Context, fromVer semver.Ver } if err != nil { for _, rollback := range slices.Backward(rollbackFuncs) { - if rollback != nil { if err2 := rollback(ctx); err2 != nil { upgrader.logger.Error("rollback failed", zap.Error(err2)) diff --git a/engine/pkg/client/internal/call_test.go b/engine/pkg/client/internal/call_test.go index 286662f36a..1e25ef24e9 100644 --- a/engine/pkg/client/internal/call_test.go +++ b/engine/pkg/client/internal/call_test.go @@ -60,7 +60,6 @@ func TestCallFuncCancel(t *testing.T) { var wg sync.WaitGroup wg.Go(func() { - resp, err := call.Do(ctx) require.Nil(t, resp) require.Error(t, err) @@ -83,7 +82,6 @@ func TestCallRetryCancel(t *testing.T) { var wg sync.WaitGroup wg.Go(func() { - resp, err := call.Do(ctx) require.Nil(t, resp) require.Error(t, err) diff --git a/engine/pkg/containers/slice_queue_test.go b/engine/pkg/containers/slice_queue_test.go index 269e8f18e1..5626f9536e 100644 --- a/engine/pkg/containers/slice_queue_test.go +++ b/engine/pkg/containers/slice_queue_test.go @@ -103,14 +103,12 @@ func TestSliceQueueConcurrentWriteAndRead(t *testing.T) { q := NewSliceQueue[int]() var wg sync.WaitGroup wg.Go(func() { - for i := range numElems { q.Push(i) } }) wg.Go(func() { - counter := 0 for { <-q.C diff --git a/engine/pkg/errctx/center_test.go b/engine/pkg/errctx/center_test.go index 50d5e14b79..a7b98a8a6a 100644 --- a/engine/pkg/errctx/center_test.go +++ b/engine/pkg/errctx/center_test.go @@ -28,7 +28,6 @@ func TestErrCenterMultipleErrCtx(t *testing.T) { var wg sync.WaitGroup for range 10 { wg.Go(func() { - ctx, cancel := center.WithCancelOnFirstError(context.Background()) defer cancel() <-ctx.Done() @@ -53,7 +52,6 @@ func TestErrCenterSingleErrCtx(t *testing.T) { var wg sync.WaitGroup for range 10 { wg.Go(func() { - <-ctx.Done() require.Error(t, ctx.Err()) require.EqualError(t, ctx.Err(), "fake error") diff --git a/engine/pkg/notifier/notifier_test.go b/engine/pkg/notifier/notifier_test.go index a2ab27b6e7..cf4c36b080 100644 --- a/engine/pkg/notifier/notifier_test.go +++ b/engine/pkg/notifier/notifier_test.go @@ -36,7 +36,6 @@ func TestNotifierBasics(t *testing.T) { for range numReceivers { wg.Go(func() { - r := n.NewReceiver() defer r.Close() @@ -78,7 +77,6 @@ func TestNotifierClose(t *testing.T) { for range numReceivers { wg.Go(func() { - r := n.NewReceiver() defer r.Close() diff --git a/engine/servermaster/serverutil/watch_executors_test.go b/engine/servermaster/serverutil/watch_executors_test.go index 2bd7adf15a..a4ac06b0e6 100644 --- a/engine/servermaster/serverutil/watch_executors_test.go +++ b/engine/servermaster/serverutil/watch_executors_test.go @@ -129,7 +129,6 @@ func TestWatchExecutors(t *testing.T) { var wg sync.WaitGroup wg.Go(func() { - err := WatchExecutors(ctx, watcher, user) require.ErrorIs(t, err, context.Canceled) }) diff --git a/pkg/chdelay/channel_delayer_test.go b/pkg/chdelay/channel_delayer_test.go index 9d657d5ba8..25fddba5fa 100644 --- a/pkg/chdelay/channel_delayer_test.go +++ b/pkg/chdelay/channel_delayer_test.go @@ -47,7 +47,6 @@ func testChannelDelayer(t *testing.T, delayBy time.Duration, count int) { }) wg.Go(func() { - counter := 0 for ts := range delayer.Out() { require.Greater(t, time.Since(ts), delayBy) diff --git a/pkg/p2p/server_client_integration_test.go b/pkg/p2p/server_client_integration_test.go index e1ad26735c..1709d83817 100644 --- a/pkg/p2p/server_client_integration_test.go +++ b/pkg/p2p/server_client_integration_test.go @@ -404,7 +404,6 @@ func TestTopicCongested(t *testing.T) { var lastSeq atomic.Int64 wg.Go(func() { - for range 100 { seq, err := client.SendMessage(ctx, "test-topic-1", &testTopicContent{}) require.NoError(t, err)