mongo 2.10.5 → 2.11.0.rc0

data/lib/mongo/operation/shared/executable.rb

@@ -66,20 +66,15 @@ module Mongo
 
         if result.not_master? || result.node_recovering?
           if result.node_shutting_down?
-            disconnect_pool = true
+            keep_pool = false
           else
-            # Max wire version needs to be checked prior to marking the
-            # server unknown
-            disconnect_pool = !server.description.server_version_gte?('4.2')
+            # Max wire version needs to be examined while the server is known
+            keep_pool = server.description.server_version_gte?('4.2')
           end
 
-          server.unknown!
+          server.unknown!(keep_connection_pool: keep_pool)
 
-          if disconnect_pool
-            server.pool.disconnect!
-          end
-
-          server.monitor.scan_semaphore.signal
+          server.scan_semaphore.signal
         end
 
         session.process(result) if session

data/lib/mongo/operation/shared/sessions_supported.rb

@@ -95,10 +95,6 @@ module Mongo
         session.add_autocommit!(selector)
       end
 
-      def apply_session_id!(selector)
-        session.add_id!(selector)
-      end
-
       def apply_start_transaction!(selector)
         session.add_start_transaction!(selector)
       end
@@ -146,7 +142,7 @@ module Mongo
       def apply_session_options(sel, server)
         apply_cluster_time!(sel, server)
         sel[:txnNumber] = BSON::Int64.new(txn_num) if txn_num
-        apply_session_id!(sel)
+        sel.merge!(lsid: session.session_id)
         apply_start_transaction!(sel)
         apply_causal_consistency!(sel, server)
         apply_autocommit!(sel)

data/lib/mongo/protocol/get_more.rb

@@ -110,7 +110,6 @@ module Mongo
         # The get more constant.
         #
         # @since 2.2.0
-        # @deprecated
         GET_MORE = 'getMore'.freeze
 
         # @return [ String ] collection The name of the collection.
@@ -149,7 +148,7 @@ module Mongo
         # @since 2.1.0
         def command
           document = BSON::Document.new
-          document.store('getMore', BSON::Int64.new(cursor_id))
+          document.store(GET_MORE, cursor_id)
           document.store(Message::BATCH_SIZE, number_to_return)
           document.store(Message::COLLECTION, collection)
           document

data/lib/mongo/protocol/kill_cursors.rb

@@ -52,7 +52,7 @@ module Mongo
           command_name: 'killCursors',
           database_name: @database,
           command: upconverter.command,
-          request_id: request_id,
+          request_id: request_id
         )
       end
 
@@ -85,6 +85,16 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # The kill cursors constant.
+        #
+        # @since 2.2.0
+        KILL_CURSORS = 'killCursors'.freeze
+
+        # The cursors constant.
+        #
+        # @since 2.2.0
+        CURSORS = 'cursors'.freeze
+
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
 
@@ -115,11 +125,8 @@ module Mongo
         # @since 2.1.0
         def command
           document = BSON::Document.new
-          document.store('killCursors', collection)
-          store_ids = cursor_ids.map do |cursor_id|
-            BSON::Int64.new(cursor_id)
-          end
-          document.store('cursors', store_ids)
+          document.store(KILL_CURSORS, collection)
+          document.store(CURSORS, cursor_ids)
           document
         end
       end

data/lib/mongo/protocol/serializers.rb

@@ -102,21 +102,13 @@ module Mongo
       # Serializes and de-serializes one 32-bit integer.
       module Int32
 
-        # Serializes a number to a 32-bit integer
+        # Serializes a fixnum to a 4-byte 32-bit integer
         #
         # @param buffer [ String ] Buffer to receive the serialized Int32.
-        # @param value [ Integer | BSON::Int32 ] 32-bit integer to be serialized.
+        # @param value [ Fixnum ] 32-bit integer to be serialized.
         #
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
-          if value.is_a?(BSON::Int32)
-            if value.respond_to?(:value)
-              # bson-ruby >= 4.6.0
-              value = value.value
-            else
-              value = value.instance_variable_get('@integer')
-            end
-          end
           buffer.put_int32(value)
         end
 
@@ -135,21 +127,13 @@ module Mongo
       # Serializes and de-serializes one 64-bit integer.
       module Int64
 
-        # Serializes a number to a 64-bit integer
+        # Serializes a fixnum to an 8-byte 64-bit integer
         #
         # @param buffer [ String ] Buffer to receive the serialized Int64.
-        # @param value [ Integer | BSON::Int64 ] 64-bit integer to be serialized.
+        # @param value [ Fixnum ] 64-bit integer to be serialized.
         #
         # @return [ String ] Buffer with serialized value.
         def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
-          if value.is_a?(BSON::Int64)
-            if value.respond_to?(:value)
-              # bson-ruby >= 4.6.0
-              value = value.value
-            else
-              value = value.instance_variable_get('@integer')
-            end
-          end
           buffer.put_int64(value)
         end
 

data/lib/mongo/retryable.rb

@@ -119,12 +119,7 @@ module Mongo
         legacy_read_with_retry(session, server_selector, &block)
       else
         server = select_server(cluster, server_selector, session)
-        begin
-          yield server
-        rescue Error::SocketError, Error::SocketTimeoutError, Error::OperationFailure => e
-          e.add_note('retries disabled')
-          raise e
-        end
+        yield server
       end
     end
 
@@ -219,14 +214,12 @@ module Mongo
       begin
         yield(server, txn_num, false)
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('modern retry')
         e.add_note("attempt 1")
         if session.in_transaction? && !ending_transaction
           raise e
         end
         retry_write(e, session, txn_num, &block)
       rescue Error::OperationFailure => e
-        e.add_note('modern retry')
         e.add_note("attempt 1")
         if e.unsupported_retryable_write?
           raise_unsupported_error(e)
@@ -257,12 +250,7 @@ module Mongo
     def nro_write_with_retry(session, write_concern, &block)
       if session && session.client.options[:retry_writes]
         server = select_server(cluster, ServerSelector.primary, session)
-        begin
-          yield server
-        rescue Error::SocketError, Error::SocketTimeoutError, Error::OperationFailure => e
-          e.add_note('retries disabled')
-          raise e
-        end
+        yield server
       else
         legacy_write_with_retry(nil, session, &block)
       end
@@ -292,8 +280,7 @@ module Mongo
         server ||= select_server(cluster, ServerSelector.primary, session)
         yield server
       rescue Error::OperationFailure => e
-        e.add_note('legacy retry')
-        e.add_note("attempt #{attempt}")
+        e.add_note("attempt #{attempt + 1}")
         server = nil
         if attempt > client.max_write_retries
           raise e
@@ -311,19 +298,18 @@ module Mongo
     private
 
     def modern_read_with_retry(session, server_selector, &block)
+      attempt = 0
       server = select_server(cluster, server_selector, session)
       begin
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('modern retry')
-        e.add_note("attempt 1")
+        e.add_note("attempt #{attempt + 1}")
         if session.in_transaction?
           raise e
         end
         retry_read(e, server_selector, session, &block)
       rescue Error::OperationFailure => e
-        e.add_note('modern retry')
-        e.add_note("attempt 1")
+        e.add_note("attempt #{attempt + 1}")
         if session.in_transaction? || !e.write_retryable?
           raise e
         end
@@ -338,8 +324,7 @@ module Mongo
         attempt += 1
         yield server
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('legacy retry')
-        e.add_note("attempt #{attempt}")
+        e.add_note("attempt #{attempt + 1}")
         if attempt > client.max_read_retries || (session && session.in_transaction?)
           raise e
         end
@@ -347,9 +332,8 @@ module Mongo
         server = select_server(cluster, server_selector, session)
         retry
       rescue Error::OperationFailure => e
-        e.add_note('legacy retry')
-        e.add_note("attempt #{attempt}")
-        if e.retryable? && !(session && session.in_transaction?)
+        e.add_note("attempt #{attempt + 1}")
+        if cluster.sharded? && e.retryable? && !(session && session.in_transaction?)
           if attempt > client.max_read_retries
             raise e
           end
@@ -391,11 +375,9 @@ module Mongo
       begin
         yield server, true
       rescue Error::SocketError, Error::SocketTimeoutError => e
-        e.add_note('modern retry')
         e.add_note("attempt 2")
         raise e
       rescue Error::OperationFailure => e
-        e.add_note('modern retry')
         unless e.write_retryable?
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error
@@ -403,7 +385,6 @@ module Mongo
         e.add_note("attempt 2")
         raise e
       rescue => e
-        e.add_note('modern retry')
         original_error.add_note("later retry failed: #{e.class}: #{e}")
         raise original_error
       end
@@ -417,19 +398,15 @@ module Mongo
       # server unknown). Here we just need to wait for server selection.
       server = select_server(cluster, ServerSelector.primary, session)
       unless server.retry_writes?
-        # Do not need to add "modern retry" here, it should already be on
-        # the first exception.
         original_error.add_note('did not retry because server selected for retry does not supoprt retryable writes')
         raise original_error
       end
       log_retry(original_error, message: 'Write retry')
       yield(server, txn_num, true)
     rescue Error::SocketError, Error::SocketTimeoutError => e
-      e.add_note('modern retry')
       e.add_note('attempt 2')
       raise e
     rescue Error::OperationFailure => e
-      e.add_note('modern retry')
       if e.write_retryable?
         e.add_note('attempt 2')
         raise e
@@ -438,8 +415,6 @@ module Mongo
         raise original_error
       end
     rescue => e
-      # Do not need to add "modern retry" here, it should already be on
-      # the first exception.
       original_error.add_note("later retry failed: #{e.class}: #{e}")
       raise original_error
     end

data/lib/mongo/semaphore.rb

@@ -25,7 +25,7 @@ module Mongo
 
     # Waits for the semaphore to be signaled up to timeout seconds.
     # If semaphore is not signaled, returns after timeout seconds.
-    def wait(timeout)
+    def wait(timeout = nil)
       @lock.synchronize do
         @cv.wait(@lock, timeout)
       end

data/lib/mongo/server.rb

@@ -58,16 +58,24 @@ module Mongo
       @cluster = cluster
       @monitoring = monitoring
       options = options.dup
-      monitor = options.delete(:monitor)
+      _monitor = options.delete(:monitor)
       @options = options.freeze
       @event_listeners = event_listeners
       @connection_id_gen = Class.new do
         include Id
       end
-      @monitor = Monitor.new(address, event_listeners, monitoring,
-        options.merge(app_metadata: Monitor::AppMetadata.new(cluster.options)))
-      unless monitor == false
-        start_monitoring
+      @scan_semaphore = Semaphore.new
+      @round_trip_time_averager = RoundTripTimeAverager.new
+      @description = Description.new(address, {})
+      @last_scan = nil
+      unless options[:monitoring_io] == false
+        @monitor = Monitor.new(self, event_listeners, monitoring,
+          options.merge(
+            app_metadata: Monitor::AppMetadata.new(cluster.options),
+        ))
+        unless _monitor == false
+          start_monitoring
+        end
       end
       @connected = true
       @pool_lock = Mutex.new
@@ -79,7 +87,8 @@ module Mongo
     # @return [ Cluster ] cluster The server cluster.
     attr_reader :cluster
 
-    # @return [ Monitor ] monitor The server monitor.
+    # @return [ nil | Monitor ] monitor The server monitor. nil if the servenr
+    #   was created with monitoring_io: false option.
     attr_reader :monitor
 
     # @return [ Hash ] The options hash.
@@ -88,15 +97,46 @@ module Mongo
     # @return [ Monitoring ] monitoring The monitoring.
     attr_reader :monitoring
 
-    # Get the description from the monitor and scan on monitor.
-    def_delegators :monitor,
-      :description,
-      :scan!,
-      :heartbeat_frequency,
-      :last_scan,
-      :compressor
+    # @return [ Server::Description ] description The server
+    #   description the monitor refreshes.
+    attr_reader :description
+
+    # @return [ Time | nil ] last_scan The time when the last server scan
+    #   completed, or nil if the server has not been scanned yet.
+    #
+    # @since 2.4.0
+    def last_scan
+      if description && !description.config.empty?
+        description.last_update_time
+      else
+        @last_scan
+      end
+    end
+
+    # @deprecated
+    def heartbeat_frequency
+      cluster.heartbeat_interval
+    end
+
+    # @deprecated
     alias :heartbeat_frequency_seconds :heartbeat_frequency
 
+    # @deprecated
+    def_delegators :monitor, :scan!
+
+    # The last compressor discovered by the server monitor.
+    #
+    # The compressor state should be determined for each individual
+    # connection rather than kept per server. A future version of the
+    # driver will change how compressors are tracked and used.
+    def compressor
+      if monitor
+        monitor.compressor
+      else
+        nil
+      end
+    end
+
     # Delegate convenience methods to the monitor description.
     def_delegators :description,
                    :arbiter?,
@@ -127,6 +167,16 @@ module Mongo
     def_delegators :features,
                    :check_driver_support!
 
+    # @return [ Semaphore ] Semaphore to signal to request an immediate scan
+    #   of this server by its monitor, if one is running.
+    #
+    # @api private
+    attr_reader :scan_semaphore
+
+    # @return [ RoundTripTimeAverager ] Round trip time averager object.
+    # @api private
+    attr_reader :round_trip_time_averager
+
     # Is this server equal to another?
     #
     # @example Is the server equal to the other?
@@ -169,26 +219,37 @@ module Mongo
     # @deprecated No longer necessary with Server Selection specification.
     def connectable?; end
 
-    # Disconnect the server from the connection.
-    #
-    # @example Disconnect the server.
-    #   server.disconnect!
+    # Disconnect the driver from this server.
     #
-    # @param [ Boolean ] wait Whether to wait for background threads to
-    #   finish running.
+    # Disconnects all idle connections to this server in its connection pool,
+    # if any exist. Stops the populator of the connection pool, if it is
+    # running. Does not immediately close connections which are presently
+    # checked out (i.e. in use) - such connections will be closed when they
+    # are returned to their respective connection pools. Stop the server's
+    # background monitor.
     #
-    # @return [ true ] Always true with no exception.
+    # @return [ true ] Always true.
     #
     # @since 2.0.0
-    def disconnect!(wait=false)
-      begin
+    def disconnect!
+      if monitor
+        monitor.stop!
+      end
+      _pool = @pool_lock.synchronize do
+        @pool
+      end
+      if _pool
         # For backwards compatibility we disconnect/clear the pool rather
-        # than close it here.
-        pool.disconnect!
-      rescue Error::PoolClosedError
-        # If the pool was already closed, we don't need to do anything here.
+        # than close it here. We also stop the populator which allows the
+        # the pool to continue providing connections but stops it from
+        # connecting in background on clients/servers that are in fact
+        # intended to be closed and no longer used.
+        begin
+          _pool.disconnect!(stop_populator: true)
+        rescue Error::PoolClosedError
+          # If the pool was already closed, we don't need to do anything here.
+        end
       end
-      monitor.stop!(wait)
       @connected = false
       true
     end
@@ -228,8 +289,8 @@ module Mongo
         Monitoring::Event::ServerOpening.new(address, cluster.topology)
       )
       if options[:monitoring_io] != false
-        monitor.run!
         ObjectSpace.define_finalizer(self, self.class.finalize(monitor))
+        monitor.run!
       end
     end
 
@@ -275,11 +336,17 @@ module Mongo
       if replica_set_name
         status += " replica_set=#{replica_set_name}"
       end
+
+      if @pool
+        status += " pool=#{@pool.summary}"
+      end
+
       address_bit = if address
         "#{address.host}:#{address.port}"
       else
         'nil'
       end
+
       "#<Server address=#{address_bit} #{status}>"
     end
 
@@ -374,7 +441,6 @@ module Mongo
     rescue Mongo::Error::SocketError
       # non-timeout network error
       unknown!
-      pool.disconnect!
       raise
     rescue Auth::Unauthorized
       # auth error, keep server description and topology as they are
@@ -407,24 +473,24 @@ module Mongo
     # Marks server unknown and publishes the associated SDAM event
     # (server description changed).
     #
+    # @param [ Hash ] options Options.
+    #
+    # @option options [ true | false ] :keep_connection_pool Usually when the
+    #   new server description is unknown, the connection pool on the
+    #   respective server is cleared. Set this option to true to keep the
+    #   existing connection pool (required when handling not master errors
+    #   on 4.2+ servers).
+    #
     # @since 2.4.0, SDAM events are sent as of version 2.7.0
-    def unknown!
-      # Just dispatch the description changed event here, SDAM flow
-      # will update description on the server without in-place mutations
-      # and invoke SDAM transitions as needed.
-      publish(Event::DESCRIPTION_CHANGED, description, Description.new(address))
+    def unknown!(options = {})
+      # SDAM flow will update description on the server without in-place
+      # mutations and invoke SDAM transitions as needed.
+      cluster.run_sdam_flow(description, Description.new(address), options)
     end
 
     # @api private
     def update_description(description)
-      prev_description = monitor.instance_variable_get('@description')
-      monitor.instance_variable_set('@description', description)
-      if description.unknown? && !prev_description.unknown?
-        # This clears redundantly sometimes and also clears the pool on
-        # 4.2+ servers after not master errors which should not be done.
-        # Driver version 2.11+ has the correct implementation.
-        clear_connection_pool
-      end
+      @description = description
     end
 
     # @api private
@@ -440,6 +506,11 @@ module Mongo
     def next_connection_id
       @connection_id_gen.next_id
     end
+
+    # @api private
+    def update_last_scan
+      @last_scan = Time.now
+    end
   end
 end