GODRIVER-1582 Add support for commitQuorum (#388)

Author: Divjot Arora

mongo/index_view.go

@@ -238,6 +238,14 @@ func (iv IndexView) CreateMany(ctx context.Context, models []IndexModel, opts ..
 	if option.MaxTime != nil {
 		op.MaxTimeMS(int64(*option.MaxTime / time.Millisecond))
 	}
+	if option.CommitQuorum != nil {
+		commitQuorum, err := transformValue(iv.coll.registry, option.CommitQuorum)
+		if err != nil {
+			return nil, err
+		}
+
+		op.CommitQuorum(commitQuorum)
+	}
 
 	err = op.Execute(ctx)
 	if err != nil {

mongo/integration/index_view_test.go

@@ -137,6 +137,55 @@ func TestIndexView(t *testing.T) {
 			})
 			assert.NotNil(mt, err, "expected CreateOne error, got nil")
 		})
+		// Only run on replica sets as commitQuorum is not supported on standalones.
+		mt.RunOpts("commit quorum", mtest.NewOptions().Topologies(mtest.ReplicaSet).CreateClient(false), func(mt *mtest.T) {
+			intVal := options.CreateIndexes().SetCommitQuorumInt(1)
+			stringVal := options.CreateIndexes().SetCommitQuorumString("majority")
+			majority := options.CreateIndexes().SetCommitQuorumMajority()
+			votingMembers := options.CreateIndexes().SetCommitQuorumVotingMembers()
+
+			indexModel := mongo.IndexModel{
+				Keys: bson.D{{"x", 1}},
+			}
+
+			testCases := []struct {
+				name             string
+				opts             *options.CreateIndexesOptions
+				expectError      bool
+				expectedValue    interface{} // ignored if expectError is true
+				minServerVersion string
+				maxServerVersion string
+			}{
+				{"error on server versions before 4.4", majority, true, nil, "", "4.2"},
+				{"integer value", intVal, false, int32(1), "4.4", ""},
+				{"string value", stringVal, false, "majority", "4.4", ""},
+				{"majority", majority, false, "majority", "4.4", ""},
+				{"votingMembers", votingMembers, false, "votingMembers", "4.4", ""},
+			}
+			for _, tc := range testCases {
+				mtOpts := mtest.NewOptions().MinServerVersion(tc.minServerVersion).MaxServerVersion(tc.maxServerVersion)
+				mt.RunOpts(tc.name, mtOpts, func(mt *mtest.T) {
+					mt.ClearEvents()
+					_, err := mt.Coll.Indexes().CreateOne(mtest.Background, indexModel, tc.opts)
+					if tc.expectError {
+						assert.NotNil(mt, err, "expected CreateOne error, got nil")
+						return
+					}
+
+					assert.Nil(mt, err, "CreateOne error: %v", err)
+					cmd := mt.GetStartedEvent().Command
+					sentBSONValue, err := cmd.LookupErr("commitQuorum")
+					assert.Nil(mt, err, "expected commitQuorum in command %s", cmd)
+
+					var sentValue interface{}
+					err = sentBSONValue.Unmarshal(&sentValue)
+					assert.Nil(mt, err, "Unmarshal error: %v", err)
+
+					assert.Equal(mt, tc.expectedValue, sentValue, "expected commitQuorum value %v, got %v",
+						tc.expectedValue, sentValue)
+				})
+			}
+		})
 	})
 	mt.Run("create many", func(mt *mtest.T) {
 		mt.Run("success", func(mt *mtest.T) {
@@ -162,31 +211,79 @@ func TestIndexView(t *testing.T) {
 			})
 		})
 		wc := writeconcern.New(writeconcern.W(1))
-		mt.RunOpts("uses writeconcern",
-			mtest.NewOptions().CollectionOptions(options.Collection().SetWriteConcern(wc)),
-			func(mt *mtest.T) {
-				iv := mt.Coll.Indexes()
-				_, err := iv.CreateMany(mtest.Background, []mongo.IndexModel{
-					{
-						Keys: bson.D{{"foo", -1}},
-					},
-					{
-						Keys: bson.D{{"bar", 1}, {"baz", -1}},
-					},
-				})
-				assert.Nil(mt, err, "CreateMany error: %v", err)
+		wcMtOpts := mtest.NewOptions().CollectionOptions(options.Collection().SetWriteConcern(wc))
+		mt.RunOpts("uses writeconcern", wcMtOpts, func(mt *mtest.T) {
+			iv := mt.Coll.Indexes()
+			_, err := iv.CreateMany(mtest.Background, []mongo.IndexModel{
+				{
+					Keys: bson.D{{"foo", -1}},
+				},
+				{
+					Keys: bson.D{{"bar", 1}, {"baz", -1}},
+				},
+			})
+			assert.Nil(mt, err, "CreateMany error: %v", err)
 
-				evt := mt.GetStartedEvent()
-				assert.NotNil(mt, evt, "expected CommandStartedEvent, got nil")
+			evt := mt.GetStartedEvent()
+			assert.NotNil(mt, evt, "expected CommandStartedEvent, got nil")
 
-				assert.Equal(mt, "createIndexes", evt.CommandName, "command name mismatch; expected createIndexes, got %s", evt.CommandName)
+			assert.Equal(mt, "createIndexes", evt.CommandName, "command name mismatch; expected createIndexes, got %s", evt.CommandName)
 
-				actual, err := evt.Command.LookupErr("writeConcern", "w")
-				assert.Nil(mt, err, "error getting writeConcern.w: %s", err)
+			actual, err := evt.Command.LookupErr("writeConcern", "w")
+			assert.Nil(mt, err, "error getting writeConcern.w: %s", err)
 
-				wcVal := numberFromValue(mt, actual)
-				assert.Equal(mt, int64(1), wcVal, "expected writeConcern to be 1, got: %v", wcVal)
-			})
+			wcVal := numberFromValue(mt, actual)
+			assert.Equal(mt, int64(1), wcVal, "expected writeConcern to be 1, got: %v", wcVal)
+		})
+		// Only run on replica sets as commitQuorum is not supported on standalones.
+		mt.RunOpts("commit quorum", mtest.NewOptions().Topologies(mtest.ReplicaSet).CreateClient(false), func(mt *mtest.T) {
+			intVal := options.CreateIndexes().SetCommitQuorumInt(1)
+			stringVal := options.CreateIndexes().SetCommitQuorumString("majority")
+			majority := options.CreateIndexes().SetCommitQuorumMajority()
+			votingMembers := options.CreateIndexes().SetCommitQuorumVotingMembers()
+
+			indexModel := mongo.IndexModel{
+				Keys: bson.D{{"x", 1}},
+			}
+
+			testCases := []struct {
+				name             string
+				opts             *options.CreateIndexesOptions
+				expectError      bool
+				expectedValue    interface{} // ignored if expectError is true
+				minServerVersion string
+				maxServerVersion string
+			}{
+				{"error on server versions before 4.4", majority, true, nil, "", "4.2"},
+				{"integer value", intVal, false, int32(1), "4.4", ""},
+				{"string value", stringVal, false, "majority", "4.4", ""},
+				{"majority", majority, false, "majority", "4.4", ""},
+				{"votingMembers", votingMembers, false, "votingMembers", "4.4", ""},
+			}
+			for _, tc := range testCases {
+				mtOpts := mtest.NewOptions().MinServerVersion(tc.minServerVersion).MaxServerVersion(tc.maxServerVersion)
+				mt.RunOpts(tc.name, mtOpts, func(mt *mtest.T) {
+					mt.ClearEvents()
+					_, err := mt.Coll.Indexes().CreateOne(mtest.Background, indexModel, tc.opts)
+					if tc.expectError {
+						assert.NotNil(mt, err, "expected CreateOne error, got nil")
+						return
+					}
+
+					assert.Nil(mt, err, "CreateOne error: %v", err)
+					cmd := mt.GetStartedEvent().Command
+					sentBSONValue, err := cmd.LookupErr("commitQuorum")
+					assert.Nil(mt, err, "expected commitQuorum in command %s", cmd)
+
+					var sentValue interface{}
+					err = sentBSONValue.Unmarshal(&sentValue)
+					assert.Nil(mt, err, "Unmarshal error: %v", err)
+
+					assert.Equal(mt, tc.expectedValue, sentValue, "expected commitQuorum value %v, got %v",
+						tc.expectedValue, sentValue)
+				})
+			}
+		})
 	})
 	mt.Run("drop one", func(mt *mtest.T) {
 		iv := mt.Coll.Indexes()

mongo/options/indexoptions.go

@@ -13,6 +13,20 @@ import (
 // CreateIndexesOptions represents options that can be used to configure IndexView.CreateOne and IndexView.CreateMany
 // operations.
 type CreateIndexesOptions struct {
+	// The number of data-bearing members of a replica set, including the primary, that must complete the index builds
+	// successfully before the primary marks the indexes as ready. This should either be a string or int32 value. The
+	// semantics of the values are as follows:
+	//
+	// 1. String: specifies a tag. All members with that tag must complete the build.
+	// 2. int: the number of members that must complete the build.
+	// 3. "majority": A special value to indicate that more than half the nodes must complete the build.
+	// 4. "votingMembers": A special value to indicate that all voting data-bearing nodes must complete.
+	//
+	// This option is only available on MongoDB versions >= 4.4. A client-side error will be returned if the option
+	// is specified for MongoDB versions <= 4.2. The default value is nil, meaning that the server-side default will be
+	// used. See dochub.mongodb.org/core/index-commit-quorum for more information.
+	CommitQuorum interface{}
+
 	// The maximum amount of time that the query can run on the server. The default value is nil, meaning that there
 	// is no time limit for query execution.
 	MaxTime *time.Duration
@@ -29,6 +43,30 @@ func (c *CreateIndexesOptions) SetMaxTime(d time.Duration) *CreateIndexesOptions
 	return c
 }
 
+// SetCommitQuorumInt sets the value for the CommitQuorum field as an int32.
+func (c *CreateIndexesOptions) SetCommitQuorumInt(quorum int32) *CreateIndexesOptions {
+	c.CommitQuorum = quorum
+	return c
+}
+
+// SetCommitQuorumString sets the value for the CommitQuorum field as a string.
+func (c *CreateIndexesOptions) SetCommitQuorumString(quorum string) *CreateIndexesOptions {
+	c.CommitQuorum = quorum
+	return c
+}
+
+// SetCommitQuorumMajority sets the value for the CommitQuorum to special "majority" value.
+func (c *CreateIndexesOptions) SetCommitQuorumMajority() *CreateIndexesOptions {
+	c.CommitQuorum = "majority"
+	return c
+}
+
+// SetCommitQuorumVotingMembers sets the value for the CommitQuorum to special "votingMembers" value.
+func (c *CreateIndexesOptions) SetCommitQuorumVotingMembers() *CreateIndexesOptions {
+	c.CommitQuorum = "votingMembers"
+	return c
+}
+
 // MergeCreateIndexesOptions combines the given CreateIndexesOptions into a single CreateIndexesOptions in a last one
 // wins fashion.
 func MergeCreateIndexesOptions(opts ...*CreateIndexesOptions) *CreateIndexesOptions {
@@ -40,6 +78,9 @@ func MergeCreateIndexesOptions(opts ...*CreateIndexesOptions) *CreateIndexesOpti
 		if opt.MaxTime != nil {
 			c.MaxTime = opt.MaxTime
 		}
+		if opt.CommitQuorum != nil {
+			c.CommitQuorum = opt.CommitQuorum
+		}
 	}
 
 	return c
@@ -129,8 +170,8 @@ func MergeListIndexesOptions(opts ...*ListIndexesOptions) *ListIndexesOptions {
 // IndexOptions represents options that can be used to configure a new index created through the IndexView.CreateOne
 // or IndexView.CreateMany operations.
 type IndexOptions struct {
-	// If true, the index will be built in the background on the server and will not block other tasks. The default
-	// value is false.
+	// If true, the index will be built in the background on the server and will not block other tasks. This option
+	// has been deprecated in MongoDB version 4.2. The default value is false.
 	Background *bool
 
 	// The length of time, in seconds, for documents to remain in the collection. The default value is 0, which means

x/mongo/driver/operation/createIndexes.go

@@ -18,6 +18,14 @@ documentation = "An array containing index specification documents for the index
 type = "int64"
 documentation = "MaxTimeMS specifies the maximum amount of time to allow the query to run."
 
+[request.commitQuorum]
+type = "value"
+minWireVersionRequired = 9
+documentation = """
+The number of data-bearing members of a replica set, including the primary, that must complete the index builds
+successfully before the primary marks the indexes as ready. This should either be a string or int32 value.
+"""
+
 [response]
 name = "CreateIndexesResult"