Merge branch 'fix_lint' into REP-5201-persist-resume-token

Author: FGasper

internal/partitions/partition_test.go

@@ -73,50 +73,60 @@ func (suite *UnitTestSuite) TestVersioning() {
 	expectedFilterWithTypeBracketing := makeExpectedFilterWithTypeBracketing(partition.Key.Lower, partition.Upper)
 	// No version given, default to no bracketing
 	findOptions := partition.GetFindOptions(nil, nil)
-	filter := findOptions.Map()["filter"]
+	filter := getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 6.0 (int64)
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int64(6), int64(0), int64(0), int64(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 6.0
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(6), int32(0), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 5.3.0.9
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(5), int32(3), int32(0), int32(9)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 7.1.3.5
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(7), int32(1), int32(3), int32(5)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 4.4 (int64)
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int64(4), int64(4), int64(0), int64(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// 4.4
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(4), int32(4), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// 4.2
 	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(4), int32(2), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// No version array -- assume old, require type bracketing.
 	findOptions = partition.GetFindOptions(&bson.M{"notVersionArray": bson.A{6, int32(0), int32(0), int32(0)}}, nil)
-	filter = findOptions.Map()["filter"]
+	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 }
 
+func getFilterFromFindOptions(opts bson.D) any {
+	for _, el := range opts {
+		if el.Key == "filter" {
+			return el.Value
+		}
+	}
+
+	return nil
+}
+
 func makeTestPartition() (Partition, bson.D) {
 	partition := Partition{
 		Key: PartitionKey{

internal/util/uuid.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/google/uuid"
+	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	"go.mongodb.org/mongo-driver/bson/bsontype"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -21,10 +22,10 @@ const (
 type UUID uuid.UUID
 
 var (
-	_ bsoncodec.ValueMarshaler   = UUID{}
-	_ bsoncodec.ValueUnmarshaler = (*UUID)(nil)
-	_ bsoncodec.KeyMarshaler     = UUID{}
-	_ bsoncodec.KeyUnmarshaler   = (*UUID)(nil)
+	_ bson.ValueMarshaler      = UUID{}
+	_ bson.ValueUnmarshaler    = (*UUID)(nil)
+	_ bsoncodec.KeyMarshaler   = UUID{}
+	_ bsoncodec.KeyUnmarshaler = (*UUID)(nil)
 )
 
 // NewUUID constructs a new, randomly-generated UUID.
@@ -36,13 +37,13 @@ func NewUUID() UUID {
 // ValueMarshaler interface.
 func (u UUID) MarshalBSONValue() (bsontype.Type, []byte, error) {
 	val := bsoncore.AppendBinary(nil, uuidBinarySubtype, u[:])
-	return bsontype.Binary, val, nil
+	return bson.TypeBinary, val, nil
 }
 
 // UnmarshalBSONValue is used to unmarshal BSON into UUID objects. This implements the
 // ValueUnmarshaler interface.
 func (u *UUID) UnmarshalBSONValue(bsonType bsontype.Type, data []byte) error {
-	if bsonType != bsontype.Binary {
+	if bsonType != bson.TypeBinary {
 		return fmt.Errorf("cannot decoded BSON value of type %s as a UUID", bsonType)
 	}
 

internal/verifier/bson_compare.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/bsontype"
 )
 
 type MismatchDetails struct {
@@ -109,9 +108,9 @@ func bsonUnorderedCompareRawValue(srcValue, dstValue bson.RawValue) (bool, error
 	}
 
 	switch srcValue.Type {
-	case bsontype.Array:
+	case bson.TypeArray:
 		return bsonUnorderedCompareRawArray(srcValue.Array(), dstValue.Array())
-	case bsontype.EmbeddedDocument:
+	case bson.TypeEmbeddedDocument:
 		return BsonUnorderedCompareRawDocument(srcValue.Document(), dstValue.Document())
 	default:
 		return srcValue.Equal(dstValue), nil

internal/verifier/change_stream_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
 )
 
@@ -77,7 +76,7 @@ func (suite *MultiSourceVersionTestSuite) TestStartAtTimeWithChanges() {
 	suite.Require().NoError(err)
 	newStartTs := sess.OperationTime()
 	suite.Require().NotNil(newStartTs)
-	suite.Require().Less(primitive.CompareTimestamp(*origStartTs, *newStartTs), 0)
+	suite.Require().Negative(origStartTs.Compare(*newStartTs))
 	verifier.changeStreamEnderChan <- struct{}{}
 	<-verifier.changeStreamDoneChan
 	suite.Require().Equal(verifier.srcStartAtTs, newStartTs)

internal/verifier/migration_verifier.go

@@ -211,7 +211,7 @@ func (verifier *Verifier) getClientOpts(uri string) *options.ClientOptions {
 		AppName: &appName,
 	}
 	opts.ApplyURI(uri)
-	opts.SetWriteConcern(writeconcern.New(writeconcern.WMajority()))
+	opts.SetWriteConcern(writeconcern.Majority())
 
 	verifier.doIfForceReadConcernMajority(func() {
 		opts.SetReadConcern(readconcern.Majority())
@@ -714,12 +714,11 @@ func (verifier *Verifier) logChunkInfo(ctx context.Context, namespaceAndUUID *uu
 	}
 	defer cursor.Close(ctx)
 	for cursor.Next(ctx) {
-		var result bson.D
-		if err = cursor.Decode(&result); err != nil {
+		var resultMap bson.M
+		if err = cursor.Decode(&resultMap); err != nil {
 			verifier.logger.Error().Msgf("Error decoding chunk info for %s: %v", namespace, err)
 			return
 		}
-		resultMap := result.Map()
 		verifier.logger.Debug().Msgf(" Chunk of %s on %v, range %v to %v", namespace, resultMap["shard"],
 			resultMap["min"], resultMap["max"])
 	}
@@ -986,7 +985,7 @@ func (verifier *Verifier) markCollectionFailed(workerNum int, task *Verification
 		Details:   Failed + fmt.Sprintf(" %v", err)})
 }
 
-func verifyIndexes(ctx context.Context, workerNum int, task *VerificationTask, srcColl, dstColl *mongo.Collection,
+func verifyIndexes(ctx context.Context, _ int, _ *VerificationTask, srcColl, dstColl *mongo.Collection,
 	srcIdIndexSpec, dstIdIndexSpec *mongo.IndexSpecification) ([]VerificationResult, error) {
 	srcSpecs, err := srcColl.Indexes().ListSpecifications(ctx)
 	if err != nil {
@@ -1209,12 +1208,12 @@ func (verifier *Verifier) doIfForceReadConcernMajority(f func()) {
 
 func (verifier *Verifier) verificationDatabase() *mongo.Database {
 	db := verifier.metaClient.Database(verifier.metaDBName)
-	if db.WriteConcern().GetW() != "majority" {
+	if db.WriteConcern().W != "majority" {
 		verifier.logger.Fatal().Msgf("Verification metadata is not using write concern majority: %+v", db.WriteConcern())
 	}
 
 	verifier.doIfForceReadConcernMajority(func() {
-		if db.ReadConcern().GetLevel() != "majority" {
+		if db.ReadConcern().Level != "majority" {
 			verifier.logger.Fatal().Msgf("Verification metadata is not using read concern majority: %+v", db.ReadConcern())
 		}
 	})
@@ -1234,7 +1233,7 @@ func (verifier *Verifier) srcClientDatabase(dbName string) *mongo.Database {
 	db := verifier.srcClient.Database(dbName)
 	// No need to check the write concern because we do not write to the source database.
 	verifier.doIfForceReadConcernMajority(func() {
-		if db.ReadConcern().GetLevel() != "majority" {
+		if db.ReadConcern().Level != "majority" {
 			verifier.logger.Fatal().Msgf("Source client is not using read concern majority: %+v", db.ReadConcern())
 		}
 	})
@@ -1245,7 +1244,7 @@ func (verifier *Verifier) dstClientDatabase(dbName string) *mongo.Database {
 	db := verifier.dstClient.Database(dbName)
 	// No need to check the write concern because we do not write to the target database.
 	verifier.doIfForceReadConcernMajority(func() {
-		if db.ReadConcern().GetLevel() != "majority" {
+		if db.ReadConcern().Level != "majority" {
 			verifier.logger.Fatal().Msgf("Source client is not using read concern majority: %+v", db.ReadConcern())
 		}
 	})
@@ -1460,11 +1459,10 @@ func getBuildInfo(ctx context.Context, client *mongo.Client) (*bson.M, error) {
 	if commandResult.Err() != nil {
 		return nil, commandResult.Err()
 	}
-	var buildInfo bson.D
-	err := commandResult.Decode(&buildInfo)
+	var buildInfoMap bson.M
+	err := commandResult.Decode(&buildInfoMap)
 	if err != nil {
 		return nil, err
 	}
-	buildInfoMap := buildInfo.Map()
 	return &buildInfoMap, nil
 }

internal/verifier/migration_verifier_test.go

@@ -161,7 +161,7 @@ func (suite *MultiDataVersionTestSuite) TestVerifierFetchDocuments() {
 			func() {
 				doc := srcMap.Fetch(both[0])
 				val := doc.Lookup("num")
-				suite.Assert().Less(val.AsInt32(), int32(100))
+				suite.Assert().Less(val.AsInt64(), int64(100))
 			},
 			"doc is fetched",
 		)

internal/verifier/unit_test_util.go

@@ -83,10 +83,10 @@ func (suite *WithMongodsTestSuite) SetupSuite() {
 	err := startTestMongods(suite.T(), &suite.srcMongoInstance, &suite.dstMongoInstance, &suite.metaMongoInstance)
 	suite.Require().NoError(err)
 	ctx := context.Background()
-	clientOpts := options.Client().ApplyURI("mongodb://localhost:" + suite.srcMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.New(writeconcern.WMajority()))
+	clientOpts := options.Client().ApplyURI("mongodb://localhost:" + suite.srcMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.Majority())
 	suite.srcMongoClient, err = mongo.Connect(ctx, clientOpts)
 	suite.Require().NoError(err)
-	clientOpts = options.Client().ApplyURI("mongodb://localhost:" + suite.dstMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.New(writeconcern.WMajority()))
+	clientOpts = options.Client().ApplyURI("mongodb://localhost:" + suite.dstMongoInstance.port).SetAppName("Verifier Test Suite").SetWriteConcern(writeconcern.Majority())
 	suite.dstMongoClient, err = mongo.Connect(ctx, clientOpts)
 	suite.Require().NoError(err)
 	clientOpts = options.Client().ApplyURI("mongodb://localhost:" + suite.metaMongoInstance.port).SetAppName("Verifier Test Suite")

internal/verifier/util.go

@@ -1,17 +1,10 @@
 package verifier
 
 import (
-	"context"
 	"fmt"
 	"strings"
 
-	"github.com/10gen/migration-verifier/internal/logger"
 	"github.com/10gen/migration-verifier/internal/partitions"
-	"github.com/10gen/migration-verifier/internal/retry"
-	"github.com/10gen/migration-verifier/internal/util"
-	"github.com/pkg/errors"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
 )
 
@@ -96,52 +89,3 @@ type QueryFilter struct {
 	Namespace string `bson:"namespace"    json:"namespace"`
 	To        string `bson:"to,omitempty" json:"to,omitempty"`
 }
-
-// GetLastOpTimeAndSyncShardClusterTime retrieves the last operation time on the source.
-func GetLastOpTimeAndSyncShardClusterTime(
-	ctx context.Context,
-	logger *logger.Logger,
-	retryer retry.Retryer,
-	client *mongo.Client,
-	retryOnLockFailed bool,
-) (primitive.Timestamp, error) {
-	// 'appendOplogNote' will perform a no-op write on the source cluster. When run against
-	// sharded clusters, this command will perform the no-op write on all shards. In receiving
-	// the shard responses, the driver notes the highest $clusterTime amongst all of them.
-	var response *mongo.SingleResult
-	appendOplogNoteCmd := bson.D{
-		{"appendOplogNote", 1},
-		{"data", bson.D{{"migration-verifier", "last op fetching"}}},
-	}
-
-	if retryOnLockFailed {
-		retryer = retryer.WithErrorCodes(util.LockFailed)
-	}
-	err := retryer.RunForTransientErrorsOnly(ctx, logger, func(ri *retry.Info) error {
-		ri.Log(logger.Logger,
-			"appendOplogNote",
-			"source",
-			"",
-			"",
-			fmt.Sprintf("Running appendOplogNote command. %v", appendOplogNoteCmd))
-		response = client.Database("admin").RunCommand(ctx, appendOplogNoteCmd)
-		if err := response.Err(); err != nil {
-			return err
-		}
-
-		return nil
-	})
-
-	// Get the `operationTime` from the response and return it.
-	respStruct := struct {
-		OperationTime primitive.Timestamp `bson:"operationTime"`
-	}{}
-
-	err = response.Decode(&respStruct)
-	if err != nil {
-		return primitive.Timestamp{}, errors.Wrap(err,
-			"failed to parse source cluster's appendOplogNote response")
-	}
-
-	return respStruct.OperationTime, nil
-}