mongo 2.17.2 → 2.18.1

data/lib/mongo/server/connection_pool.rb

@@ -29,7 +29,7 @@ module Mongo
       # The default max size for the connection pool.
       #
       # @since 2.9.0
-      DEFAULT_MAX_SIZE = 5.freeze
+      DEFAULT_MAX_SIZE = 20.freeze
 
       # The default min size for the connection pool.
       #
@@ -59,7 +59,8 @@ module Mongo
       # @param [ Server ] server The server which this connection pool is for.
       # @param [ Hash ] options The connection pool options.
       #
-      # @option options [ Integer ] :max_size The maximum pool size.
+      # @option options [ Integer ] :max_size The maximum pool size. Setting
+      #   this option to zero creates an unlimited connection pool.
       # @option options [ Integer ] :max_pool_size Deprecated.
       #   The maximum pool size. If max_size is also given, max_size and
       #   max_pool_size must be identical.
@@ -98,7 +99,7 @@ module Mongo
         options[:max_size] ||= options[:max_pool_size]
         options.delete(:max_pool_size)
         if options[:min_size] && options[:max_size] &&
-          options[:min_size] > options[:max_size]
+          (options[:max_size] != 0 && options[:min_size] > options[:max_size])
         then
           raise ArgumentError, "Cannot have min size #{options[:min_size]} exceed max size #{options[:max_size]}"
         end
@@ -278,7 +279,7 @@ module Mongo
       #   and remains so for longer than the wait timeout.
       #
       # @since 2.9.0
-      def check_out(service_id: nil)
+      def check_out(connection_global_id: nil)
         check_invariants
 
         publish_cmap_event(
@@ -307,12 +308,31 @@ module Mongo
             # a connection while this thread is waiting for one.
             @lock.synchronize do
               until @available_connections.empty?
-                connection = next_available_connection(service_id: service_id)
-
-                # If service_id is not nil, connection may be nil here
-                # even if there are available connections in the pool
-                # (they could be to other services).
-                break unless connection
+                connection = next_available_connection(
+                  connection_global_id: connection_global_id
+                )
+
+                if connection.nil?
+                  if connection_global_id
+                    # A particular connection is requested, but it is not available.
+                    # If it is nether available not checked out, we should stop here.
+                    @checked_out_connections.detect do |conn|
+                      conn.connection_global_id == connection_global_id
+                    end.tap do |conn|
+                      if conn.nil?
+                        publish_cmap_event(
+                          Monitoring::Event::Cmap::ConnectionCheckOutFailed.new(
+                            @server.address,
+                            Monitoring::Event::Cmap::ConnectionCheckOutFailed::CONNECTION_ERROR
+                          ),
+                        )
+                        raise Error::MissingConnection.new
+                      end
+                    end
+                  else
+                    break
+                  end
+                end
 
                 if connection.pid != pid
                   log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{connection.pid}, new pid #{pid}")
@@ -321,38 +341,44 @@ module Mongo
                   next
                 end
 
-                if connection.generation != generation(service_id: connection.service_id)
-                  # Stale connections should be disconnected in the clear
-                  # method, but if any don't, check again here
-                  connection.disconnect!(reason: :stale)
-                  @populate_semaphore.signal
-                  next
-                end
-
-                if max_idle_time && connection.last_checkin &&
-                  Time.now - connection.last_checkin > max_idle_time
-                then
-                  connection.disconnect!(reason: :idle)
-                  @populate_semaphore.signal
-                  next
+                if !connection.pinned?
+                  # If connection is marked as pinned, it is used by a transaction
+                  # or a series of cursor operations in a load balanced setup.
+                  # In this case connection should not be disconnected until
+                  # unpinned.
+                  if connection.generation != generation(
+                    service_id: connection.service_id
+                  )
+                    # Stale connections should be disconnected in the clear
+                    # method, but if any don't, check again here
+                    connection.disconnect!(reason: :stale)
+                    @populate_semaphore.signal
+                    next
+                  end
+
+                  if max_idle_time && connection.last_checkin &&
+                    Time.now - connection.last_checkin > max_idle_time
+                  then
+                    connection.disconnect!(reason: :idle)
+                    @populate_semaphore.signal
+                    next
+                  end
                 end
 
                 @pending_connections << connection
                 throw(:done)
               end
 
-              if service_id
-                # If we need a connection to a particular service, we can't
-                # create one if we don't already have one, but we can wait
-                # for an in-progress operation to return such a connection
-                # to the pool, or for the populator to create a suitable
-                # connection.
+              if @server.load_balancer? && connection_global_id
+                # We need a  particular connection, and if it is not available
+                # we can wait for an in-progress operation to return
+                # such a connection to the pool.
               else
                 # If we are below pool capacity, create a new connection.
                 #
                 # Ruby does not allow a thread to lock a mutex which it already
                 # holds.
-                if unsynchronized_size < max_size
+                if max_size == 0 || unsynchronized_size < max_size
                   connection = create_connection
                   @pending_connections << connection
                   throw(:done)
@@ -370,14 +396,14 @@ module Mongo
               )
 
               msg = @lock.synchronize do
-                service_id_msg = if service_id
-                  " for service #{service_id}"
+                connection_global_id_msg = if connection_global_id
+                  " for connection #{connection_global_id}"
                 else
                   ''
                 end
 
                 "Timed out attempting to check out a connection " +
-                  "from pool for #{@server.address}#{service_id_msg} after #{wait_timeout} sec. " +
+                  "from pool for #{@server.address}#{connection_global_id_msg} after #{wait_timeout} sec. " +
                   "Connections in pool: #{@available_connections.length} available, " +
                   "#{@checked_out_connections.length} checked out, " +
                   "#{@pending_connections.length} pending " +
@@ -471,7 +497,11 @@ module Mongo
             # Connection was closed - for example, because it experienced
             # a network error. Nothing else needs to be done here.
             @populate_semaphore.signal
-          elsif connection.generation != generation(service_id: connection.service_id)
+          elsif connection.generation != generation(service_id: connection.service_id) && !connection.pinned?
+            # If connection is marked as pinned, it is used by a transaction
+            # or a series of cursor operations in a load balanced setup.
+            # In this case connection should not be disconnected until
+            # unpinned.
             connection.disconnect!(reason: :stale)
             @populate_semaphore.signal
           else
@@ -495,8 +525,6 @@ module Mongo
       # @option options [ true | false ] :lazy If true, do not close any of
       #   the idle connections and instead let them be closed during a
       #   subsequent check out operation.
-      # @option options [ Object ] :service_id Discard state for the specified
-      #   service id only.
       # @option options [ true | false ] :stop_populator Whether to stop
       #   the populator background thread. For internal driver use only.
       # @option options [ Object ] :service_id Clear connections with
@@ -522,12 +550,12 @@ module Mongo
           publish_cmap_event(
             Monitoring::Event::Cmap::PoolCleared.new(
               @server.address,
-              service_id: service_id,
+              service_id: service_id
             )
           )
 
           unless options && options[:lazy]
-            if service_id
+            if @server.load_balancer? && service_id
               loop do
                 conn = @available_connections.detect do |conn|
                   conn.service_id == service_id
@@ -632,10 +660,10 @@ module Mongo
       # @return [ Object ] The result of the block.
       #
       # @since 2.0.0
-      def with_connection(service_id: nil)
+      def with_connection(connection_global_id: nil)
         raise_if_closed!
 
-        connection = check_out(service_id: service_id)
+        connection = check_out(connection_global_id: connection_global_id)
         yield(connection)
       ensure
         if connection
@@ -751,13 +779,13 @@ module Mongo
 
       private
 
-      # Returns the next available connection, optionally scoped to the
-      # specified service. If no suitable connections are available,
+      # Returns the next available connection, optionally with given
+      # global id. If no suitable connections are available,
       # returns nil.
-      def next_available_connection(service_id: nil)
-        if service_id
+      def next_available_connection(connection_global_id: nil)
+        if @server.load_balancer? && connection_global_id
           conn = @available_connections.detect do |conn|
-            conn.service_id == service_id
+            conn.global_id == connection_global_id
           end
           if conn
             @available_connections.delete(conn)

data/lib/mongo/server/description/features.rb

@@ -36,10 +36,12 @@ module Mongo
         # -  9 => 4.4
         # - 13 => 5.0
         # - 14 => 5.1
+        # - 17 => 6.0
         #
         # @since 2.0.0
         MAPPINGS = {
           merge_out_on_secondary: 13,
+          get_more_comment: 9,
           retryable_write_error_label: 9,
           commit_quorum: 9,
           # Server versions older than 4.2 do not reliably validate options
@@ -80,7 +82,7 @@ module Mongo
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (6..14).freeze
+        DRIVER_WIRE_VERSIONS = (6..17).freeze
 
         # Create the methods for each mapping to tell if they are supported.
         #

data/lib/mongo/server/description.rb

@@ -234,8 +234,7 @@ module Mongo
           # to work if the server it communicates with does not set serviceId
           # in ismaster/hello response.
           #
-          # In practice, there are currently no server version that actually
-          # sets this field.
+          # At the moment we cannot run a proper load balancer setup on evergreen
           #
           # Therefore, when connect=:load_balanced Ruby option is used instead
           # of the loadBalanced=true URI option, if serviceId is not set in
@@ -255,6 +254,8 @@ module Mongo
           # service ids are strings, to distinguish them from the real ones.
           # In particular processId is also a BSON::ObjectId, but will be
           # mapped to a string for clarity that this is a fake service id.
+          #
+          # TODO: Remove this when https://jira.mongodb.org/browse/RUBY-2881 is done.
           if ok? && !service_id
             unless force_load_balancer
               raise Error::MissingServiceId, "The server at #{address.seed} did not provide a service id in handshake response"
@@ -871,6 +872,10 @@ module Mongo
       # @api private
       def server_version_gte?(version)
         required_wv = case version
+          when '5.2'
+            15
+          when '5.1'
+            14
           when '5.0'
             12
           when '4.4'

data/lib/mongo/server/monitor/connection.rb

@@ -86,6 +86,7 @@ module Mongo
           options[:connect_timeout] || Server::CONNECT_TIMEOUT
         end
 
+        # @return [ Integer ] server_connection_id The server connection id.
         attr_reader :server_connection_id
 
         # Sends a message and returns the result.

data/lib/mongo/server/monitor.rb

@@ -170,6 +170,25 @@ module Mongo
         end
       end
 
+      def create_push_monitor!(topology_version)
+        @update_mutex.synchronize do
+          if @push_monitor && !@push_monitor.running?
+            @push_monitor = nil
+          end
+
+          @push_monitor ||= PushMonitor.new(
+            self,
+            topology_version,
+            monitoring,
+            **Utils.shallow_symbolize_keys(options.merge(
+              socket_timeout: heartbeat_interval + connection.socket_timeout,
+              app_metadata: options[:push_monitor_app_metadata],
+              check_document: @connection.check_document
+            )),
+          )
+        end
+      end
+
       def stop_push_monitor!
         @update_mutex.synchronize do
           if @push_monitor
@@ -249,6 +268,10 @@ module Mongo
         end
       end
 
+      def to_s
+        "#<#{self.class.name}:#{object_id} #{server.address}>"
+      end
+
       private
 
       def pre_stop
@@ -300,20 +323,9 @@ module Mongo
             connection.handshake!
           end
           @connection = connection
-          if result['topologyVersion']
+          if tv_doc = result['topologyVersion']
             # Successful response, server 4.4+
-            @update_mutex.synchronize do
-              @push_monitor ||= PushMonitor.new(
-                self,
-                TopologyVersion.new(result['topologyVersion']),
-                monitoring,
-                **Utils.shallow_symbolize_keys(options.merge(
-                  socket_timeout: heartbeat_interval + connection.socket_timeout,
-                  app_metadata: options[:push_monitor_app_metadata],
-                  check_document: @connection.check_document
-                )),
-              )
-            end
+            create_push_monitor!(TopologyVersion.new(tv_doc))
             push_monitor.run!
           else
             # Failed response or pre-4.4 server

data/lib/mongo/server/push_monitor.rb

@@ -78,7 +78,7 @@ module Mongo
           if @connection
             # Interrupt any in-progress exhausted hello reads by
             # disconnecting the connection.
-            @connection.send(:socket).close
+            @connection.send(:socket).close rescue nil
           end
         end
         super.tap do
@@ -124,8 +124,14 @@ module Mongo
           bg_error_backtrace: options[:bg_error_backtrace],
         )
 
-        # Avoid tight looping in push monitor - see RUBY-2806.
-        sleep(0.5)
+        # If a request failed on a connection, stop push monitoring.
+        # In case the server is dead we don't want to have two connections
+        # trying to connect unsuccessfully at the same time.
+        stop!
+
+        # Request an immediate check on the monitor to get reinstated as
+        # soon as possible in case the server is actually alive.
+        server.scan_semaphore.signal
       end
 
       def check
@@ -190,6 +196,10 @@ module Mongo
         end
       end
 
+      def to_s
+        "#<#{self.class.name}:#{object_id} #{server.address}>"
+      end
+
     end
   end
 end

data/lib/mongo/server.rb

@@ -444,8 +444,8 @@ module Mongo
     # @return [ Object ] The result of the block execution.
     #
     # @since 2.3.0
-    def with_connection(service_id: nil, &block)
-      pool.with_connection(service_id: service_id, &block)
+    def with_connection(connection_global_id: nil, &block)
+      pool.with_connection(connection_global_id: connection_global_id, &block)
     end
 
     # Handle handshake failure.
@@ -511,9 +511,15 @@ module Mongo
     # @note Retryable writes are only available on server versions 3.6+ and with
     #   sharded clusters or replica sets.
     #
+    # @note Some of the conditions in this method automatically return false for
+    #       for load balanced topologies. The conditions in this method should
+    #       always be true, since load-balanced topologies are only available on
+    #       MongoDB 5.0+, and not for standalone topologies. Therefore, we can
+    #       assume that retry writes are enabled.
+    #
     # @since 2.5.0
     def retry_writes?
-      !!(features.sessions_enabled? && logical_session_timeout && !standalone?)
+      !!(features.sessions_enabled? && logical_session_timeout && !standalone?) || load_balancer?
     end
 
     # Marks server unknown and publishes the associated SDAM event
@@ -532,8 +538,6 @@ module Mongo
     #   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).
-    # @option options [ Object ] :service_id Discard state for the specified
-    #   service id only.
     # @option options [ TopologyVersion ] :topology_version Topology version
     #   of the error response that is causing the server to be marked unknown.
     # @option options [ true | false ] :stop_push_monitor Whether to stop

data/lib/mongo/session/session_pool.rb

@@ -99,6 +99,10 @@ module Mongo
       #
       # @since 2.5.0
       def checkin(session)
+        if session.nil?
+          raise ArgumentError, 'session cannot be nil'
+        end
+
         @mutex.synchronize do
           prune!
           unless about_to_expire?(session)
@@ -133,6 +137,10 @@ module Mongo
       private
 
       def about_to_expire?(session)
+        if session.nil?
+          raise ArgumentError, 'session cannot be nil'
+        end
+
         # Load balancers spec explicitly requires to ignore the logical session
         # timeout value.
         # No rationale is provided as of the time of this writing.