Remove unused ServerOption error. (#888)

Author: matthewdale

x/mongo/driver/topology/CMAP_spec_test.go

@@ -209,8 +209,7 @@ func runCMAPTest(t *testing.T, testFileName string) {
 		}))
 	}
 
-	s, err := NewServer(address.Address(l.Addr().String()), primitive.NewObjectID(), sOpts...)
-	testHelpers.RequireNil(t, err, "error creating server: %v", err)
+	s := NewServer(address.Address(l.Addr().String()), primitive.NewObjectID(), sOpts...)
 	s.state = serverConnected
 	testHelpers.RequireNil(t, err, "error connecting connection pool: %v", err)
 	defer s.pool.close(context.Background())

x/mongo/driver/topology/server.go

@@ -130,11 +130,8 @@ type updateTopologyCallback func(description.Server) description.Server
 // ConnectServer creates a new Server and then initializes it using the
 // Connect method.
 func ConnectServer(addr address.Address, updateCallback updateTopologyCallback, topologyID primitive.ObjectID, opts ...ServerOption) (*Server, error) {
-	srvr, err := NewServer(addr, topologyID, opts...)
-	if err != nil {
-		return nil, err
-	}
-	err = srvr.Connect(updateCallback)
+	srvr := NewServer(addr, topologyID, opts...)
+	err := srvr.Connect(updateCallback)
 	if err != nil {
 		return nil, err
 	}
@@ -143,12 +140,8 @@ func ConnectServer(addr address.Address, updateCallback updateTopologyCallback,
 
 // NewServer creates a new server. The mongodb server at the address will be monitored
 // on an internal monitoring goroutine.
-func NewServer(addr address.Address, topologyID primitive.ObjectID, opts ...ServerOption) (*Server, error) {
-	cfg, err := newServerConfig(opts...)
-	if err != nil {
-		return nil, err
-	}
-
+func NewServer(addr address.Address, topologyID primitive.ObjectID, opts ...ServerOption) *Server {
+	cfg := newServerConfig(opts...)
 	globalCtx, globalCtxCancel := context.WithCancel(context.Background())
 	s := &Server{
 		state: serverDisconnected,
@@ -190,7 +183,7 @@ func NewServer(addr address.Address, topologyID primitive.ObjectID, opts ...Serv
 	s.pool = newPool(pc, connectionOpts...)
 	s.publishServerOpeningEvent(s.address)
 
-	return s, nil
+	return s
 }
 
 // Connect initializes the Server by starting background monitoring goroutines.

x/mongo/driver/topology/server_options.go

@@ -40,7 +40,7 @@ type serverConfig struct {
 	poolMaintainInterval time.Duration
 }
 
-func newServerConfig(opts ...ServerOption) (*serverConfig, error) {
+func newServerConfig(opts ...ServerOption) *serverConfig {
 	cfg := &serverConfig{
 		heartbeatInterval: 10 * time.Second,
 		heartbeatTimeout:  10 * time.Second,
@@ -52,159 +52,139 @@ func newServerConfig(opts ...ServerOption) (*serverConfig, error) {
 		if opt == nil {
 			continue
 		}
-		err := opt(cfg)
-		if err != nil {
-			return nil, err
-		}
+		opt(cfg)
 	}
 
-	return cfg, nil
+	return cfg
 }
 
 // ServerOption configures a server.
-type ServerOption func(*serverConfig) error
+type ServerOption func(*serverConfig)
 
 func withMonitoringDisabled(fn func(bool) bool) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.monitoringDisabled = fn(cfg.monitoringDisabled)
-		return nil
 	}
 }
 
 // WithConnectionOptions configures the server's connections.
 func WithConnectionOptions(fn func(...ConnectionOption) []ConnectionOption) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.connectionOpts = fn(cfg.connectionOpts...)
-		return nil
 	}
 }
 
 // WithCompressionOptions configures the server's compressors.
 func WithCompressionOptions(fn func(...string) []string) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.compressionOpts = fn(cfg.compressionOpts...)
-		return nil
 	}
 }
 
 // WithServerAppName configures the server's application name.
 func WithServerAppName(fn func(string) string) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.appname = fn(cfg.appname)
-		return nil
 	}
 }
 
 // WithHeartbeatInterval configures a server's heartbeat interval.
 func WithHeartbeatInterval(fn func(time.Duration) time.Duration) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.heartbeatInterval = fn(cfg.heartbeatInterval)
-		return nil
 	}
 }
 
 // WithHeartbeatTimeout configures how long to wait for a heartbeat socket to
 // connection.
 func WithHeartbeatTimeout(fn func(time.Duration) time.Duration) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.heartbeatTimeout = fn(cfg.heartbeatTimeout)
-		return nil
 	}
 }
 
 // WithMaxConnections configures the maximum number of connections to allow for
 // a given server. If max is 0, then maximum connection pool size is not limited.
 func WithMaxConnections(fn func(uint64) uint64) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.maxConns = fn(cfg.maxConns)
-		return nil
 	}
 }
 
 // WithMinConnections configures the minimum number of connections to allow for
 // a given server. If min is 0, then there is no lower limit to the number of
 // connections.
 func WithMinConnections(fn func(uint64) uint64) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.minConns = fn(cfg.minConns)
-		return nil
 	}
 }
 
 // WithMaxConnecting configures the maximum number of connections a connection
 // pool may establish simultaneously. If maxConnecting is 0, the default value
 // of 2 is used.
 func WithMaxConnecting(fn func(uint64) uint64) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.maxConnecting = fn(cfg.maxConnecting)
-		return nil
 	}
 }
 
 // WithConnectionPoolMaxIdleTime configures the maximum time that a connection can remain idle in the connection pool
 // before being removed. If connectionPoolMaxIdleTime is 0, then no idle time is set and connections will not be removed
 // because of their age
 func WithConnectionPoolMaxIdleTime(fn func(time.Duration) time.Duration) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.poolMaxIdleTime = fn(cfg.poolMaxIdleTime)
-		return nil
 	}
 }
 
 // WithConnectionPoolMaintainInterval configures the interval that the background connection pool
 // maintenance goroutine runs.
 func WithConnectionPoolMaintainInterval(fn func(time.Duration) time.Duration) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.poolMaintainInterval = fn(cfg.poolMaintainInterval)
-		return nil
 	}
 }
 
 // WithConnectionPoolMonitor configures the monitor for all connection pool actions
 func WithConnectionPoolMonitor(fn func(*event.PoolMonitor) *event.PoolMonitor) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.poolMonitor = fn(cfg.poolMonitor)
-		return nil
 	}
 }
 
 // WithServerMonitor configures the monitor for all SDAM events for a server
 func WithServerMonitor(fn func(*event.ServerMonitor) *event.ServerMonitor) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.serverMonitor = fn(cfg.serverMonitor)
-		return nil
 	}
 }
 
 // WithClock configures the ClusterClock for the server to use.
 func WithClock(fn func(clock *session.ClusterClock) *session.ClusterClock) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.clock = fn(cfg.clock)
-		return nil
 	}
 }
 
 // WithRegistry configures the registry for the server to use when creating
 // cursors.
 func WithRegistry(fn func(*bsoncodec.Registry) *bsoncodec.Registry) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.registry = fn(cfg.registry)
-		return nil
 	}
 }
 
 // WithServerAPI configures the server API options for the server to use.
 func WithServerAPI(fn func(serverAPI *driver.ServerAPIOptions) *driver.ServerAPIOptions) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.serverAPI = fn(cfg.serverAPI)
-		return nil
 	}
 }
 
 // WithServerLoadBalanced specifies whether or not the server is behind a load balancer.
 func WithServerLoadBalanced(fn func(bool) bool) ServerOption {
-	return func(cfg *serverConfig) error {
+	return func(cfg *serverConfig) {
 		cfg.loadBalanced = fn(cfg.loadBalanced)
-		return nil
 	}
 }

x/mongo/driver/topology/server_test.go

@@ -146,7 +146,7 @@ func TestServerConnectionTimeout(t *testing.T) {
 			// event monitor to send events to the channel.
 			eventsCh := make(chan *event.PoolEvent, 100)
 
-			server, err := NewServer(
+			server := NewServer(
 				address.Address(l.Addr().String()),
 				primitive.NewObjectID(),
 				// Create a connection pool event monitor that sends all events to an events channel
@@ -176,7 +176,6 @@ func TestServerConnectionTimeout(t *testing.T) {
 				// heartbeats from unexpectedly clearing the connection pool.
 				withMonitoringDisabled(func(bool) bool { return true }),
 			)
-			require.NoError(t, err)
 			require.NoError(t, server.Connect(nil))
 
 			// Create a context with the operation timeout if one is specified in the test case.
@@ -246,7 +245,7 @@ func TestServer(t *testing.T) {
 	for _, tt := range serverTestTable {
 		t.Run(tt.name, func(t *testing.T) {
 			var returnConnectionError bool
-			s, err := NewServer(
+			s := NewServer(
 				address.Address("localhost"),
 				primitive.NewObjectID(),
 				WithConnectionOptions(func(connOpts ...ConnectionOption) []ConnectionOption {
@@ -274,15 +273,14 @@ func TestServer(t *testing.T) {
 					)
 				}),
 			)
-			require.NoError(t, err)
 
 			var desc *description.Server
 			descript := s.Description()
 			if tt.hasDesc {
 				desc = &descript
 				require.Nil(t, desc.LastError)
 			}
-			err = s.pool.ready()
+			err := s.pool.ready()
 			require.NoError(t, err, "pool.ready() error")
 			defer s.pool.close(context.Background())
 
@@ -463,17 +461,16 @@ func TestServer(t *testing.T) {
 			_ = nc.Close()
 		})
 		d := newdialer(&net.Dialer{})
-		s, err := NewServer(address.Address(addr.String()),
+		s := NewServer(address.Address(addr.String()),
 			primitive.NewObjectID(),
 			WithConnectionOptions(func(option ...ConnectionOption) []ConnectionOption {
 				return []ConnectionOption{WithDialer(func(_ Dialer) Dialer { return d })}
 			}),
 			WithMaxConnections(func(u uint64) uint64 {
 				return 1
 			}))
-		noerr(t, err)
 		s.state = serverConnected
-		err = s.pool.ready()
+		err := s.pool.ready()
 		noerr(t, err)
 		defer s.pool.close(context.Background())
 
@@ -603,11 +600,9 @@ func TestServer(t *testing.T) {
 
 		for _, tc := range testCases {
 			t.Run(tc.name, func(t *testing.T) {
-				server, err := NewServer(address.Address("localhost"), primitive.NewObjectID())
-				assert.Nil(t, err, "NewServer error: %v", err)
-
+				server := NewServer(address.Address("localhost"), primitive.NewObjectID())
 				server.state = serverConnected
-				err = server.pool.ready()
+				err := server.pool.ready()
 				assert.Nil(t, err, "pool.ready() error: %v", err)
 
 				originalDesc := description.Server{
@@ -678,13 +673,10 @@ func TestServer(t *testing.T) {
 			return append(connOpts, dialerOpt)
 		})
 
-		s, err := NewServer(address.Address("localhost:27017"), primitive.NewObjectID(), serverOpt)
-		if err != nil {
-			t.Fatalf("error from NewServer: %v", err)
-		}
+		s := NewServer(address.Address("localhost:27017"), primitive.NewObjectID(), serverOpt)
 
 		// do a heartbeat with a nil connection so a new one will be dialed
-		_, err = s.check()
+		_, err := s.check()
 		assert.Nil(t, err, "check error: %v", err)
 		assert.NotNil(t, s.conn, "no connection dialed in check")
 
@@ -745,13 +737,10 @@ func TestServer(t *testing.T) {
 			WithServerMonitor(func(*event.ServerMonitor) *event.ServerMonitor { return sdam }),
 		}
 
-		s, err := NewServer(address.Address("localhost:27017"), primitive.NewObjectID(), serverOpts...)
-		if err != nil {
-			t.Fatalf("error from NewServer: %v", err)
-		}
+		s := NewServer(address.Address("localhost:27017"), primitive.NewObjectID(), serverOpts...)
 
 		// set up heartbeat connection, which doesn't send events
-		_, err = s.check()
+		_, err := s.check()
 		assert.Nil(t, err, "check error: %v", err)
 
 		channelConn := s.conn.nc.(*drivertest.ChannelNetConn)
@@ -806,16 +795,15 @@ func TestServer(t *testing.T) {
 	t.Run("WithServerAppName", func(t *testing.T) {
 		name := "test"
 
-		s, err := NewServer(address.Address("localhost"),
+		s := NewServer(address.Address("localhost"),
 			primitive.NewObjectID(),
 			WithServerAppName(func(string) string { return name }))
-		require.Nil(t, err, "error from NewServer: %v", err)
 		require.Equal(t, name, s.cfg.appname, "expected appname to be: %v, got: %v", name, s.cfg.appname)
 	})
 	t.Run("createConnection overwrites WithSocketTimeout", func(t *testing.T) {
 		socketTimeout := 40 * time.Second
 
-		s, err := NewServer(
+		s := NewServer(
 			address.Address("localhost"),
 			primitive.NewObjectID(),
 			WithConnectionOptions(func(connOpts ...ConnectionOption) []ConnectionOption {
@@ -826,7 +814,6 @@ func TestServer(t *testing.T) {
 				)
 			}),
 		)
-		assert.Nil(t, err, "NewServer error: %v", err)
 
 		conn := s.createConnection()
 		assert.Equal(t, s.cfg.heartbeatTimeout, 10*time.Second, "expected heartbeatTimeout to be: %v, got: %v", 10*time.Second, s.cfg.heartbeatTimeout)

x/mongo/driver/topology/topology.go

@@ -556,7 +556,7 @@ func (t *Topology) selectServerFromDescription(desc description.Topology,
 func (t *Topology) pollSRVRecords() {
 	defer t.pollingwg.Done()
 
-	serverConfig, _ := newServerConfig(t.cfg.serverOpts...)
+	serverConfig := newServerConfig(t.cfg.serverOpts...)
 	heartbeatInterval := serverConfig.heartbeatInterval
 
 	pollTicker := time.NewTicker(t.rescanSRVInterval)