REP-5972 Version metadata to prevent breakage across verifier builds. (#113)

This adds a metadata version to the persisted generation and makes migration-verifier fail if it starts up and finds a persisted metadata version that mismatches its own.

Author: FGasper

internal/verifier/check_test.go

@@ -0,0 +1,26 @@
+package verifier
+
+func (suite *IntegrationTestSuite) TestPersistedMetadataVersionMismatch() {
+	ctx := suite.Context()
+
+	verifier := suite.BuildVerifier()
+	verifier.SetNamespaceMap()
+
+	genColl := verifier.metaClient.
+		Database(verifier.metaDBName).
+		Collection(generationCollName)
+
+	_, err := genColl.InsertOne(
+		ctx,
+		generationDoc{
+			MetadataVersion: verifierMetadataVersion - 1,
+		},
+	)
+	suite.Require().NoError(err, "should write old generation doc")
+
+	runner := RunVerifierCheck(ctx, suite.T(), verifier)
+	err = runner.AwaitGenerationEnd()
+
+	mme := metadataMismatchErr{}
+	suite.Require().ErrorAs(err, &mme)
+}

internal/verifier/generation.go

@@ -16,6 +16,22 @@ const (
 	generationFieldName = "generation"
 )
 
+type generationDoc struct {
+	Generation      int
+	MetadataVersion int
+}
+
+type metadataMismatchErr struct {
+	persistedVersion int
+}
+
+func (mme metadataMismatchErr) Error() string {
+	return fmt.Sprintf("persisted metadata (version: %d) predates this migration-verifier build (metadata version: %d); please discard prior verification progress by restarting with the `--clean` flag",
+		mme.persistedVersion,
+		verifierMetadataVersion,
+	)
+}
+
 func (v *Verifier) persistGenerationWhileLocked(ctx context.Context) error {
 	generation, _ := v.getGenerationWhileLocked()
 
@@ -24,7 +40,10 @@ func (v *Verifier) persistGenerationWhileLocked(ctx context.Context) error {
 	result, err := db.Collection(generationCollName).ReplaceOne(
 		ctx,
 		bson.D{},
-		bson.D{{generationFieldName, generation}},
+		generationDoc{
+			Generation:      generation,
+			MetadataVersion: verifierMetadataVersion,
+		},
 		options.Replace().SetUpsert(true),
 	)
 
@@ -43,9 +62,7 @@ func (v *Verifier) readGeneration(ctx context.Context) (option.Option[int], erro
 		bson.D{},
 	)
 
-	parsed := struct {
-		Generation int `bson:"generation"`
-	}{}
+	parsed := generationDoc{}
 
 	err := result.Decode(&parsed)
 
@@ -59,5 +76,10 @@ func (v *Verifier) readGeneration(ctx context.Context) (option.Option[int], erro
 		return option.None[int](), err
 	}
 
+	if parsed.MetadataVersion != verifierMetadataVersion {
+		return option.None[int](), metadataMismatchErr{parsed.MetadataVersion}
+
+	}
+
 	return option.Some(parsed.Generation), nil
 }

internal/verifier/metadata.go

@@ -1,93 +1,3 @@
 package verifier
 
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	"github.com/10gen/migration-verifier/internal/util"
-	"github.com/10gen/migration-verifier/option"
-	"github.com/pkg/errors"
-	"github.com/samber/lo"
-	"go.mongodb.org/mongo-driver/mongo"
-)
-
-// This is the Field for a VerificationResult for shard key mismatches.
-const ShardKeyField = "Shard Key"
-
-func (verifier *Verifier) verifyShardingIfNeeded(
-	ctx context.Context,
-	srcColl, dstColl *mongo.Collection,
-) ([]VerificationResult, error) {
-
-	// We only need to compare if both clusters are sharded
-	srcSharded := verifier.srcClusterInfo.Topology == util.TopologySharded
-	dstSharded := verifier.dstClusterInfo.Topology == util.TopologySharded
-
-	if !srcSharded || !dstSharded {
-		return nil, nil
-	}
-
-	srcShardOpt, err := util.GetShardKey(ctx, srcColl)
-	if err != nil {
-		return nil, errors.Wrapf(
-			err,
-			"failed to fetch %#q's shard key on source",
-			FullName(srcColl),
-		)
-	}
-
-	dstShardOpt, err := util.GetShardKey(ctx, dstColl)
-	if err != nil {
-		return nil, errors.Wrapf(
-			err,
-			"failed to fetch %#q's shard key on destination",
-			FullName(dstColl),
-		)
-	}
-
-	srcKey, srcIsSharded := srcShardOpt.Get()
-	dstKey, dstIsSharded := dstShardOpt.Get()
-
-	if !srcIsSharded && !dstIsSharded {
-		return nil, nil
-	}
-
-	if srcIsSharded != dstIsSharded {
-		return []VerificationResult{{
-			Field:     ShardKeyField,
-			Cluster:   lo.Ternary(srcIsSharded, ClusterTarget, ClusterSource),
-			Details:   Missing,
-			NameSpace: FullName(srcColl),
-		}}, nil
-	}
-
-	if bytes.Equal(srcKey, dstKey) {
-		return nil, nil
-	}
-
-	areEqual, err := util.ServerThinksTheseMatch(
-		ctx,
-		verifier.metaClient,
-		srcKey, dstKey,
-		option.None[mongo.Pipeline](),
-	)
-	if err != nil {
-		return nil, errors.Wrapf(
-			err,
-			"failed to ask server if shard keys (src %v; dst: %v) match",
-			srcKey,
-			dstKey,
-		)
-	}
-
-	if !areEqual {
-		return []VerificationResult{{
-			Field:     ShardKeyField,
-			Details:   fmt.Sprintf("%s: src=%v; dst=%v", Mismatch, srcKey, dstKey),
-			NameSpace: FullName(srcColl),
-		}}, nil
-	}
-
-	return nil, nil
-}
+const verifierMetadataVersion = 1

internal/verifier/sharding.go

@@ -0,0 +1,93 @@
+package verifier
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/10gen/migration-verifier/internal/util"
+	"github.com/10gen/migration-verifier/option"
+	"github.com/pkg/errors"
+	"github.com/samber/lo"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+// This is the Field for a VerificationResult for shard key mismatches.
+const ShardKeyField = "Shard Key"
+
+func (verifier *Verifier) verifyShardingIfNeeded(
+	ctx context.Context,
+	srcColl, dstColl *mongo.Collection,
+) ([]VerificationResult, error) {
+
+	// We only need to compare if both clusters are sharded
+	srcSharded := verifier.srcClusterInfo.Topology == util.TopologySharded
+	dstSharded := verifier.dstClusterInfo.Topology == util.TopologySharded
+
+	if !srcSharded || !dstSharded {
+		return nil, nil
+	}
+
+	srcShardOpt, err := util.GetShardKey(ctx, srcColl)
+	if err != nil {
+		return nil, errors.Wrapf(
+			err,
+			"failed to fetch %#q's shard key on source",
+			FullName(srcColl),
+		)
+	}
+
+	dstShardOpt, err := util.GetShardKey(ctx, dstColl)
+	if err != nil {
+		return nil, errors.Wrapf(
+			err,
+			"failed to fetch %#q's shard key on destination",
+			FullName(dstColl),
+		)
+	}
+
+	srcKey, srcIsSharded := srcShardOpt.Get()
+	dstKey, dstIsSharded := dstShardOpt.Get()
+
+	if !srcIsSharded && !dstIsSharded {
+		return nil, nil
+	}
+
+	if srcIsSharded != dstIsSharded {
+		return []VerificationResult{{
+			Field:     ShardKeyField,
+			Cluster:   lo.Ternary(srcIsSharded, ClusterTarget, ClusterSource),
+			Details:   Missing,
+			NameSpace: FullName(srcColl),
+		}}, nil
+	}
+
+	if bytes.Equal(srcKey, dstKey) {
+		return nil, nil
+	}
+
+	areEqual, err := util.ServerThinksTheseMatch(
+		ctx,
+		verifier.metaClient,
+		srcKey, dstKey,
+		option.None[mongo.Pipeline](),
+	)
+	if err != nil {
+		return nil, errors.Wrapf(
+			err,
+			"failed to ask server if shard keys (src %v; dst: %v) match",
+			srcKey,
+			dstKey,
+		)
+	}
+
+	if !areEqual {
+		return []VerificationResult{{
+			Field:     ShardKeyField,
+			Details:   fmt.Sprintf("%s: src=%v; dst=%v", Mismatch, srcKey, dstKey),
+			NameSpace: FullName(srcColl),
+		}}, nil
+	}
+
+	return nil, nil
+}