mongo 2.15.1 → 2.16.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abc1ceb1549c601a0b9d34ae3df301219e1de84ebdda6747734b9228395fa860
-  data.tar.gz: b5dc267b2fc65cfaef33a3e0966edd9b90fb35c414e996d2bd778d0c43ff9cc3
+  metadata.gz: 3112358aa696aa5d05305642f004ad5b32bbab28162dea03b96572ed546fc932
+  data.tar.gz: fa983d69caf1b98e44b035fd43d264df4e2c76fa1cb0761d8798e83af2173f92
 SHA512:
-  metadata.gz: 7688c5325d3a4746ba6c2975dbdaf4aaf15929d49d467ff27cc3ec9a437ea1e34913436307c0ee845f3f8c53d9fdfdbfd6037fa71aa6479a33e165a3111651d8
-  data.tar.gz: 910a844b6907a24914990a4697e74ceff60bddfc160464f43f83f0a7fd94eb10eb8a098afc696f35eee68603c26213432dba5ae573e3cc71f8a0fd464ae89d2a
+  metadata.gz: c38dca4384567fa492f8ecea2b357c4e72178bb70fcf1a1da9b3b932c56848f209e3c637ad5c40cb95bcb8b9e0a8017e389ea95e610cf45078108fff5bcbf49a
+  data.tar.gz: 8b2fe87f2f589c2af5ebb67a195d981cc4cf0c08c19f7090cbffe35fe270d56cd0ea6d6fa9dd304c444a8480b0793bba639787e7545bc84e18dd42fd9b7f22e3

data/README.md

@@ -5,7 +5,7 @@ MongoDB Ruby Driver
 
 The officially supported Ruby driver for [MongoDB](https://www.mongodb.org/).
 
-The Ruby driver supports Ruby 2.3-3.0 and JRuby 9.2.
+The Ruby driver supports Ruby 2.4-3.0 and JRuby 9.2.
 
 
 Documentation

data/lib/mongo/bulk_write.rb

@@ -66,7 +66,7 @@ module Mongo
           if single_statement?(operation)
             write_concern = write_concern(session)
             write_with_retry(session, write_concern) do |server, txn_num|
-              server.with_connection do |connection|
+              server.with_connection(service_id: context.service_id) do |connection|
                 execute_operation(
                   operation.keys.first,
                   operation.values.flatten,
@@ -80,7 +80,7 @@ module Mongo
             end
           else
             nro_write_with_retry(session, write_concern) do |server|
-              server.with_connection do |connection|
+              server.with_connection(service_id: context.service_id) do |connection|
                 execute_operation(
                   operation.keys.first,
                   operation.values.flatten,

data/lib/mongo/client.rb

@@ -67,6 +67,7 @@ module Mongo
       :database,
       :heartbeat_frequency,
       :id_generator,
+      :load_balanced,
       :local_threshold,
       :logger,
       :log_prefix,
@@ -243,7 +244,10 @@ module Mongo
     # @option options [ Symbol ] :connect Deprecated - use :direct_connection
     #   option instead of this option. The connection method to use. This
     #   forces the cluster to behave in the specified way instead of
-    #   auto-discovering. One of :direct, :replica_set, :sharded
+    #   auto-discovering. One of :direct, :replica_set, :sharded,
+    #   :load_balanced. If :connect is set to :load_balanced, the driver
+    #   will behave as if the server is a load balancer even if it isn't
+    #   connected to a load balancer.
     # @option options [ Float ] :connect_timeout The timeout, in seconds, to
     #   attempt a connection.
     # @option options [ String ] :database The database to connect to.
@@ -251,6 +255,8 @@ module Mongo
     #   for the server monitor to refresh its description via hello.
     # @option options [ Object ] :id_generator A custom object to generate ids
     #   for documents. Must respond to #generate.
+    # @option options [ true | false ] :load_balanced Whether to expect to
+    #   connect to a load balancer.
     # @option options [ Integer ] :local_threshold The local threshold boundary
     #   in seconds for selecting a near server for an operation.
     # @option options [ Logger ] :logger A custom logger to use.
@@ -1234,9 +1240,15 @@ module Mongo
         raise ArgumentError, "If :write and :write_concern are both given, they must be identical: #{options.inspect}"
       end
 
+      connect = options[:connect]&.to_sym
+
+      if connect && !%i(direct replica_set sharded load_balanced).include?(connect)
+        raise ArgumentError, "Invalid :connect option value: #{connect}"
+      end
+
       if options[:direct_connection]
-        if options[:connect] && options[:connect].to_sym != :direct
-          raise ArgumentError, "Conflicting client options: direct_connection=true and connect=#{options[:connect]}"
+        if connect && connect != :direct
+          raise ArgumentError, "Conflicting client options: direct_connection=true and connect=#{connect}"
         end
         # When a new client is created, we get the list of seed addresses
         if addresses && addresses.length > 1
@@ -1248,8 +1260,36 @@ module Mongo
         end
       end
 
-      if options[:direct_connection] == false && options[:connect] && options[:connect].to_sym == :direct
-        raise ArgumentError, "Conflicting client options: direct_connection=false and connect=#{options[:connect]}"
+      if options[:load_balanced]
+        if addresses && addresses.length > 1
+          raise ArgumentError, "load_balanced=true cannot be used with multiple seeds"
+        end
+
+        if options[:direct_connection]
+          raise ArgumentError, "direct_connection=true cannot be used with load_balanced=true"
+        end
+
+        if connect && connect != :load_balanced
+          raise ArgumentError, "connect=#{connect} cannot be used with load_balanced=true"
+        end
+
+        if options[:replica_set]
+          raise ArgumentError, "load_balanced=true cannot be used with replica_set option"
+        end
+      end
+
+      if connect == :load_balanced
+        if addresses && addresses.length > 1
+          raise ArgumentError, "connect=load_balanced cannot be used with multiple seeds"
+        end
+
+        if options[:replica_set]
+          raise ArgumentError, "connect=load_balanced cannot be used with replica_set option"
+        end
+      end
+
+      if options[:direct_connection] == false && connect && connect == :direct
+        raise ArgumentError, "Conflicting client options: direct_connection=false and connect=#{connect}"
       end
 
       %i(connect_timeout socket_timeout).each do |key|

data/lib/mongo/cluster/periodic_executor.rb

@@ -36,14 +36,15 @@ module Mongo
       #
       # @example Create a PeriodicExecutor.
       #   Mongo::Cluster::PeriodicExecutor.new([reaper, reaper2])
+      #
+      # @param [ Array<Object> ] executors The executors. Each must respond
+      #   to #execute and #flush.
       # @param [ Hash ] options The options.
       #
       # @option options [ Logger ] :logger A custom logger to use.
       #
       # @api private
-      #
-      # @since 2.5.0
-      def initialize(executors = [], options = {})
+      def initialize(executors, options = {})
         @thread = nil
         @executors = executors
         @stop_semaphore = Semaphore.new

data/lib/mongo/cluster/reapers/cursor_reaper.rb

@@ -28,42 +28,38 @@ module Mongo
     class CursorReaper
       include Retryable
 
-      # The default time interval for the cursor reaper to send pending kill cursors operations.
+      # The default time interval for the cursor reaper to send pending
+      # kill cursors operations.
       #
       # @since 2.3.0
       FREQUENCY = 1.freeze
 
       # Create a cursor reaper.
       #
-      # @example Create a CursorReaper.
-      #   Mongo::Cluster::CursorReaper.new(cluster)
+      # @param [ Cluster ] cluster The cluster.
       #
       # @api private
-      #
-      # @since 2.3.0
-      def initialize
+      def initialize(cluster)
+        @cluster = cluster
         @to_kill = {}
-        @active_cursors = Set.new
+        @active_cursor_ids = Set.new
         @mutex = Mutex.new
       end
 
+      attr_reader :cluster
+
       # Schedule a kill cursors operation to be eventually executed.
       #
-      # @example Schedule a kill cursors operation.
-      #   cursor_reaper.schedule_kill_cursor(id, op_spec, server)
-      #
-      # @param [ Integer ] id The id of the cursor to kill.
-      # @param [ Hash ] op_spec The spec for the kill cursors op.
-      # @param [ Mongo::Server ] server The server to send the kill cursors operation to.
+      # @param [ Cursor::KillSpec ] kill_spec The kill specification.
+      # @param [ Mongo::Server ] server The server to send the kill cursors
+      #   operation to.
       #
       # @api private
-      #
-      # @since 2.3.0
-      def schedule_kill_cursor(id, op_spec, server)
+      def schedule_kill_cursor(kill_spec, server)
         @mutex.synchronize do
-          if @active_cursors.include?(id)
-            @to_kill[server] ||= Set.new
-            @to_kill[server] << op_spec
+          if @active_cursor_ids.include?(kill_spec.cursor_id)
+            @to_kill[server.address.seed] ||= Set.new
+            @to_kill[server.address.seed] << kill_spec
           end
         end
       end
@@ -87,7 +83,7 @@ module Mongo
         end
 
         @mutex.synchronize do
-          @active_cursors << id
+          @active_cursor_ids << id
         end
       end
 
@@ -110,7 +106,7 @@ module Mongo
         end
 
         @mutex.synchronize do
-          @active_cursors.delete(id)
+          @active_cursor_ids.delete(id)
         end
       end
 
@@ -123,33 +119,70 @@ module Mongo
       #
       # @since 2.3.0
       def kill_cursors
-        to_kill_copy = {}
-        active_cursors_copy = []
+        # TODO optimize this to batch kill cursor operations for the same
+        # server/database/collection instead of killing each cursor
+        # individually.
 
-        @mutex.synchronize do
-          to_kill_copy = @to_kill.dup
-          active_cursors_copy = @active_cursors.dup
-          @to_kill = {}
-        end
+        loop do
+          server_address_str = nil
+
+          kill_spec = @mutex.synchronize do
+            # Find a server that has any cursors scheduled for destruction.
+            server_address_str, specs =
+              @to_kill.detect { |server_address_str, specs| specs.any? }
+
+            if specs.nil?
+              # All servers have empty specs, nothing to do.
+              return
+            end
+
+            # Note that this mutates the spec in the queue.
+            # If the kill cursor operation fails, we don't attempt to
+            # kill that cursor again.
+            spec = specs.take(1).tap do |arr|
+              specs.subtract(arr)
+            end.first
+
+            unless @active_cursor_ids.include?(spec.cursor_id)
+              # The cursor was already killed, typically because it has
+              # been iterated to completion. Remove the kill spec from
+              # our records without doing any more work.
+              spec = nil
+            end
+
+            spec
+          end
+
+          # If there was a spec to kill but its cursor was already killed,
+          # look for another spec.
+          next unless kill_spec
+
+          # We could also pass kill_spec directly into the KillCursors
+          # operation, though this would make that operation have a
+          # different API from all of the other ones which accept hashes.
+          spec = {
+            cursor_ids: [kill_spec.cursor_id],
+            coll_name: kill_spec.coll_name,
+            db_name: kill_spec.db_name,
+          }
+          op = Operation::KillCursors.new(spec)
+
+          server = cluster.servers.detect do |server|
+            server.address.seed == server_address_str
+          end
+
+          unless server
+            # TODO We currently don't have a server for the address that the
+            # cursor is associated with. We should leave the cursor in the
+            # queue to be killed at a later time (when the server comes back).
+            next
+          end
 
-        to_kill_copy.each do |server, op_specs|
           options = {
             server_api: server.options[:server_api],
+            service_id: kill_spec.service_id,
           }
-          context = Operation::Context.new(options: options)
-          op_specs.each do |op_spec|
-            if server.features.find_command_enabled?
-              Cursor::Builder::KillCursorsCommand.update_cursors(op_spec, active_cursors_copy.to_a)
-              if Cursor::Builder::KillCursorsCommand.get_cursors_list(op_spec).size > 0
-                Operation::KillCursors.new(op_spec).execute(server, context: context)
-              end
-            else
-              Cursor::Builder::OpKillCursors.update_cursors(op_spec, active_cursors_copy.to_a)
-              if Cursor::Builder::OpKillCursors.get_cursors_list(op_spec).size > 0
-                Operation::KillCursors.new(op_spec).execute(server, context: context)
-              end
-            end
-          end
+          op.execute(server, context: Operation::Context.new(options: options))
         end
       end
       alias :execute :kill_cursors

data/lib/mongo/cluster/sdam_flow.rb

@@ -105,6 +105,11 @@ class Mongo::Cluster
       end
 
       case topology
+      when Topology::LoadBalanced
+        @updated_desc = ::Mongo::Server::Description::LoadBalancer.new(
+          updated_desc.address,
+        )
+        update_server_descriptions
       when Topology::Single
         if topology.replica_set_name
           if updated_desc.replica_set_name != topology.replica_set_name
@@ -112,7 +117,7 @@ class Mongo::Cluster
               "Server #{updated_desc.address.to_s} has an incorrect replica set name '#{updated_desc.replica_set_name}'; expected '#{topology.replica_set_name}'"
             )
             @updated_desc = ::Mongo::Server::Description.new(updated_desc.address,
-              {}, updated_desc.average_round_trip_time)
+              {}, average_round_trip_time: updated_desc.average_round_trip_time)
             update_server_descriptions
           end
         end
@@ -229,7 +234,7 @@ class Mongo::Cluster
 
       if stale_primary?
         @updated_desc = ::Mongo::Server::Description.new(updated_desc.address,
-          {}, updated_desc.average_round_trip_time)
+          {}, average_round_trip_time: updated_desc.average_round_trip_time)
         update_server_descriptions
         check_if_has_primary
         return
@@ -258,7 +263,8 @@ class Mongo::Cluster
         if server.address != updated_desc.address
           if server.primary?
             server.update_description(::Mongo::Server::Description.new(
-              server.address, {}, server.description.average_round_trip_time))
+              server.address, {},
+              average_round_trip_time: server.description.average_round_trip_time))
           end
         end
       end

data/lib/mongo/cluster/topology/base.rb

@@ -67,17 +67,21 @@ module Mongo
             @server_descriptions[server.address.to_s] = server.description
           end
 
-          begin
-            server_descriptions.each do |address_str, desc|
-              unless desc.unknown?
-                desc.features.check_driver_support!
+          if is_a?(LoadBalanced)
+            @compatible = true
+          else
+            begin
+              server_descriptions.each do |address_str, desc|
+                unless desc.unknown?
+                  desc.features.check_driver_support!
+                end
               end
+            rescue Error::UnsupportedFeatures => e
+              @compatible = false
+              @compatibility_error = e
+            else
+              @compatible = true
             end
-          rescue Error::UnsupportedFeatures => e
-            @compatible = false
-            @compatibility_error = e
-          else
-            @compatible = true
           end
 
           @have_data_bearing_servers = false

data/lib/mongo/cluster/topology/load_balanced.rb

@@ -0,0 +1,102 @@
+# 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 Cluster
+    module Topology
+
+      # Defines behavior for when a cluster is in load-balanced topology.
+      class LoadBalanced < Base
+
+        # The display name for the topology.
+        NAME = 'LoadBalanced'.freeze
+
+        # Get the display name.
+        #
+        # @return [ String ] The display name.
+        def display_name
+          self.class.name.gsub(/.*::/, '')
+        end
+
+        # @note This method is experimental and subject to change.
+        #
+        # @api experimental
+        def summary
+          details = server_descriptions.keys.join(',')
+          "#{display_name}[#{details}]"
+        end
+
+        # Determine if the topology would select a readable server for the
+        # provided candidates and read preference.
+        #
+        # @param [ Cluster ] cluster The cluster.
+        # @param [ ServerSelector ] server_selector The server
+        #   selector.
+        #
+        # @return [ true ] A standalone always has a readable server.
+        def has_readable_server?(cluster, server_selector = nil); true; end
+
+        # Determine if the topology would select a writable server for the
+        # provided candidates.
+        #
+        # @param [ Cluster ] cluster The cluster.
+        #
+        # @return [ true ] A standalone always has a writable server.
+        def has_writable_server?(cluster); true; end
+
+        # Returns whether this topology is one of the replica set ones.
+        #
+        # @return [ false ] Always false.
+        def replica_set?; false; end
+
+        # Select appropriate servers for this topology.
+        #
+        # @param [ Array<Server> ] servers The known servers.
+        #
+        # @return [ Array<Server> ] All of the known servers.
+        def servers(servers, name = nil)
+          servers
+        end
+
+        # Returns whether this topology is sharded.
+        #
+        # @return [ false ] Always false.
+        def sharded?; false; end
+
+        # Returns whether this topology is Single.
+        #
+        # @return [ true ] Always false.
+        def single?; false; end
+
+        # Returns whether this topology is Unknown.
+        #
+        # @return [ false ] Always false.
+        def unknown?; false; end
+
+        private
+
+        def validate_options(options, cluster)
+          if cluster.servers_list.length > 1
+            raise ArgumentError, "Cannot instantiate a load-balanced topology with more than one server in the cluster: #{cluster.servers_list.map(&:address).map(&:seed).join(', ')}"
+          end
+
+          super(options, cluster)
+        end
+      end
+    end
+  end
+end

data/lib/mongo/cluster/topology.rb

@@ -38,6 +38,7 @@ end
 
 require 'mongo/cluster/topology/base'
 require 'mongo/cluster/topology/no_replica_set_options'
+require 'mongo/cluster/topology/load_balanced'
 require 'mongo/cluster/topology/replica_set_no_primary'
 require 'mongo/cluster/topology/replica_set_with_primary'
 require 'mongo/cluster/topology/sharded'
@@ -50,10 +51,12 @@ module Mongo
       # The various topologies for server selection.
       #
       # @since 2.0.0
+      # @api private
       OPTIONS = {
+        direct: Single,
+        load_balanced: LoadBalanced,
         replica_set: ReplicaSetNoPrimary,
         sharded: Sharded,
-        direct: Single,
       }.freeze
 
       # Get the initial cluster topology for the provided options.
@@ -71,26 +74,43 @@ module Mongo
       # @option options [ Symbol ] :connect Deprecated - use :direct_connection
       #   option instead of this option. The connection method to use. This
       #   forces the cluster to behave in the specified way instead of
-      #   auto-discovering. One of :direct, :replica_set, :sharded
+      #   auto-discovering. One of :direct, :replica_set, :sharded,
+      #   :load_balanced. If :connect is set to :load_balanced, the driver
+      #   will behave as if the server is a load balancer even if it isn't
+      #   connected to a load balancer.
+      # @option options [ true | false ] :load_balanced Whether to expect to
+      #   connect to a load balancer.
       # @option options [ Symbol ] :replica_set The name of the replica set to
       #   connect to. Servers not in this replica set will be ignored.
       #
-      # @return [ ReplicaSet, Sharded, Single ] The topology.
+      # @return [ ReplicaSet, Sharded, Single, LoadBalanced ] The topology.
       #
       # @since 2.0.0
       # @api private
       def initial(cluster, monitoring, options)
+        connect = options[:connect]&.to_sym
         cls = if options[:direct_connection]
-          if options[:connect] && options[:connect] && options[:connect].to_sym != :direct
-            raise ArgumentError, "Conflicting topology options: direct_connection=true and connect=#{options[:connect]}"
+          if connect && connect != :direct
+            raise ArgumentError, "Conflicting topology options: direct_connection=true and connect=#{connect}"
+          end
+          if options[:load_balanced]
+            raise ArgumentError, "Conflicting topology options: direct_connection=true and load_balanced=true"
           end
           Single
-        elsif options[:direct_connection] == false && options[:connect] && options[:connect].to_sym == :direct
-          raise ArgumentError, "Conflicting topology options: direct_connection=false and connect=#{options[:connect]}"
-        elsif options.key?(:connect)
+        elsif options[:direct_connection] == false && connect && connect == :direct
+          raise ArgumentError, "Conflicting topology options: direct_connection=false and connect=#{connect}"
+        elsif connect && connect != :load_balanced
+          if options[:load_balanced]
+            raise ArgumentError, "Conflicting topology options: connect=#{options[:connect].inspect} and load_balanced=true"
+          end
           OPTIONS.fetch(options[:connect].to_sym)
         elsif options.key?(:replica_set) || options.key?(:replica_set_name)
+          if options[:load_balanced]
+            raise ArgumentError, "Conflicting topology options: replica_set/replica_set_name and load_balanced=true"
+          end
           ReplicaSetNoPrimary
+        elsif options[:load_balanced] || connect == :load_balanced
+          LoadBalanced
         else
           Unknown
         end