mongo 2.11.0 → 2.11.5

data/lib/mongo/auth/user.rb

@@ -151,6 +151,8 @@ module Mongo
       #   authorized for.
       # @option options [ String ] :user The user name.
       # @option options [ String ] :password The user's password.
+      # @option options [ String ] :pwd Legacy option for the user's password.
+      #   If :password and :pwd are both specified, :password takes precedence.
       # @option options [ Symbol ] :auth_mech The authorization mechanism.
       # @option options [ Array<String>, Array<Hash> ] roles The user roles.
       # @option options [ String ] :client_key The user's client key cached from a previous
@@ -196,7 +198,11 @@ module Mongo
       #
       # @since 2.0.0
       def spec
-        { pwd: password, roles: roles }
+        {roles: roles}.tap do |spec|
+          if password
+            spec[:pwd] = password
+          end
+        end
       end
 
       private

data/lib/mongo/auth/x509.rb

@@ -20,6 +20,7 @@ module Mongo
     # Defines behavior for X.509 authentication.
     #
     # @since 2.0.0
+    # @api private
     class X509
 
       # The authentication mechinism string.
@@ -67,7 +68,7 @@ module Mongo
         conversation = Conversation.new(user)
         reply = connection.dispatch([ conversation.start(connection) ])
         connection.update_cluster_time(Operation::Result.new(reply))
-        conversation.finalize(reply)
+        conversation.finalize(reply, connection)
       end
     end
   end

data/lib/mongo/auth/x509/conversation.rb

@@ -42,26 +42,26 @@ module Mongo
         #
         # @param [ Protocol::Message ] reply The reply of the previous
         #   message.
+        # @param [ Server::Connection ] connection The connection being
+        #   authenticated.
         #
         # @return [ Protocol::Query ] The next message to send.
         #
         # @since 2.0.0
-        def finalize(reply)
-          validate!(reply)
+        def finalize(reply, connection)
+          validate!(reply, connection.server)
         end
 
         # Start the X.509 conversation. This returns the first message that
         # needs to be sent to the server.
         #
-        # @example Start the conversation.
-        #   conversation.start
-        #
-        # @param [ Mongo::Server::Connection ] connection The connection being authenticated.
+        # @param [ Server::Connection ] connection The connection being
+        #   authenticated.
         #
         # @return [ Protocol::Query ] The first X.509 conversation message.
         #
         # @since 2.0.0
-        def start(connection = nil)
+        def start(connection)
           login = LOGIN.merge(mechanism: X509::MECHANISM)
           login[:user] = user.name if user.name
           if connection && connection.features.op_msg_enabled?
@@ -103,9 +103,9 @@ module Mongo
 
         private
 
-        def validate!(reply)
+        def validate!(reply, server)
           if reply.documents[0][Operation::Result::OK] != 1
-            raise Unauthorized.new(user, used_mechanism: MECHANISM)
+            raise Unauthorized.new(user, used_mechanism: MECHANISM, server: server)
           end
           @reply = reply
         end

data/lib/mongo/bulk_write/transformable.rb

@@ -92,7 +92,7 @@ module Mongo
           Operation::U => doc[:replacement],
         }.tap do |d|
           if doc[:upsert]
-            d[:upsert] = true
+            d['upsert'] = true
           end
           d[Operation::COLLATION] = doc[:collation] if doc[:collation]
         end
@@ -108,7 +108,7 @@ module Mongo
           Operation::MULTI => true,
         }.tap do |d|
           if doc[:upsert]
-            d[:upsert] = true
+            d['upsert'] = true
           end
           d[Operation::COLLATION] = doc[:collation] if doc[:collation]
           d[Operation::ARRAY_FILTERS] = doc[:array_filters] if doc[:array_filters]
@@ -124,7 +124,7 @@ module Mongo
           Operation::U => doc[:update],
         }.tap do |d|
           if doc[:upsert]
-            d[:upsert] = true
+            d['upsert'] = true
           end
           d[Operation::COLLATION] = doc[:collation] if doc[:collation]
           d[Operation::ARRAY_FILTERS] = doc[:array_filters] if doc[:array_filters]

data/lib/mongo/client.rb

@@ -756,8 +756,8 @@ module Mongo
     #
     # @since 2.5.0
     def start_session(options = {})
-      cluster.send(:get_session, self, options.merge(implicit: false)) ||
-        (raise Error::InvalidSession.new(Session::SESSIONS_NOT_SUPPORTED))
+      get_session(options.merge(implicit: false)) or
+        raise Error::InvalidSession.new(Session::SESSIONS_NOT_SUPPORTED)
     end
 
     # As of version 3.6 of the MongoDB server, a ``$changeStream`` pipeline stage is supported
@@ -827,14 +827,25 @@ module Mongo
     # The session is implicit unless options[:implicit] is given.
     # If deployment does not support session, returns nil.
     #
-    # @note This method will return nil if deployment has no data-bearing
-    #   servers at the time of the call.
+    # @return [ Session | nil ] Session object or nil if sessions are not
+    #   supported by the deployment.
     def get_session(options = {})
-      cluster.send(:get_session, self, options)
+      if options[:session]
+        return options[:session].validate!(self)
+      end
+
+      if cluster.sessions_supported?
+        Session.new(cluster.session_pool.checkout, self, { implicit: true }.merge(options))
+      end
     end
 
     def with_session(options = {}, &block)
-      cluster.send(:with_session, self, options, &block)
+      session = get_session(options)
+      yield(session)
+    ensure
+      if session && session.implicit?
+        session.end_session
+      end
     end
 
     def initialize_copy(original)

data/lib/mongo/cluster.rb

@@ -109,6 +109,8 @@ module Mongo
         options[:cleanup] = false
       end
 
+      seeds = seeds.uniq
+
       @servers = []
       @monitoring = monitoring
       @event_listeners = Event::Listeners.new
@@ -162,12 +164,9 @@ module Mongo
         return
       end
 
-      # Need to record start time prior to starting monitoring
-      start_time = Time.now
-
-      servers.each do |server|
-        server.start_monitoring
-      end
+      # Update instance variables prior to starting monitoring threads.
+      @connecting = false
+      @connected = true
 
       if options[:cleanup] != false
         @cursor_reaper = CursorReaper.new
@@ -182,8 +181,12 @@ module Mongo
         @periodic_executor.run!
       end
 
-      @connecting = false
-      @connected = true
+      # Need to record start time prior to starting monitoring
+      start_time = Time.now
+
+      servers.each do |server|
+        server.start_monitoring
+      end
 
       if options[:scan] != false
         server_selection_timeout = options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
@@ -743,30 +746,49 @@ module Mongo
     #   server.remove('127.0.0.1:27017')
     #
     # @param [ String ] host The host/port or socket address.
+    # @param [ true | false ] disconnect Whether to disconnect the servers
+    #   being removed. For internal driver use only.
+    #
+    # @return [ Array<Server> | true | false ] If disconnect is any value other
+    #   than false, including nil, returns whether any servers were removed.
+    #   If disconnect is false, returns an array of servers that were removed
+    #   (and should be disconnected by the caller).
     #
-    # @return [ true|false ] Whether any servers were removed.
+    # @note The return value of this method is not part of the driver's
+    #   public API.
     #
-    # @since 2.0.0, return value added in 2.7.0
-    def remove(host)
+    # @since 2.0.0
+    def remove(host, disconnect: true)
       address = Address.new(host)
       removed_servers = @servers.select { |s| s.address == address }
       @update_lock.synchronize { @servers = @servers - removed_servers }
-      removed_servers.each do |server|
-        if server.connected?
-          server.disconnect!
-          publish_sdam_event(
-            Monitoring::SERVER_CLOSED,
-            Monitoring::Event::ServerClosed.new(address, topology)
-          )
+      if disconnect != false
+        removed_servers.each do |server|
+          disconnect_server_if_connected(server)
         end
       end
-      removed_servers.any?
+      if disconnect != false
+        removed_servers.any?
+      else
+        removed_servers
+      end
     end
 
     # @api private
     def update_topology(new_topology)
       old_topology = topology
       @topology = new_topology
+
+      # If new topology has data bearing servers, we know for sure whether
+      # sessions are supported - update our cached value.
+      # If new topology has no data bearing servers, leave the old value
+      # as it is and sessions_supported? method will perform server selection
+      # to try to determine session support accurately, falling back to the
+      # last known value.
+      if topology.data_bearing_servers?
+        @sessions_supported = !!topology.logical_session_timeout
+      end
+
       publish_sdam_event(
         Monitoring::TOPOLOGY_CHANGED,
         Monitoring::Event::TopologyChanged.new(old_topology, topology)
@@ -778,53 +800,49 @@ module Mongo
       @update_lock.synchronize { @servers.dup }
     end
 
-    private
-
-    # If options[:session] is set, validates that session and returns it.
-    # If deployment supports sessions, creates a new session and returns it.
-    # The session is implicit unless options[:implicit] is given.
-    # If deployment does not support session, returns nil.
-    #
-    # @note This method will return nil if deployment has no data-bearing
-    #   servers at the time of the call.
-    def get_session(client, options = {})
-      return options[:session].validate!(self) if options[:session]
-      if sessions_supported?
-        Session.new(@session_pool.checkout, client, { implicit: true }.merge(options))
+    # @api private
+    def disconnect_server_if_connected(server)
+      if server.connected?
+        server.disconnect!
+        publish_sdam_event(
+          Monitoring::SERVER_CLOSED,
+          Monitoring::Event::ServerClosed.new(server.address, topology)
+        )
       end
     end
 
-    def with_session(client, options = {})
-      session = get_session(client, options)
-      yield(session)
-    ensure
-      session.end_session if (session && session.implicit?)
-    end
-
-    # Returns whether the deployment (as this term is defined in the sessions
-    # spec) supports sessions.
+    # Returns whether the deployment that the driver is connected to supports
+    # sessions.
     #
-    # @note If the cluster has no data bearing servers, for example because
-    #   the deployment is in the middle of a failover, this method returns
-    #   false.
+    # Session support may change over time, for example due to servers in the
+    # deployment being upgraded or downgraded. This method returns the
+    # current information if the client is connected to at least one data
+    # bearing server. If the client is currently not connected to any data
+    # bearing servers, this method returns the last known value for whether
+    # the deployment supports sessions.
     #
-    # @note This method returns as soon as the driver connects to any single
-    #   server in the deployment. Whether deployment overall supports sessions
-    #   can change depending on how many servers have been contacted, if
-    #   the servers are configured differently.
+    # @return [ true | false ] Whether deployment supports sessions.
+    # @api private
     def sessions_supported?
       if topology.data_bearing_servers?
         return !!topology.logical_session_timeout
       end
 
+      # No data bearing servers known - perform server selection to try to
+      # get a response from at least one of them, to return an accurate
+      # assessment of whether sessions are currently supported.
       begin
         ServerSelector.get(mode: :primary_preferred).select_server(self)
         !!topology.logical_session_timeout
       rescue Error::NoServerAvailable
-        false
+        # We haven't been able to contact any servers - use last known
+        # value for esssion support.
+        @sessions_supported || false
       end
     end
 
+    private
+
     # @api private
     def start_stop_srv_monitor
       # SRV URI is either always given or not for a given cluster, if one

data/lib/mongo/cluster/sdam_flow.rb

@@ -30,6 +30,7 @@ class Mongo::Cluster
       @topology = cluster.topology
       @original_desc = @previous_desc = previous_desc
       @updated_desc = updated_desc
+      @servers_to_disconnect = []
     end
 
     attr_reader :cluster
@@ -73,6 +74,60 @@ class Mongo::Cluster
     end
 
     def server_description_changed
+      if updated_desc.me_mismatch? && updated_desc.primary? &&
+        (topology.unknown? || topology.replica_set?)
+      then
+        # When the driver receives a description claiming to be a primary,
+        # we are obligated by spec tests to add and remove hosts in that
+        # description even if it also has a me mismatch. The me mismatch
+        # scenario though presents a number of problems:
+        #
+        # 1. Effectively, the server's address changes, meaning we cannot
+        # update the description of the server whose description change we
+        # are processing (instead servers are added and removed), but we
+        # behave to an extent as if we are updating the description, which
+        # causes a bunch of awkwardness.
+        # 2. The server for which we are processing the response will be
+        # removed from topology, which may cause the current thread to terminate
+        # prior to running the entire sdam flow. To deal with this we separate
+        # the removal event publication from actually removing the server
+        # from topology, which again complicates the flow.
+
+        # Primary-with-me-mismatch response could be the first one we receive
+        # when the topology is still unknown. Change to RS without primary
+        # in this case.
+        if topology.unknown?
+          @topology = Topology::ReplicaSetNoPrimary.new(
+            topology.options.merge(replica_set_name: updated_desc.replica_set_name),
+            topology.monitoring, self)
+        end
+
+        servers = add_servers_from_desc(updated_desc)
+        # Spec tests require us to remove servers based on data in descrptions
+        # with me mismatches. The driver will be more resilient if it only
+        # removed servers from descriptions with matching mes.
+        remove_servers_not_in_desc(updated_desc)
+
+        servers.each do |server|
+          server.start_monitoring
+        end
+
+        # The rest of sdam flow assumes the server being removed is not the one
+        # whose description we are processing, and publishes description update
+        # event. Since we are removing the server whose response we are
+        # processing, do not publish description change event but mark it
+        # published (by assigning to @previous_desc).
+        do_remove(updated_desc.address.to_s)
+        @previous_desc = updated_desc
+
+        # We may have removed the current primary, check if there is a primary.
+        check_if_has_primary
+        # Publish topology change event.
+        commit_changes
+        disconnect_servers
+        return
+      end
+
       unless update_server_descriptions
         # All of the transitions require that server whose updated_desc we are
         # processing is still in the cluster (i.e., was not removed as a result
@@ -142,6 +197,7 @@ class Mongo::Cluster
       end
 
       commit_changes
+      disconnect_servers
     end
 
     # Transitions from unknown to single topology type, when a standalone
@@ -337,9 +393,14 @@ class Mongo::Cluster
       end.flatten
       servers_list.each do |server|
         unless updated_desc_address_strs.include?(address_str = server.address.to_s)
+          updated_host = updated_desc.address.to_s
+          if updated_desc.me && updated_desc.me != updated_host
+            updated_host += " (self-identified as #{updated_desc.me})"
+          end
           log_warn(
             "Removing server #{address_str} because it is not in hosts reported by primary " +
-            "#{updated_desc.address}"
+            "#{updated_host}. Reported hosts are: " +
+            updated_desc.hosts.join(', ')
           )
           do_remove(address_str)
         end
@@ -356,7 +417,21 @@ class Mongo::Cluster
     # Removes specified server from topology and warns if the topology ends
     # up with an empty server list as a result
     def do_remove(address_str)
-      cluster.remove(address_str)
+      servers = cluster.remove(address_str, disconnect: false)
+      servers.each do |server|
+        # We need to publish server closed event here, but we cannot close
+        # the server because it could be the server owning the monitor in
+        # whose thread this flow is presently executing, in which case closing
+        # the server can terminate the thread and leave SDAM processing
+        # incomplete. Thus we have to remove the server from the cluster,
+        # publish the event, but do not call disconnect on the server until
+        # the very end when all processing has completed.
+        publish_sdam_event(
+          Mongo::Monitoring::SERVER_CLOSED,
+          Mongo::Monitoring::Event::ServerClosed.new(server.address, cluster.topology)
+        )
+      end
+      @servers_to_disconnect += servers
       if servers_list.empty?
         log_warn(
           "Topology now has no servers - this is likely a misconfiguration of the cluster and/or the application"
@@ -451,6 +526,15 @@ class Mongo::Cluster
       cluster.update_topology(topology)
     end
 
+    def disconnect_servers
+      while server = @servers_to_disconnect.shift
+        if server.connected?
+          # Do not publish server closed event, as this was already done
+          server.disconnect!
+        end
+      end
+    end
+
     # If the server being processed is identified as data bearing, creates the
     # server's connection pool so it can start populating
     def start_pool_if_data_bearing
@@ -468,7 +552,7 @@ class Mongo::Cluster
     # invoking this method.
     def check_if_has_primary
       unless topology.replica_set?
-        raise ArgumentError, 'check_if_has_primary should only be called when topology is replica set'
+        raise ArgumentError, "check_if_has_primary should only be called when topology is replica set, but it is #{topology.class.name.sub(/.*::/, '')}"
       end
 
       primary = servers_list.detect do |server|