GODRIVER-211 revise connection pooling options on client/connstring

Change-Id: Ic9b1f10ef3646e535a19a20a53decc0444fe1fe1

Author: Isabella Siu

internal/testutil/helpers/helpers.go

@@ -108,14 +108,9 @@ func VerifyConnStringOptions(t *testing.T, cs connstring.ConnString, options map
 			require.Equal(t, value, cs.J)
 		case "maxidletimems":
 			require.Equal(t, value, cs.MaxConnIdleTime)
-		case "maxconnlifetimems":
-			require.Equal(t, value, cs.MaxConnLifeTime)
-		case "maxconnsperhost":
-			require.True(t, cs.MaxIdleConnsPerHostSet)
-			require.Equal(t, value, cs.MaxIdleConnsPerHost)
-		case "maxidleconnsperhost":
-			require.True(t, cs.MaxIdleConnsPerHostSet)
-			require.Equal(t, value, cs.MaxIdleConnsPerHost)
+		case "maxpoolsize":
+			require.True(t, cs.MaxPoolSizeSet)
+			require.Equal(t, value, cs.MaxPoolSize)
 		case "readpreference":
 			require.Equal(t, value, cs.ReadPreference)
 		case "readpreferencetags":

mongo/client_options_test.go

@@ -98,8 +98,8 @@ func TestClientOptions_chainAll(t *testing.T) {
 	}).SetConnectTimeout(500 * time.Millisecond).SetHeartbeatInterval(15 * time.Second).SetHosts([]string{
 		"mongodb://localhost:27018",
 		"mongodb://localhost:27019",
-	}).SetLocalThreshold(time.Second).SetMaxConnIdleTime(30 * time.Second).SetMaxConnsPerHost(150).
-		SetMaxIdleConnsPerHost(20).SetReadConcern(rc).SetReadPreference(rp).SetReplicaSet("foo").
+	}).SetLocalThreshold(time.Second).SetMaxConnIdleTime(30 * time.Second).SetMaxPoolSize(150).
+		SetReadConcern(rc).SetReadPreference(rp).SetReplicaSet("foo").
 		SetRetryWrites(retryWrites).SetServerSelectionTimeout(time.Second).
 		SetSingle(false).SetSocketTimeout(2 * time.Second).SetSSL(&options.SSLOpt{
 		Enabled:                      true,
@@ -130,10 +130,8 @@ func TestClientOptions_chainAll(t *testing.T) {
 			LocalThreshold:                     time.Second,
 			MaxConnIdleTime:                    30 * time.Second,
 			MaxConnIdleTimeSet:                 true,
-			MaxConnsPerHost:                    150,
-			MaxConnsPerHostSet:                 true,
-			MaxIdleConnsPerHost:                20,
-			MaxIdleConnsPerHostSet:             true,
+			MaxPoolSize:                        150,
+			MaxPoolSizeSet:                     true,
 			ReplicaSet:                         "foo",
 			ServerSelectionTimeoutSet:          true,
 			ServerSelectionTimeout:             time.Second,

mongo/options/clientoptions.go

@@ -194,19 +194,10 @@ func (c *ClientOptions) SetMaxConnIdleTime(d time.Duration) *ClientOptions {
 	return c
 }
 
-// SetMaxConnsPerHost specifies the max size of a server's connection pool.
-func (c *ClientOptions) SetMaxConnsPerHost(u uint16) *ClientOptions {
-	c.ConnString.MaxConnsPerHost = u
-	c.ConnString.MaxConnsPerHostSet = true
-
-	return c
-}
-
-// SetMaxIdleConnsPerHost specifies the number of connections in a server's connection pool that can
-// be idle at any given time.
-func (c *ClientOptions) SetMaxIdleConnsPerHost(u uint16) *ClientOptions {
-	c.ConnString.MaxIdleConnsPerHost = u
-	c.ConnString.MaxIdleConnsPerHostSet = true
+// SetMaxPoolSize specifies the max size of a server's connection pool.
+func (c *ClientOptions) SetMaxPoolSize(u uint16) *ClientOptions {
+	c.ConnString.MaxPoolSize = u
+	c.ConnString.MaxPoolSizeSet = true
 
 	return c
 }
@@ -353,13 +344,9 @@ func MergeClientOptions(cs connstring.ConnString, opts ...*ClientOptions) *Clien
 			c.ConnString.MaxConnIdleTimeSet = true
 			c.ConnString.MaxConnIdleTime = opt.ConnString.MaxConnIdleTime
 		}
-		if opt.ConnString.MaxConnsPerHostSet {
-			c.ConnString.MaxConnsPerHostSet = true
-			c.ConnString.MaxConnsPerHost = opt.ConnString.MaxConnsPerHost
-		}
-		if opt.ConnString.MaxIdleConnsPerHostSet {
-			c.ConnString.MaxIdleConnsPerHostSet = true
-			c.ConnString.MaxIdleConnsPerHost = opt.ConnString.MaxIdleConnsPerHost
+		if opt.ConnString.MaxPoolSizeSet {
+			c.ConnString.MaxPoolSizeSet = true
+			c.ConnString.MaxPoolSize = opt.ConnString.MaxPoolSize
 		}
 		if opt.ReadConcern != nil {
 			c.ReadConcern = opt.ReadConcern

x/mongo/driver/topology/topology_options.go

@@ -89,16 +89,9 @@ func WithConnString(fn func(connstring.ConnString) connstring.ConnString) Option
 			connOpts = append(connOpts, connection.WithIdleTimeout(func(time.Duration) time.Duration { return cs.MaxConnIdleTime }))
 		}
 
-		if cs.MaxConnLifeTime > 0 {
-			connOpts = append(connOpts, connection.WithIdleTimeout(func(time.Duration) time.Duration { return cs.MaxConnLifeTime }))
-		}
-
-		if cs.MaxConnsPerHostSet {
-			c.serverOpts = append(c.serverOpts, WithMaxConnections(func(uint16) uint16 { return cs.MaxConnsPerHost }))
-		}
-
-		if cs.MaxIdleConnsPerHostSet {
-			c.serverOpts = append(c.serverOpts, WithMaxIdleConnections(func(uint16) uint16 { return cs.MaxIdleConnsPerHost }))
+		if cs.MaxPoolSizeSet {
+			c.serverOpts = append(c.serverOpts, WithMaxConnections(func(uint16) uint16 { return cs.MaxPoolSize }))
+			c.serverOpts = append(c.serverOpts, WithMaxIdleConnections(func(uint16) uint16 { return cs.MaxPoolSize }))
 		}
 
 		if cs.ReplicaSet != "" {

x/network/connstring/connstring.go

@@ -53,11 +53,8 @@ type ConnString struct {
 	LocalThresholdSet                  bool
 	MaxConnIdleTime                    time.Duration
 	MaxConnIdleTimeSet                 bool
-	MaxConnLifeTime                    time.Duration
-	MaxConnsPerHost                    uint16
-	MaxConnsPerHostSet                 bool
-	MaxIdleConnsPerHost                uint16
-	MaxIdleConnsPerHostSet             bool
+	MaxPoolSize                        uint16
+	MaxPoolSizeSet                     bool
 	Password                           string
 	PasswordSet                        bool
 	ReadConcernLevel                   string
@@ -529,42 +526,20 @@ func (p *parser) addOption(pair string) error {
 		}
 		p.LocalThreshold = time.Duration(n) * time.Millisecond
 		p.LocalThresholdSet = true
-	case "maxconnsperhost":
-		n, err := strconv.Atoi(value)
-		if err != nil || n < 0 {
-			return fmt.Errorf("invalid value for %s: %s", key, value)
-		}
-		p.MaxConnsPerHost = uint16(n)
-		p.MaxConnsPerHostSet = true
-	case "maxidleconnsperhost":
-		n, err := strconv.Atoi(value)
-		if err != nil || n < 0 {
-			return fmt.Errorf("invalid value for %s: %s", key, value)
-		}
-		p.MaxIdleConnsPerHost = uint16(n)
-		p.MaxIdleConnsPerHostSet = true
 	case "maxidletimems":
 		n, err := strconv.Atoi(value)
 		if err != nil || n < 0 {
 			return fmt.Errorf("invalid value for %s: %s", key, value)
 		}
 		p.MaxConnIdleTime = time.Duration(n) * time.Millisecond
 		p.MaxConnIdleTimeSet = true
-	case "maxlifetimems":
-		n, err := strconv.Atoi(value)
-		if err != nil || n < 0 {
-			return fmt.Errorf("invalid value for %s: %s", key, value)
-		}
-		p.MaxConnLifeTime = time.Duration(n) * time.Millisecond
 	case "maxpoolsize":
 		n, err := strconv.Atoi(value)
 		if err != nil || n < 0 {
 			return fmt.Errorf("invalid value for %s: %s", key, value)
 		}
-		p.MaxConnsPerHost = uint16(n)
-		p.MaxConnsPerHostSet = true
-		p.MaxIdleConnsPerHost = uint16(n)
-		p.MaxIdleConnsPerHostSet = true
+		p.MaxPoolSize = uint16(n)
+		p.MaxPoolSizeSet = true
 	case "readconcernlevel":
 		p.ReadConcernLevel = value
 	case "readpreference":

x/network/connstring/connstring_spec_test.go

@@ -138,11 +138,8 @@ func runTest(t *testing.T, filename string, test *testCase) {
 		// for options that are present.
 		var ok bool
 
-		_, ok = test.Options["maxconnsperhost"]
-		require.Equal(t, ok, cs.MaxConnsPerHostSet)
-
-		_, ok = test.Options["maxidleconnsperhost"]
-		require.Equal(t, ok, cs.MaxIdleConnsPerHostSet)
+		_, ok = test.Options["maxpoolsize"]
+		require.Equal(t, ok, cs.MaxPoolSizeSet)
 
 		require.Equal(t, test.Auth != nil && test.Auth.Password != nil, cs.PasswordSet)
 	})

x/network/connstring/connstring_test.go

@@ -225,86 +225,6 @@ func TestMaxConnIdleTime(t *testing.T) {
 	}
 }
 
-func TestMaxConnLifeTime(t *testing.T) {
-	tests := []struct {
-		s        string
-		expected time.Duration
-		err      bool
-	}{
-		{s: "maxLifeTimeMS=10", expected: time.Duration(10) * time.Millisecond},
-		{s: "maxLifeTimeMS=100", expected: time.Duration(100) * time.Millisecond},
-		{s: "maxLifeTimeMS=-2", err: true},
-		{s: "maxLifeTimeMS=gsdge", err: true},
-	}
-
-	for _, test := range tests {
-		s := fmt.Sprintf("mongodb://localhost/?%s", test.s)
-		t.Run(s, func(t *testing.T) {
-			cs, err := connstring.Parse(s)
-			if test.err {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				require.Equal(t, test.expected, cs.MaxConnLifeTime)
-			}
-		})
-	}
-}
-
-func TestMaxConnsPerHost(t *testing.T) {
-	tests := []struct {
-		s        string
-		expected uint16
-		err      bool
-	}{
-		{s: "maxConnsPerHost=10", expected: 10},
-		{s: "maxConnsPerHost=100", expected: 100},
-		{s: "maxConnsPerHost=-2", err: true},
-		{s: "maxConnsPerHost=gsdge", err: true},
-	}
-
-	for _, test := range tests {
-		s := fmt.Sprintf("mongodb://localhost/?%s", test.s)
-		t.Run(s, func(t *testing.T) {
-			cs, err := connstring.Parse(s)
-			if test.err {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				require.True(t, cs.MaxConnsPerHostSet)
-				require.Equal(t, test.expected, cs.MaxConnsPerHost)
-			}
-		})
-	}
-}
-
-func TestMaxIdleConnsPerHost(t *testing.T) {
-	tests := []struct {
-		s        string
-		expected uint16
-		err      bool
-	}{
-		{s: "maxIdleConnsPerHost=10", expected: 10},
-		{s: "maxIdleConnsPerHost=100", expected: 100},
-		{s: "maxIdleConnsPerHost=-2", err: true},
-		{s: "maxIdleConnsPerHost=gsdge", err: true},
-	}
-
-	for _, test := range tests {
-		s := fmt.Sprintf("mongodb://localhost/?%s", test.s)
-		t.Run(s, func(t *testing.T) {
-			cs, err := connstring.Parse(s)
-			if test.err {
-				require.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				require.True(t, cs.MaxIdleConnsPerHostSet)
-				require.Equal(t, test.expected, cs.MaxIdleConnsPerHost)
-			}
-		})
-	}
-}
-
 func TestMaxPoolSize(t *testing.T) {
 	tests := []struct {
 		s        string
@@ -325,10 +245,8 @@ func TestMaxPoolSize(t *testing.T) {
 				require.Error(t, err)
 			} else {
 				require.NoError(t, err)
-				require.True(t, cs.MaxConnsPerHostSet)
-				require.Equal(t, test.expected, cs.MaxConnsPerHost)
-				require.True(t, cs.MaxIdleConnsPerHostSet)
-				require.Equal(t, test.expected, cs.MaxIdleConnsPerHost)
+				require.True(t, cs.MaxPoolSizeSet)
+				require.Equal(t, test.expected, cs.MaxPoolSize)
 			}
 		})
 	}