mongo 2.15.0 → 2.16.1

data/lib/mongo/server/connection_common.rb

@@ -57,13 +57,15 @@ module Mongo
       # @param [ Server::AppMetadata ] app_metadata Application metadata
       # @param [ BSON::Document ] speculative_auth_doc The speculative
       #   authentication document, if any.
+      # @param [ true | false ] load_balancer Whether the connection is to
+      #   a load balancer.
       # @param server_api [ Hash | nil ] server_api Server API version.
       #
       # @return [BSON::Document] Document that should be sent to a server
       #     for handshake purposes.
       #
       # @api private
-      def handshake_document(app_metadata, speculative_auth_doc: nil, server_api: nil)
+      def handshake_document(app_metadata, speculative_auth_doc: nil, load_balancer: false, server_api: nil)
         serv_api = app_metadata.server_api || server_api
         document = if serv_api
                      HELLO_DOC.merge(Utils.transform_server_api(serv_api))
@@ -74,6 +76,33 @@ module Mongo
           if speculative_auth_doc
             doc.update(speculativeAuthenticate: speculative_auth_doc)
           end
+          if load_balancer
+            doc.update(loadBalanced: true)
+          end
+        end
+      end
+
+      # Build a command that should be used for connection handshake.
+      #
+      # @param [ BSON::Document ] handshake_document Document that should be
+      #   sent to a server for handshake purpose.
+      #
+      # @return [ Protocol::Message ] Command that should be sent to a server
+      #   for handshake purposes.
+      #
+      # @api private
+      def handshake_command(handshake_document)
+        if handshake_document['apiVersion']
+          Protocol::Msg.new(
+            [], {}, handshake_document.merge({'$db' => Database::ADMIN})
+          )
+        else
+          Protocol::Query.new(
+            Database::ADMIN,
+            Database::COMMAND,
+            handshake_document,
+            :limit => -1
+          )
         end
       end
 
@@ -125,10 +154,18 @@ module Mongo
         if respond_to?(:id)
           note << ", connection #{generation}:#{id}"
         end
+        # Non-monitoring connections have service id.
+        # Monitoring connections do not.
+        if respond_to?(:service_id) && service_id
+          note << ", service id #{service_id}"
+        end
         e.add_note(note)
         if respond_to?(:generation)
           # Non-monitoring connections
           e.generation = generation
+          if respond_to?(:description)
+            e.service_id = service_id
+          end
         end
         raise e
       end

data/lib/mongo/server/connection_pool/generation_manager.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+    class ConnectionPool
+
+      # @api private
+      class GenerationManager
+
+        def initialize(server:)
+          @map = Hash.new { |hash, key| hash[key] = 1 }
+          @server = server
+          @lock = Mutex.new
+        end
+
+        attr_reader :server
+
+        def generation(service_id: nil)
+          if service_id
+            unless server.load_balancer?
+              raise ArgumentError, "Generation scoping to services is only available in load-balanced mode, but the server at #{server.address} is not a load balancer"
+            end
+          else
+            if server.load_balancer?
+              raise ArgumentError, "The server at #{server.address} is a load balancer and therefore does not have a single global generation"
+            end
+          end
+          @lock.synchronize do
+            @map[service_id]
+          end
+        end
+
+        def bump(service_id: nil)
+          @lock.synchronize do
+            if service_id
+              @map[service_id] += 1
+            else
+              # When service id is not supplied, one of two things may be
+              # happening;
+              #
+              # 1. The pool is not to a load balancer, in which case we only
+              #    need to increment the generation for the nil service_id.
+              # 2. The pool is to a load balancer, in which case we need to
+              #    increment the generation for each service.
+              #
+              # Incrementing everything in the map accomplishes both tasks.
+              @map.each do |k, v|
+                @map[k] += 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/server/connection_pool.rb

@@ -14,7 +14,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-require 'mongo/server/connection_pool/populator'
 
 module Mongo
   class Server
@@ -111,7 +110,7 @@ module Mongo
         @server = server
         @options = options.freeze
 
-        @generation = 1
+        @generation_manager = GenerationManager.new(server: server)
         @closed = false
 
         # A connection owned by this pool should be either in the
@@ -189,12 +188,14 @@ module Mongo
         @max_idle_time ||= options[:max_idle_time]
       end
 
+      # @api private
+      attr_reader :generation_manager
+
       # @return [ Integer ] generation Generation of connections currently
       #   being used by the queue.
       #
-      # @since 2.9.0
       # @api private
-      attr_reader :generation
+      def_delegator :generation_manager, :generation
 
       # Size of the connection pool.
       #
@@ -277,7 +278,7 @@ module Mongo
       #   and remains so for longer than the wait timeout.
       #
       # @since 2.9.0
-      def check_out
+      def check_out(service_id: nil)
         check_invariants
 
         publish_cmap_event(
@@ -306,7 +307,12 @@ module Mongo
             # a connection while this thread is waiting for one.
             @lock.synchronize do
               until @available_connections.empty?
-                connection = @available_connections.pop
+                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
 
                 if connection.pid != pid
                   log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{connection.pid}, new pid #{pid}")
@@ -315,7 +321,7 @@ module Mongo
                   next
                 end
 
-                if connection.generation != generation
+                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)
@@ -335,12 +341,22 @@ module Mongo
                 throw(:done)
               end
 
-              # Ruby does not allow a thread to lock a mutex which it already
-              # holds.
-              if unsynchronized_size < max_size
-                connection = create_connection
-                @pending_connections << connection
-                throw(:done)
+              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.
+              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
+                  connection = create_connection
+                  @pending_connections << connection
+                  throw(:done)
+                end
               end
             end
 
@@ -354,8 +370,14 @@ module Mongo
               )
 
               msg = @lock.synchronize do
+                service_id_msg = if service_id
+                  " for service #{service_id}"
+                else
+                  ''
+                end
+
                 "Timed out attempting to check out a connection " +
-                  "from pool for #{@server.address} after #{wait_timeout} sec. " +
+                  "from pool for #{@server.address}#{service_id_msg} after #{wait_timeout} sec. " +
                   "Connections in pool: #{@available_connections.length} available, " +
                   "#{@checked_out_connections.length} checked out, " +
                   "#{@pending_connections.length} pending " +
@@ -449,7 +471,7 @@ 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
+          elsif connection.generation != generation(service_id: connection.service_id)
             connection.disconnect!(reason: :stale)
             @populate_semaphore.signal
           else
@@ -473,8 +495,12 @@ 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
+      #   the specified service id only.
       #
       # @return [ true ] true.
       #
@@ -488,18 +514,38 @@ module Mongo
           stop_populator
         end
 
+        service_id = options && options[:service_id]
+
         @lock.synchronize do
-          @generation += 1
+          @generation_manager.bump(service_id: service_id)
 
           publish_cmap_event(
-            Monitoring::Event::Cmap::PoolCleared.new(@server.address)
+            Monitoring::Event::Cmap::PoolCleared.new(
+              @server.address,
+              service_id: service_id,
+            )
           )
 
           unless options && options[:lazy]
-            until @available_connections.empty?
-              connection = @available_connections.pop
-              connection.disconnect!(reason: :stale)
-              @populate_semaphore.signal
+            if service_id
+              loop do
+                conn = @available_connections.detect do |conn|
+                  conn.service_id == service_id
+                end
+                if conn
+                  @available_connections.delete(conn)
+                  conn.disconnect!(reason: :stale)
+                  @populate_semaphore.signal
+                else
+                  break
+                end
+              end
+            else
+              until @available_connections.empty?
+                connection = @available_connections.pop
+                connection.disconnect!(reason: :stale)
+                @populate_semaphore.signal
+              end
             end
           end
         end
@@ -586,10 +632,10 @@ module Mongo
       # @return [ Object ] The result of the block.
       #
       # @since 2.0.0
-      def with_connection
+      def with_connection(service_id: nil)
         raise_if_closed!
 
-        connection = check_out
+        connection = check_out(service_id: service_id)
         yield(connection)
       ensure
         if connection
@@ -705,13 +751,33 @@ module Mongo
 
       private
 
+      # Returns the next available connection, optionally scoped to the
+      # specified service. If no suitable connections are available,
+      # returns nil.
+      def next_available_connection(service_id: nil)
+        if service_id
+          conn = @available_connections.detect do |conn|
+            conn.service_id == service_id
+          end
+          if conn
+            @available_connections.delete(conn)
+          end
+          conn
+        else
+          @available_connections.pop
+        end
+      end
+
       def create_connection
-        connection = Connection.new(@server, options.merge(
-          generation: generation,
+        opts = options.merge(
           connection_pool: self,
           # Do not pass app metadata - this will be retrieved by the connection
           # based on the auth needs.
-        ))
+        )
+        unless @server.load_balancer?
+          opts[:generation] = generation
+        end
+        connection = Connection.new(@server, opts)
       end
 
       # Create a connection, connect it, and add it to the pool.
@@ -772,7 +838,11 @@ module Mongo
           raise
         end
       rescue Error::SocketError, Error::SocketTimeoutError => exc
-        @server.unknown!(generation: exc.generation, stop_push_monitor: true)
+        @server.unknown!(
+          generation: exc.generation,
+          service_id: exc.service_id,
+          stop_push_monitor: true,
+        )
         raise
       end
 
@@ -800,3 +870,6 @@ module Mongo
     end
   end
 end
+
+require 'mongo/server/connection_pool/generation_manager'
+require 'mongo/server/connection_pool/populator'

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

@@ -38,28 +38,29 @@ module Mongo
         #
         # @since 2.0.0
         MAPPINGS = {
-          :retryable_write_error_label => 9,
+          retryable_write_error_label: 9,
+          commit_quorum: 9,
           # Server versions older than 4.2 do not reliably validate options
           # provided by the client during findAndModify operations, requiring the
           # driver to raise client-side errors when those options are provided.
-          :find_and_modify_option_validation => 8,
-          :transactions => 7,
-          :scram_sha_256 => 7,
-          :array_filters => 6,
-          :op_msg => 6,
-          :sessions => 6,
-          :collation => 5,
-          :max_staleness => 5,
+          find_and_modify_option_validation: 8,
+          transactions: 7,
+          scram_sha_256: 7,
+          array_filters: 6,
+          op_msg: 6,
+          sessions: 6,
+          collation: 5,
+          max_staleness: 5,
           # Server versions older than 3.4 do not reliably validate options
           # provided by the client during update/delete operations, requiring the
           # driver to raise client-side errors when those options are provided.
-          :update_delete_option_validation => 5,
-          :find_command => 4,
-          :list_collections => 3,
-          :list_indexes => 3,
-          :scram_sha_1 => 3,
-          :write_command => 2,
-          :users_info => 2
+          update_delete_option_validation: 5,
+          find_command: 4,
+          list_collections: 3,
+          list_indexes: 3,
+          scram_sha_1: 3,
+          write_command: 2,
+          users_info: 2,
         }.freeze
 
         # Error message if the server is too old for this version of the driver.

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+    class Description
+
+      # Represents an assumed description of servers behind load balancers.
+      class LoadBalancer
+        def initialize(address)
+          @address = address
+        end
+
+        # @return [ Address ] address The server's address.
+        attr_reader :address
+      end
+    end
+  end
+end

data/lib/mongo/server/description.rb

@@ -15,8 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/server/description/features'
-
 module Mongo
   class Server
 
@@ -201,7 +199,8 @@ module Mongo
                                ].freeze
 
       # Instantiate the new server description from the result of the hello
-      # command.
+      # command or fabricate a placeholder description for Unknown and
+      # LoadBalancer servers.
       #
       # @example Instantiate the new description.
       #   Description.new(address, { 'isWritablePrimary' => true }, 0.5)
@@ -209,17 +208,67 @@ module Mongo
       # @param [ Address ] address The server address.
       # @param [ Hash ] config The result of the hello command.
       # @param [ Float ] average_round_trip_time The moving average time (sec) the hello
-      #   call took to complete.
+      #   command took to complete.
+      # @param [ Float ] average_round_trip_time The moving average time (sec)
+      #   the ismaster call took to complete.
+      # @param [ true | false ] load_balancer Whether the server is treated as
+      #   a load balancer.
+      # @param [ true | false ] force_load_balancer Whether the server is
+      #   forced to be a load balancer.
       #
-      # @since 2.0.0
-      def initialize(address, config = {}, average_round_trip_time = nil)
+      # @api private
+      def initialize(address, config = {}, average_round_trip_time: nil,
+        load_balancer: false, force_load_balancer: false
+      )
         @address = address
         @config = config
+        @load_balancer = !!load_balancer
+        @force_load_balancer = !!force_load_balancer
         @features = Features.new(wire_versions, me || @address.to_s)
         @average_round_trip_time = average_round_trip_time
         @last_update_time = Time.now.freeze
         @last_update_monotime = Utils.monotonic_time
 
+        if load_balancer
+          # When loadBalanced=true URI option is set, the driver will refuse
+          # 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.
+          #
+          # Therefore, when connect=:load_balanced Ruby option is used instead
+          # of the loadBalanced=true URI option, if serviceId is not set in
+          # ismaster/hello response, the driver fabricates a serviceId and
+          # proceeds to treat a server that does not report itself as being
+          # behind a load balancer as a server that is behind a load balancer.
+          #
+          # 5.0+ servers should provide topologyVersion.processId which
+          # is specific to the particular process instance. We can use that
+          # field as a proxy for serviceId.
+          #
+          # If the topologyVersion isn't provided for whatever reason, we
+          # fabricate a serviceId locally.
+          #
+          # In either case, a serviceId provided by an actual server behind
+          # a load balancer is supposed to be a BSON::ObjectId. The fabricated
+          # 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.
+          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"
+            end
+
+            fake_service_id = if process_id = topology_version && topology_version['processId']
+              "process:#{process_id}"
+            else
+              "fake:#{rand(2**32-1)+1}"
+            end
+            @config = @config.merge('serviceId' => fake_service_id)
+          end
+        end
+
         if Mongo::Lint.enabled?
           # prepopulate cache instance variables
           hosts
@@ -237,11 +286,23 @@ module Mongo
       # @return [ Hash ] The actual result from the hello command.
       attr_reader :config
 
+      # Returns whether this server is a load balancer.
+      #
+      # @return [ true | false ] Whether this server is a load balancer.
+      def load_balancer?
+        @load_balancer
+      end
+
       # @return [ Features ] features The features for the server.
       def features
         @features
       end
 
+      # @return [ nil | Object ] The service id, if any.
+      def service_id
+        config['serviceId']
+      end
+
       # @return [ Float ] The moving average time the hello call took to complete.
       attr_reader :average_round_trip_time
 
@@ -625,6 +686,7 @@ module Mongo
       #
       # @since 2.4.0
       def server_type
+        return :load_balancer if load_balancer?
         return :arbiter if arbiter?
         return :ghost if ghost?
         return :sharded if mongos?
@@ -659,6 +721,7 @@ module Mongo
       #
       # @since 2.0.0
       def unknown?
+        return false if load_balancer?
         config.empty? || config.keys == %w(topologyVersion) || !ok?
       end
 
@@ -780,6 +843,11 @@ module Mongo
         config['connectionId']
       end
 
+      # @api experimental
+      def service_id
+        config['serviceId']
+      end
+
       # Check equality of two descriptions.
       #
       # @example Check description equality.
@@ -825,8 +893,19 @@ module Mongo
             raise ArgumentError, "Bogus required version #{version}"
           end
 
+        if load_balancer?
+          # If we are talking to a load balancer, there is no monitoring
+          # and we don't know what server is behind the load balancer.
+          # Assume everything is supported.
+          # TODO remove this when RUBY-2220 is implemented.
+          return true
+        end
+
         required_wv >= min_wire_version && required_wv <= max_wire_version
       end
     end
   end
 end
+
+require 'mongo/server/description/features'
+require 'mongo/server/description/load_balancer'

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

@@ -194,13 +194,12 @@ module Mongo
         #
         # @raise [Mongo::Error] If handshake failed.
         def handshake!
-          document = handshake_document(
-            @app_metadata,
-            server_api: options[:server_api]
+          command = handshake_command(
+            handshake_document(
+              @app_metadata,
+              server_api: options[:server_api]
+            )
           )
-          # TODO (DR): OP_MSG should be used if api version is declared.
-          # See https://github.com/mongodb/specifications/blob/master/source/message/OP_MSG.rst#id5
-          command = Protocol::Query.new(Database::ADMIN, Database::COMMAND, document, :limit => -1)
           payload = command.serialize.to_s
           message = dispatch_bytes(payload)
           result = Operation::Result.new(message)

data/lib/mongo/server/monitor.rb

@@ -215,7 +215,8 @@ module Mongo
           old_description = server.description
 
           new_description = Description.new(server.address, result,
-            server.round_trip_time_averager.average_round_trip_time)
+            average_round_trip_time: server.round_trip_time_averager.average_round_trip_time
+          )
 
           server.cluster.run_sdam_flow(server.description, new_description, awaited: awaited)