mongo 2.15.1 → 2.16.0.alpha1

data/lib/mongo/cluster.rb

@@ -159,6 +159,10 @@ module Mongo
       @sdam_flow_lock = Mutex.new
       Session::SessionPool.create(self)
 
+      if seeds.empty? && load_balanced?
+        raise ArgumentError, 'Load-balanced clusters with no seeds are prohibited'
+      end
+
       # The opening topology is always unknown with no servers.
       # https://github.com/mongodb/specifications/pull/388
       opening_topology = Topology::Unknown.new(options, monitoring, self)
@@ -171,7 +175,7 @@ module Mongo
       @seeds = seeds = seeds.uniq
       servers = seeds.map do |seed|
         # Server opening events must be sent after topology change events.
-        # Therefore separate server addition, done here before topoolgy change
+        # Therefore separate server addition, done here before topology change
         # event is published, from starting to monitor the server which is
         # done later.
         add(seed, monitor: false)
@@ -179,11 +183,20 @@ module Mongo
 
       if seeds.size >= 1
         # Recreate the topology to get the current server list into it
-        @topology = topology.class.new(topology.options, topology.monitoring, self)
-        publish_sdam_event(
-          Monitoring::TOPOLOGY_CHANGED,
-          Monitoring::Event::TopologyChanged.new(opening_topology, @topology)
-        )
+        recreate_topology(topology, opening_topology)
+      end
+
+      if load_balanced?
+        # We are required by the specifications to produce certain SDAM events
+        # when in load-balanced topology.
+        # These events don't make a lot of sense from the standpoint of the
+        # driver's SDAM implementation, nor from the standpoint of the
+        # driver's load balancer implementation.
+        # They are just required boilerplate.
+        #
+        # Note that this call must be done above the monitoring_io check
+        # because that short-circuits the rest of the constructor.
+        fabricate_lb_sdam_events_and_set_server_type
       end
 
       if options[:monitoring_io] == false
@@ -203,7 +216,7 @@ module Mongo
       @connected = true
 
       if options[:cleanup] != false
-        @cursor_reaper = CursorReaper.new
+        @cursor_reaper = CursorReaper.new(self)
         @socket_reaper = SocketReaper.new(self)
         @periodic_executor = PeriodicExecutor.new([
           @cursor_reaper, @socket_reaper,
@@ -212,54 +225,56 @@ module Mongo
         @periodic_executor.run!
       end
 
-      # Need to record start time prior to starting monitoring
-      start_monotime = Utils.monotonic_time
-
-      servers.each do |server|
-        server.start_monitoring
-      end
+      unless load_balanced?
+        # Need to record start time prior to starting monitoring
+        start_monotime = Utils.monotonic_time
 
-      if options[:scan] != false
-        server_selection_timeout = options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
-        # The server selection timeout can be very short especially in
-        # tests, when the client waits for a synchronous scan before
-        # starting server selection. Limiting the scan to server selection time
-        # then aborts the scan before it can process even local servers.
-        # Therefore, allow at least 3 seconds for the scan here.
-        if server_selection_timeout < 3
-          server_selection_timeout = 3
+        servers.each do |server|
+          server.start_monitoring
         end
-        deadline = start_monotime + server_selection_timeout
-        # Wait for the first scan of each server to complete, for
-        # backwards compatibility.
-        # If any servers are discovered during this SDAM round we are going to
-        # wait for these servers to also be queried, and so on, up to the
-        # server selection timeout or the 3 second minimum.
-        loop do
-          # Ensure we do not try to read the servers list while SDAM is running
-          servers = @sdam_flow_lock.synchronize do
-            servers_list.dup
-          end
-          if servers.all? { |server| server.last_scan_monotime && server.last_scan_monotime >= start_monotime }
-            break
-          end
-          if (time_remaining = deadline - Utils.monotonic_time) <= 0
-            break
+
+        if options[:scan] != false
+          server_selection_timeout = options[:server_selection_timeout] || ServerSelector::SERVER_SELECTION_TIMEOUT
+          # The server selection timeout can be very short especially in
+          # tests, when the client waits for a synchronous scan before
+          # starting server selection. Limiting the scan to server selection time
+          # then aborts the scan before it can process even local servers.
+          # Therefore, allow at least 3 seconds for the scan here.
+          if server_selection_timeout < 3
+            server_selection_timeout = 3
           end
-          log_debug("Waiting for up to #{'%.2f' % time_remaining} seconds for servers to be scanned: #{summary}")
-          # Since the semaphore may have been signaled between us checking
-          # the servers list above and the wait call below, we should not
-          # wait for the full remaining time - wait for up to 1 second, then
-          # recheck the state.
-          begin
-            server_selection_semaphore.wait([time_remaining, 1].min)
-          rescue ::Timeout::Error
-            # nothing
+          deadline = start_monotime + server_selection_timeout
+          # Wait for the first scan of each server to complete, for
+          # backwards compatibility.
+          # If any servers are discovered during this SDAM round we are going to
+          # wait for these servers to also be queried, and so on, up to the
+          # server selection timeout or the 3 second minimum.
+          loop do
+            # Ensure we do not try to read the servers list while SDAM is running
+            servers = @sdam_flow_lock.synchronize do
+              servers_list.dup
+            end
+            if servers.all? { |server| server.last_scan_monotime && server.last_scan_monotime >= start_monotime }
+              break
+            end
+            if (time_remaining = deadline - Utils.monotonic_time) <= 0
+              break
+            end
+            log_debug("Waiting for up to #{'%.2f' % time_remaining} seconds for servers to be scanned: #{summary}")
+            # Since the semaphore may have been signaled between us checking
+            # the servers list above and the wait call below, we should not
+            # wait for the full remaining time - wait for up to 1 second, then
+            # recheck the state.
+            begin
+              server_selection_semaphore.wait([time_remaining, 1].min)
+            rescue ::Timeout::Error
+              # nothing
+            end
           end
         end
-      end
 
-      start_stop_srv_monitor
+        start_stop_srv_monitor
+      end
     end
 
     # Create a cluster for the provided client, for use when we don't want the
@@ -321,6 +336,14 @@ module Mongo
     def_delegators :topology, :replica_set?, :replica_set_name, :sharded?,
                    :single?, :unknown?
 
+    # Returns whether the cluster is configured to be in the load-balanced
+    # topology.
+    #
+    # @return [ true | false ] Whether the topology is load-balanced.
+    def load_balanced?
+      topology.is_a?(Topology::LoadBalanced)
+    end
+
     [:register_cursor, :schedule_kill_cursor, :unregister_cursor].each do |m|
       define_method(m) do |*args|
         if options[:cleanup] != false
@@ -599,9 +622,25 @@ module Mongo
     #   on 4.2+ servers).
     # @option aptions [ true | false ] :awaited Whether the updated description
     #   was a result of processing an awaited hello.
+    # @option options [ Object ] :service_id Change state for the specified
+    #   service id only.
     #
     # @api private
     def run_sdam_flow(previous_desc, updated_desc, options = {})
+      if load_balanced?
+        if updated_desc.config.empty?
+          unless options[:keep_connection_pool]
+            servers_list.each do |server|
+              # TODO should service id be taken out of updated_desc?
+              # We could also assert that
+              # options[:service_id] == updated_desc.service_id
+              server.clear_connection_pool(service_id: options[:service_id])
+            end
+          end
+        end
+        return
+      end
+
       @sdam_flow_lock.synchronize do
         flow = SdamFlow.new(self, previous_desc, updated_desc,
           awaited: options[:awaited])
@@ -782,8 +821,15 @@ module Mongo
     def add(host, add_options=nil)
       address = Address.new(host, options)
       if !addresses.include?(address)
-        server = Server.new(address, self, @monitoring, event_listeners, options.merge(
-          monitor: false))
+        opts = options.merge(monitor: false)
+        # Note that in a load-balanced topology, every server must be a
+        # load balancer (load_balancer: true is specified in the options)
+        # but this option isn't set here because we are required by the
+        # specifications to pretent the server started out as an unknown one
+        # and publish server description change event into the load balancer
+        # one. The actual correct description for this server will be set
+        # by the fabricate_lb_sdam_events_and_set_server_type method.
+        server = Server.new(address, self, @monitoring, event_listeners, opts)
         @update_lock.synchronize do
           # Need to recheck whether server is present in @servers, because
           # the previous check was not under a lock.
@@ -899,6 +945,10 @@ module Mongo
     #
     # @api private
     def validate_session_support!
+      if topology.is_a?(Topology::LoadBalanced)
+        return
+      end
+
       @state_change_lock.synchronize do
         @sdam_flow_lock.synchronize do
           if topology.data_bearing_servers?
@@ -982,6 +1032,41 @@ module Mongo
       msg = "The deployment that the driver is connected to does not support sessions: #{reason}"
       raise Error::SessionsNotSupported, msg
     end
+
+    def fabricate_lb_sdam_events_and_set_server_type
+      # Although there is no monitoring connection in load balanced mode,
+      # we must emit the following series of SDAM events.
+      server = @servers.first
+      # We are guaranteed to have the server here.
+      server.publish_opening_event
+      server_desc = server.description
+      # This is where a load balancer actually gets its correct server
+      # description.
+      server.update_description(
+        Server::Description.new(server.address, {},
+          load_balancer: true,
+          force_load_balancer: options[:connect] == :load_balanced,
+        )
+      )
+      publish_sdam_event(
+        Monitoring::SERVER_DESCRIPTION_CHANGED,
+        Monitoring::Event::ServerDescriptionChanged.new(
+          server.address,
+          topology,
+          server_desc,
+          server.description
+        )
+      )
+      recreate_topology(topology, topology)
+    end
+
+    def recreate_topology(new_topology_template, previous_topology)
+      @topology = topology.class.new(new_topology_template.options, new_topology_template.monitoring, self)
+      publish_sdam_event(
+        Monitoring::TOPOLOGY_CHANGED,
+        Monitoring::Event::TopologyChanged.new(previous_topology, @topology)
+      )
+    end
   end
 end
 

data/lib/mongo/collection/view/aggregation.rb

@@ -121,10 +121,12 @@ module Mongo
         end
 
         def valid_server?(server)
-          description = server.with_connection do |connection|
-            connection.description
+          if secondary_ok?
+            true
+          else
+            description = server.description
+            description.standalone? || description.mongos? || description.primary? || description.load_balancer?
           end
-          description.standalone? || description.mongos? || description.primary? || secondary_ok?
         end
 
         def secondary_ok?
@@ -136,16 +138,9 @@ module Mongo
             log_warn("Rerouting the Aggregation operation to the primary server - #{server.summary} is not suitable")
             server = cluster.next_primary(nil, session)
           end
-          validate_collation!(server)
           initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
-        def validate_collation!(server)
-          if options[:collation] && !server.with_connection { |connection| connection.features }.collation_enabled?
-            raise Error::UnsupportedCollation.new
-          end
-        end
-
         # Skip, sort, limit, projection are specified as pipeline stages
         # rather than as options.
         def cache_options

data/lib/mongo/collection/view/builder/aggregation.rb

@@ -79,11 +79,12 @@ module Mongo
           # @since 2.2.0
           def specification
             spec = {
-                    selector: aggregation_command,
-                    db_name: database.name,
-                    read: view.read_preference,
-                    session: @options[:session]
-                   }
+              selector: aggregation_command,
+              db_name: database.name,
+              read: view.read_preference,
+              session: @options[:session],
+              collation: @options[:collation],
+            }
             if write?
               spec.update(write_concern: write_concern)
             end

data/lib/mongo/collection/view/builder/map_reduce.rb

@@ -36,7 +36,7 @@ module Mongo
             scope: 'scope',
             verbose: 'verbose',
             bypass_document_validation: 'bypassDocumentValidation',
-            collation: 'collation'
+            collation: 'collation',
           ).freeze
 
           def_delegators :@view, :collection, :database, :filter, :read, :write_concern
@@ -71,36 +71,6 @@ module Mongo
             @options = options
           end
 
-          # Get the specification for issuing a find command on the map/reduce
-          # results.
-          #
-          # @example Get the command specification.
-          #   builder.command_specification
-          #
-          # @return [ Hash ] The specification.
-          #
-          # @since 2.2.0
-          def command_specification
-            {
-              selector: find_command,
-              db_name: query_database,
-              read: read,
-              session: options[:session]
-            }
-          end
-
-          # Get the specification for the document query after a map/reduce.
-          #
-          # @example Get the query specification.
-          #   builder.query_specification
-          #
-          # @return [ Hash ] The specification.
-          #
-          # @since 2.2.0
-          def query_specification
-            { selector: {}, options: {}, db_name: query_database, coll_name: query_collection }
-          end
-
           # Get the specification to pass to the map/reduce operation.
           #
           # @example Get the specification.
@@ -113,6 +83,8 @@ module Mongo
             spec = {
               selector: map_reduce_command,
               db_name: database.name,
+              # Note that selector just above may also have a read preference
+              # specified, per the #map_reduce_command method below.
               read: read,
               session: options[:session]
             }
@@ -121,8 +93,6 @@ module Mongo
 
           private
 
-          OUT_ACTIONS = [ :replace, :merge, :reduce ].freeze
-
           def write?(spec)
             if out = spec[:selector][:out]
               out.is_a?(String) ||
@@ -130,37 +100,30 @@ module Mongo
             end
           end
 
-          def find_command
-            BSON::Document.new('find' => query_collection, 'filter' => {})
-          end
-
           def map_reduce_command
             command = BSON::Document.new(
               :mapReduce => collection.name,
               :map => map,
               :reduce => reduce,
               :query => filter,
-              :out => { inline: 1 }
+              :out => { inline: 1 },
             )
+            # Shouldn't this use self.read ?
             if collection.read_concern
               command[:readConcern] = Options::Mapper.transform_values_to_strings(
                 collection.read_concern)
             end
-            command.merge!(view_options)
+            command.update(view_options)
+            command.update(Utils.slice_hash(options, :collation))
+            # Read preference isn't simply passed in the command payload
+            # (it may need to be converted to wire protocol flags)
+            # so remove it here and hopefully it's handled elsewhere.
+            # If not, RUBY-2706.
+            command.delete(:read)
             command.merge!(Options::Mapper.transform_documents(options, MAPPINGS))
             command
           end
 
-          def query_database
-            options[:out].respond_to?(:keys) && options[:out][:db] ? options[:out][:db] : database.name
-          end
-
-          def query_collection
-            if options[:out].respond_to?(:keys)
-              options[:out][OUT_ACTIONS.find { |action| options[:out][action] }]
-            end || options[:out]
-          end
-
           def view_options
             @view_options ||= (opts = view.options.dup
                                opts.delete(:session)

data/lib/mongo/collection/view/builder.rb

@@ -17,7 +17,3 @@
 
 require 'mongo/collection/view/builder/aggregation'
 require 'mongo/collection/view/builder/map_reduce'
-require 'mongo/collection/view/builder/op_query'
-require 'mongo/collection/view/builder/find_command'
-require 'mongo/collection/view/builder/flags'
-require 'mongo/collection/view/builder/modifiers'

data/lib/mongo/collection/view/iterable.rb

@@ -25,6 +25,13 @@ module Mongo
       # @since 2.0.0
       module Iterable
 
+        # Returns the cursor associated with this view, if any.
+        #
+        # @return [ nil | Cursor ] The cursor, if any.
+        #
+        # @api private
+        attr_reader :cursor
+
         # Iterate through documents returned by a query with this +View+.
         #
         # @example Iterate through the result of the view.
@@ -140,36 +147,53 @@ module Mongo
             projection: projection,
             collation: collation,
             read_concern: read_concern,
-            read_preference: read_preference
-
+            read_preference: read_preference,
           }
         end
 
         def initial_query_op(server, session)
-          if server.with_connection { |connection| connection.features }.find_command_enabled?
-            initial_command_op(session)
-          else
-            # Server versions that do not have the find command feature
-            # (versions older than 3.2) do not support the allow_disk_use option
-            # but perform no validation and will not raise an error if it is
-            # specified. If the allow_disk_use option is specified, raise an error
-            # to alert the user.
-            raise Error::UnsupportedOption.allow_disk_use_error if options.key?(:allow_disk_use)
-            Operation::Find.new(Builder::OpQuery.new(self).specification)
+          spec = {
+            coll_name: collection.name,
+            filter: filter,
+            projection: projection,
+            db_name: database.name,
+            session: session,
+            collation: collation,
+            sort: sort,
+            skip: skip,
+            limit: limit,
+            allow_disk_use: options[:allow_disk_use],
+            read: read,
+            read_concern: options[:read_concern] || read_concern,
+            batch_size: batch_size,
+            hint: options[:hint],
+            max_scan: options[:max_scan],
+            max_time_ms: options[:max_time_ms],
+            max_value: options[:max_value],
+            min_value: options[:min_value],
+            return_key: options[:return_key],
+            show_disk_loc: options[:show_disk_loc],
+            comment: options[:comment],
+            oplog_replay: if (v = options[:oplog_replay]).nil?
+              collection.options[:oplog_replay]
+            else
+              v
+            end,
+          }
+
+          if spec[:oplog_replay]
+            collection.client.log_warn("The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later")
           end
-        end
 
-        def initial_command_op(session)
-          builder = Builder::FindCommand.new(self, session)
           if explained?
-            Operation::Explain.new(builder.explain_specification)
+            spec[:explain] = options[:explain]
+            Operation::Explain.new(spec)
           else
-            Operation::Find.new(builder.specification)
+            Operation::Find.new(spec)
           end
         end
 
         def send_initial_query(server, session = nil)
-          validate_collation!(server, collation)
           initial_query_op(server, session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 

data/lib/mongo/collection/view/map_reduce.rb

@@ -156,6 +156,28 @@ module Mongo
           configure(:out, location)
         end
 
+        # Returns the collection name where the map-reduce result is written to.
+        # If the result is returned inline, returns nil.
+        def out_collection_name
+          if options[:out].respond_to?(:keys)
+            options[:out][OUT_ACTIONS.find do |action|
+              options[:out][action]
+            end]
+          end || options[:out]
+        end
+
+        # Returns the database name where the map-reduce result is written to.
+        # If the result is returned inline, returns nil.
+        def out_database_name
+          if options[:out]
+            if options[:out].respond_to?(:keys) && (db = options[:out][:db])
+              db
+            else
+              database.name
+            end
+          end
+        end
+
         # Set or get a scope on the operation.
         #
         # @example Set the scope value.
@@ -207,6 +229,8 @@ module Mongo
 
         private
 
+        OUT_ACTIONS = [ :replace, :merge, :reduce ].freeze
+
         def server_selector
           @view.send(:server_selector)
         end
@@ -228,10 +252,12 @@ module Mongo
         end
 
         def valid_server?(server)
-          description = server.with_connection do |connection|
-            connection.description
+          if secondary_ok?
+            true
+          else
+            description = server.description
+            description.standalone? || description.mongos? || description.primary? || description.load_balancer?
           end
-          description.standalone? || description.mongos? || description.primary? || secondary_ok?
         end
 
         def secondary_ok?
@@ -244,7 +270,6 @@ module Mongo
             log_warn(msg)
             server = cluster.next_primary(nil, session)
           end
-          validate_collation!(server)
           initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
@@ -257,22 +282,21 @@ module Mongo
         end
 
         def fetch_query_op(server, session)
-          if server.with_connection { |connection| connection.features }.find_command_enabled?
-            Operation::Find.new(find_command_spec(session))
-          else
-            Operation::Find.new(fetch_query_spec)
-          end
+          spec = {
+            coll_name: out_collection_name,
+            db_name: out_database_name,
+            filter: {},
+            session: session,
+            read: read,
+            read_concern: options[:read_concern] || collection.read_concern,
+            collation: options[:collation] || view.options[:collation],
+          }
+          Operation::Find.new(spec)
         end
 
         def send_fetch_query(server, session)
           fetch_query_op(server, session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
-
-        def validate_collation!(server)
-          if (view.options[:collation] || options[:collation]) && !server.with_connection { |connection| connection.features }.collation_enabled?
-            raise Error::UnsupportedCollation.new
-          end
-        end
       end
     end
   end