Revert "refactor build infio"

This reverts commit 2304fca.

Author: FGasper

.github/workflows/all.yml

@@ -70,3 +70,4 @@ jobs:
           MVTEST_SRC: ${{matrix.topology.srcConnStr}}
           MVTEST_DST: ${{matrix.topology.dstConnStr}}
           MVTEST_META: mongodb://localhost:27040
+          MVTEST_TOPOLOGY: ${{matrix.topology.name}}

internal/partitions/partition.go

@@ -137,7 +137,7 @@ func (p *Partition) FindCmd(
 // (e.g. use the partitions on the source to read the destination for verification)
 // If the passed-in buildinfo indicates a mongodb version < 5.0, type bracketing is not used.
 // filterAndPredicates is a slice of filter criteria that's used to construct the "filter" field in the find option.
-func (p *Partition) GetFindOptions(buildInfo *util.BuildInfo, filterAndPredicates bson.A) bson.D {
+func (p *Partition) GetFindOptions(buildInfo *bson.M, filterAndPredicates bson.A) bson.D {
 	if p == nil {
 		if len(filterAndPredicates) > 0 {
 			return bson.D{{"filter", bson.D{{"$and", filterAndPredicates}}}}
@@ -160,9 +160,16 @@ func (p *Partition) GetFindOptions(buildInfo *util.BuildInfo, filterAndPredicate
 		allowTypeBracketing := false
 		if buildInfo != nil {
 			allowTypeBracketing = true
-
-			if buildInfo.VersionArray != nil {
-				allowTypeBracketing = buildInfo.VersionArray[0] < 5
+			versionArray, ok := (*buildInfo)["versionArray"].(bson.A)
+			//bson values are int32 or int64, never int.
+			if ok {
+				majorVersion, ok := versionArray[0].(int32)
+				if ok {
+					allowTypeBracketing = majorVersion < 5
+				} else {
+					majorVersion64, _ := versionArray[0].(int64)
+					allowTypeBracketing = majorVersion64 < 5
+				}
 			}
 		}
 		if !allowTypeBracketing {

internal/partitions/partition_test.go

@@ -77,38 +77,43 @@ func (suite *UnitTestSuite) TestVersioning() {
 	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 = getFilterFromFindOptions(findOptions)
+	suite.Require().Equal(expectedFilter, filter)
+
 	// 6.0
-	findOptions = partition.GetFindOptions(&util.BuildInfo{VersionArray: []int{6, 0, 0}}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(6), int32(0), int32(0), int32(0)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 5.3.0.9
-	findOptions = partition.GetFindOptions(&util.BuildInfo{VersionArray: []int{5, 3, 0, 9}}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(5), int32(3), int32(0), int32(9)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 7.1.3.5
-	findOptions = partition.GetFindOptions(&util.BuildInfo{VersionArray: []int{7, 1, 3, 5}}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(7), int32(1), int32(3), int32(5)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilter, filter)
 
 	// 4.4 (int64)
-	findOptions = partition.GetFindOptions(&util.BuildInfo{VersionArray: []int{4, 4, 0, 0}}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int64(4), int64(4), int64(0), int64(0)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// 4.4
-	findOptions = partition.GetFindOptions(&util.BuildInfo{VersionArray: []int{4, 4, 0, 0}}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(4), int32(4), int32(0), int32(0)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// 4.2
-	findOptions = partition.GetFindOptions(&util.BuildInfo{VersionArray: []int{4, 2, 0, 0}}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"versionArray": bson.A{int32(4), int32(2), int32(0), int32(0)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 
 	// No version array -- assume old, require type bracketing.
-	findOptions = partition.GetFindOptions(&util.BuildInfo{}, nil)
+	findOptions = partition.GetFindOptions(&bson.M{"notVersionArray": bson.A{6, int32(0), int32(0), int32(0)}}, nil)
 	filter = getFilterFromFindOptions(findOptions)
 	suite.Require().Equal(expectedFilterWithTypeBracketing, filter)
 }

internal/util/buildinfo.go

@@ -2,12 +2,11 @@ package verifier
 
 import (
 	"context"
+	"os"
 	"strings"
 
-	"github.com/10gen/migration-verifier/internal/util"
 	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/pkg/errors"
-	"github.com/samber/lo"
 	"github.com/stretchr/testify/suite"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -122,10 +121,19 @@ func (suite *IntegrationTestSuite) TearDownTest() {
 }
 
 func (suite *IntegrationTestSuite) GetTopology() TestTopology {
-	buildInfo, err := util.GetBuildInfo(suite.Context(), suite.srcMongoClient)
-	suite.Require().NoError(err, "should read source's build info")
+	rawTopology, found := os.LookupEnv(topologyEnvVar)
 
-	return lo.Ternary(buildInfo.IsSharded, TopologySharded, "")
+	suite.Require().True(found, "Environment must contain %#q.", topologyEnvVar)
+
+	topology := TestTopology(rawTopology)
+
+	suite.Require().Contains(
+		knownTopologies,
+		topology,
+		"%#q must be a known value.",
+	)
+
+	return topology
 }
 
 func (suite *IntegrationTestSuite) BuildVerifier() *Verifier {

internal/verifier/integration_test_suite.go

@@ -21,7 +21,6 @@ import (
 	"github.com/10gen/migration-verifier/internal/reportutils"
 	"github.com/10gen/migration-verifier/internal/retry"
 	"github.com/10gen/migration-verifier/internal/types"
-	"github.com/10gen/migration-verifier/internal/util"
 	"github.com/10gen/migration-verifier/internal/uuidutil"
 	"github.com/olekukonko/tablewriter"
 	"github.com/pkg/errors"
@@ -89,8 +88,8 @@ type Verifier struct {
 	metaClient         *mongo.Client
 	srcClient          *mongo.Client
 	dstClient          *mongo.Client
-	srcBuildInfo       *util.BuildInfo
-	dstBuildInfo       *util.BuildInfo
+	srcBuildInfo       *bson.M
+	dstBuildInfo       *bson.M
 	numWorkers         int
 	failureDisplaySize int64
 
@@ -277,33 +276,21 @@ func (verifier *Verifier) SetSrcURI(ctx context.Context, uri string) error {
 	var err error
 	verifier.srcClient, err = mongo.Connect(ctx, opts)
 	if err != nil {
-		return errors.Wrapf(err, "failed to connect to source %#q", uri)
+		return errors.Wrapf(err, "failed to connect to %#q", uri)
 	}
-
-	buildInfo, err := util.GetBuildInfo(ctx, verifier.srcClient)
-	if err != nil {
-		return errors.Wrap(err, "failed to read source build info")
-	}
-
-	verifier.srcBuildInfo = &buildInfo
-	return nil
+	verifier.srcBuildInfo, err = getBuildInfo(ctx, verifier.srcClient)
+	return err
 }
 
 func (verifier *Verifier) SetDstURI(ctx context.Context, uri string) error {
 	opts := verifier.getClientOpts(uri)
 	var err error
 	verifier.dstClient, err = mongo.Connect(ctx, opts)
 	if err != nil {
-		return errors.Wrapf(err, "failed to connect to destination %#q", uri)
-	}
-
-	buildInfo, err := util.GetBuildInfo(ctx, verifier.dstClient)
-	if err != nil {
-		return errors.Wrap(err, "failed to read destination build info")
+		return err
 	}
-
-	verifier.dstBuildInfo = &buildInfo
-	return nil
+	verifier.dstBuildInfo, err = getBuildInfo(ctx, verifier.dstClient)
+	return err
 }
 
 func (verifier *Verifier) SetServerPort(port int) {
@@ -442,7 +429,7 @@ func (verifier *Verifier) maybeAppendGlobalFilterToPredicates(predicates bson.A)
 	return append(predicates, verifier.globalFilter)
 }
 
-func (verifier *Verifier) getDocumentsCursor(ctx context.Context, collection *mongo.Collection, buildInfo *util.BuildInfo,
+func (verifier *Verifier) getDocumentsCursor(ctx context.Context, collection *mongo.Collection, buildInfo *bson.M,
 	startAtTs *primitive.Timestamp, task *VerificationTask) (*mongo.Cursor, error) {
 	var findOptions bson.D
 	runCommandOptions := options.RunCmd()
@@ -1415,3 +1402,16 @@ func (verifier *Verifier) getNamespaces(ctx context.Context, fieldName string) (
 	}
 	return namespaces, nil
 }
+
+func getBuildInfo(ctx context.Context, client *mongo.Client) (*bson.M, error) {
+	commandResult := client.Database("admin").RunCommand(ctx, bson.D{{"buildinfo", 1}})
+	if commandResult.Err() != nil {
+		return nil, commandResult.Err()
+	}
+	var buildInfoMap bson.M
+	err := commandResult.Decode(&buildInfoMap)
+	if err != nil {
+		return nil, err
+	}
+	return &buildInfoMap, nil
+}