mongo 2.11.1 → 2.11.2

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

@@ -162,12 +162,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 +179,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 +744,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 +798,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|

data/lib/mongo/database.rb

@@ -157,7 +157,7 @@ module Mongo
     # @option opts :read [ Hash ] The read preference for this command.
     # @option opts :session [ Session ] The session to use for this command.
     #
-    # @return [ Hash ] The result of the command execution.
+    # @return [ Mongo::Operation::Result ] The result of the command execution.
     def command(operation, opts = {})
       txn_read_pref = if opts[:session] && opts[:session].in_transaction?
         opts[:session].txn_read_preference

data/lib/mongo/server.rb

@@ -306,12 +306,11 @@ module Mongo
       "#<Mongo::Server:0x#{object_id} address=#{address.host}:#{address.port}>"
     end
 
-    # @note This method is experimental and subject to change.
+    # @return [ String ] String representing server status (e.g. PRIMARY).
     #
-    # @api experimental
-    # @since 2.7.0
-    def summary
-      status = case
+    # @api private
+    def status
+      case
       when primary?
         'PRIMARY'
       when secondary?
@@ -331,8 +330,16 @@ module Mongo
       else
         # Since the summary method is often used for debugging, do not raise
         # an exception in case none of the expected types matched
-        ''
+        nil
       end
+    end
+
+    # @note This method is experimental and subject to change.
+    #
+    # @api experimental
+    # @since 2.7.0
+    def summary
+      status = self.status || ''
       if replica_set_name
         status += " replica_set=#{replica_set_name}"
       end

data/lib/mongo/server/connection.rb

@@ -103,6 +103,12 @@ module Mongo
         )
       end
 
+      # @return [ Server::Description ] The server description obtained from
+      #   the handshake on this connection.
+      #
+      # @api private
+      attr_reader :description
+
       # @return [ Time ] The last time the connection was checked back into a pool.
       #
       # @since 2.5.0
@@ -186,8 +192,10 @@ module Mongo
 
         begin
           handshake!(socket)
-          pending_connection = PendingConnection.new(socket, @server, monitoring, options.merge(id: id))
-          authenticate!(pending_connection)
+          unless description.arbiter?
+            pending_connection = PendingConnection.new(socket, @server, monitoring, options.merge(id: id))
+            authenticate!(pending_connection)
+          end
         rescue Exception
           socket.close
           raise
@@ -356,8 +364,8 @@ module Mongo
           @auth_mechanism = nil
         end
 
-        new_description = Description.new(address, response, average_rtt)
-        @server.cluster.run_sdam_flow(@server.description, new_description)
+        @description = Description.new(address, response, average_rtt)
+        @server.cluster.run_sdam_flow(@server.description, @description)
       end
 
       def authenticate!(pending_connection)

data/lib/mongo/server/connection_base.rb

@@ -29,12 +29,15 @@ module Mongo
       # @return [ Hash ] options The passed in options.
       attr_reader :options
 
+      # @return [ Server ] The server that this connection is for.
+      #
+      # @api private
+      attr_reader :server
+
       # @return [ Mongo::Address ] address The address to connect to.
-      def address
-        @server.address
-      end
+      def_delegators :server, :address
 
-      def_delegators :@server,
+      def_delegators :server,
                      :features,
                      :max_bson_object_size,
                      :max_message_size,