mongo 2.10.5 → 2.11.0.rc0

data/lib/mongo/cluster.rb

@@ -93,11 +93,15 @@ module Mongo
     #   to clean up server sessions when the cluster is disconnected, and to
     #   to not start the periodic executor. If :monitoring_io is false,
     #   :cleanup automatically defaults to false as well.
+    # @option options [ Float ] :heartbeat_frequency The interval, in seconds,
+    #   for the server monitor to refresh its description via ismaster.
+    # @option options [ Hash ] :resolv_options For internal driver use only.
+    #   Options to pass through to Resolv::DNS constructor for SRV lookups.
     #
     # @since 2.0.0
     def initialize(seeds, monitoring, options = Options::Redacted.new)
-      if options[:monitoring_io] != false && !options[:server_selection_semaphore]
-        raise ArgumentError, 'Need server selection semaphore'
+      if seeds.nil?
+        raise ArgumentError, 'Seeds cannot be nil'
       end
 
       if options[:monitoring_io] == false && !options.key?(:cleanup)
@@ -105,8 +109,6 @@ module Mongo
         options[:cleanup] = false
       end
 
-      seeds = seeds.uniq
-
       @servers = []
       @monitoring = monitoring
       @event_listeners = Event::Listeners.new
@@ -116,6 +118,8 @@ module Mongo
       @sdam_flow_lock = Mutex.new
       @cluster_time = nil
       @cluster_time_lock = Mutex.new
+      @srv_monitor_lock = Mutex.new
+      @server_selection_semaphore = Semaphore.new
       @topology = Topology.initial(self, monitoring, options)
       Session::SessionPool.create(self)
 
@@ -128,8 +132,6 @@ module Mongo
         Monitoring::Event::TopologyOpening.new(opening_topology)
       )
 
-      subscribe_to(Event::DESCRIPTION_CHANGED, Event::DescriptionChanged.new(self))
-
       @seeds = seeds
       servers = seeds.map do |seed|
         # Server opening events must be sent after topology change events.
@@ -148,27 +150,36 @@ module Mongo
         )
       end
 
-      servers.each do |server|
-        server.start_monitoring
-      end
-
       if options[:monitoring_io] == false
         # Omit periodic executor construction, because without servers
         # no commands can be sent to the cluster and there shouldn't ever
         # be anything that needs to be cleaned up.
         #
-        # Also omit legacy single round of SDAM on the main thread,
-        # as it would race with tests that mock SDAM responses.
+        # Omit monitoring individual servers and the legacy single round of
+        # of SDAM on the main thread, as it would race with tests that mock
+        # SDAM responses.
+        @connecting = @connected = false
         return
       end
 
+      # Need to record start time prior to starting monitoring
+      start_time = Time.now
+
+      servers.each do |server|
+        server.start_monitoring
+      end
+
       if options[:cleanup] != false
         @cursor_reaper = CursorReaper.new
         @socket_reaper = SocketReaper.new(self)
-        @periodic_executor = PeriodicExecutor.new(@cursor_reaper, @socket_reaper)
-        @periodic_executor.run!
+        @periodic_executor = PeriodicExecutor.new([
+          @cursor_reaper, @socket_reaper,
+        ], options)
+
+        ObjectSpace.define_finalizer(self, self.class.finalize(
+          {}, @periodic_executor, @session_pool))
 
-        ObjectSpace.define_finalizer(self, self.class.finalize({}, @periodic_executor, @session_pool))
+        @periodic_executor.run!
       end
 
       @connecting = false
@@ -184,7 +195,6 @@ module Mongo
         if server_selection_timeout < 3
           server_selection_timeout = 3
         end
-        start_time = Time.now
         deadline = start_time + server_selection_timeout
         # Wait for the first scan of each server to complete, for
         # backwards compatibility.
@@ -192,16 +202,26 @@ module Mongo
         # wait for these servers to also be queried, and so on, up to the
         # server selection timeout or the 3 second minimum.
         loop do
-          servers = servers_list.dup
-          if servers.all? { |server| server.description.last_update_time >= start_time }
+          # 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 && server.last_scan >= start_time }
             break
           end
           if (time_remaining = deadline - Time.now) <= 0
             break
           end
-          options[:server_selection_semaphore].wait(time_remaining)
+          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.
+          server_selection_semaphore.wait([time_remaining, 1].min)
         end
       end
+
+      start_stop_srv_monitor
     end
 
     # Create a cluster for the provided client, for use when we don't want the
@@ -265,6 +285,9 @@ module Mongo
       end
     end
 
+    # @api private
+    attr_reader :srv_monitor
+
     # Get the maximum number of times the client can retry a read operation
     # when using legacy read retries.
     #
@@ -301,6 +324,17 @@ module Mongo
       options[:read_retry_interval] || READ_RETRY_INTERVAL
     end
 
+    # Get the refresh interval for the server. This will be defined via an
+    # option or will default to 10.
+    #
+    # @return [ Float ] The heartbeat interval, in seconds.
+    #
+    # @since 2.10.0
+    # @api private
+    def heartbeat_interval
+      options[:heartbeat_frequency] || Server::Monitor::HEARTBEAT_FREQUENCY
+    end
+
     # Whether the cluster object is connected to its cluster.
     #
     # @return [ true|false ] Whether the cluster is connected.
@@ -369,9 +403,7 @@ module Mongo
     end
 
     # @api private
-    def server_selection_semaphore
-      options[:server_selection_semaphore]
-    end
+    attr_reader :server_selection_semaphore
 
     # Finalize the cluster for garbage collection.
     #
@@ -392,34 +424,35 @@ module Mongo
       end
     end
 
-    # Disconnect all servers.
+    # Closes the cluster.
     #
     # @note Applications should call Client#close to disconnect from
     # the cluster rather than calling this method. This method is for
     # internal driver use only.
     #
-    # @example Disconnect the cluster's servers.
-    #   cluster.disconnect!
-    #
-    # @param [ Boolean ] wait Whether to wait for background threads to
-    #   finish running.
+    # Disconnects all servers in the cluster, publishing appropriate SDAM
+    # events in the process. Stops SRV monitoring if it is active.
+    # Marks the cluster disconnected.
     #
     # @return [ true ] Always true.
     #
     # @since 2.1.0
-    def disconnect!(wait=false)
+    def disconnect!
       unless @connecting || @connected
         return true
       end
       if options[:cleanup] != false
-        if wait
-          session_pool.end_sessions
+        session_pool.end_sessions
+        @periodic_executor.stop!
+      end
+      @srv_monitor_lock.synchronize do
+        if @srv_monitor
+          @srv_monitor.stop!
         end
-        @periodic_executor.stop!(wait)
       end
       @servers.each do |server|
         if server.connected?
-          server.disconnect!(wait)
+          server.disconnect!
           publish_sdam_event(
             Monitoring::SERVER_CLOSED,
             Monitoring::Event::ServerClosed.new(server.address, topology)
@@ -481,16 +514,106 @@ module Mongo
     def scan!(sync=true)
       if sync
         servers_list.each do |server|
-          server.scan!
+          if server.monitor
+            server.monitor.scan!
+          else
+            log_warn("Synchronous scan requested on cluster #{summary} but server #{server} has no monitor")
+          end
         end
       else
         servers_list.each do |server|
-          server.monitor.scan_semaphore.signal
+          server.scan_semaphore.signal
         end
       end
       true
     end
 
+    # Runs SDAM flow on the cluster.
+    #
+    # This method can be invoked to process a new server description returned
+    # by the server on a monitoring or non-monitoring connection, and also
+    # by the driver when it marks a server unknown as a result of a (network)
+    # error.
+    #
+    # @param [ Server::Description ] previous_desc Previous server description.
+    # @param [ Server::Description ] updated_desc The changed description.
+    # @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).
+    #
+    # @api private
+    def run_sdam_flow(previous_desc, updated_desc, options = {})
+      @sdam_flow_lock.synchronize do
+        flow = SdamFlow.new(self, previous_desc, updated_desc)
+        flow.server_description_changed
+
+        # SDAM flow may alter the updated description - grab the final
+        # version for the purposes of broadcasting if a server is available
+        updated_desc = flow.updated_desc
+
+        unless options[:keep_connection_pool]
+          if flow.became_unknown?
+            servers_list.each do |server|
+              if server.address == updated_desc.address
+                server.clear_connection_pool
+              end
+            end
+          end
+        end
+
+        start_stop_srv_monitor
+      end
+
+      # Some updated descriptions, e.g. a mismatched me one, result in the
+      # server whose description we are processing being removed from
+      # the topology. When this happens, the server's monitoring thread gets
+      # killed. As a result, any code after the flow invocation may not run
+      # a particular monitor instance, hence there should generally not be
+      # any code in this method past the flow invocation.
+      #
+      # However, this broadcast call can be here because if the monitoring
+      # thread got killed the server should have been closed and no client
+      # should be currently waiting for it, thus not signaling the semaphore
+      # shouldn't cause any problems.
+      unless updated_desc.unknown?
+        server_selection_semaphore.broadcast
+      end
+    end
+
+    # Sets the list of servers to the addresses in the provided list of address
+    # strings.
+    #
+    # This method is called by the SRV monitor after receiving new DNS records
+    # for the monitored hostname.
+    #
+    # Removes servers in the cluster whose addresses are not in the passed
+    # list of server addresses, and adds servers for any addresses in the
+    # argument which are not already in the cluster.
+    #
+    # @param [ Array<String> ] server_address_strs List of server addresses
+    #    to sync the cluster servers to.
+    #
+    # @api private
+    def set_server_list(server_address_strs)
+      @sdam_flow_lock.synchronize do
+        server_address_strs.each do |address_str|
+          unless servers_list.any? { |server| server.address.seed == address_str }
+            add(address_str)
+          end
+        end
+
+        servers_list.each do |server|
+          unless server_address_strs.any? { |address_str| server.address.seed == address_str }
+            remove(server.address.seed)
+          end
+        end
+      end
+    end
+
     # Determine if this cluster of servers is equal to another object. Checks the
     # servers currently in the cluster, not what was configured.
     #
@@ -504,9 +627,7 @@ module Mongo
     # @since 2.0.0
     def ==(other)
       return false unless other.is_a?(Cluster)
-      addresses == other.addresses &&
-        options.merge(server_selection_semaphore: nil) ==
-          other.options.merge(server_selection_semaphore: nil)
+      addresses == other.addresses && options == other.options
     end
 
     # Determine if the cluster would select a readable server for the
@@ -657,9 +778,6 @@ module Mongo
       @update_lock.synchronize { @servers.dup }
     end
 
-    # @api private
-    attr_reader :sdam_flow_lock
-
     private
 
     # If options[:session] is set, validates that session and returns it.
@@ -706,7 +824,41 @@ module Mongo
         false
       end
     end
+
+    # @api private
+    def start_stop_srv_monitor
+      # SRV URI is either always given or not for a given cluster, if one
+      # wasn't given we shouldn't ever have an SRV monitor to manage.
+      return unless options[:srv_uri]
+
+      if topology.is_a?(Topology::Sharded) || topology.is_a?(Topology::Unknown)
+        # Start SRV monitor
+        @srv_monitor_lock.synchronize do
+          unless @srv_monitor
+            monitor_options = options.merge(
+              timeout: options[:connect_timeout] || Server::CONNECT_TIMEOUT)
+            @srv_monitor = _srv_monitor = SrvMonitor.new(self, monitor_options)
+            finalizer = lambda do
+              _srv_monitor.stop!
+            end
+            ObjectSpace.define_finalizer(self, finalizer)
+          end
+          @srv_monitor.run!
+        end
+      else
+        # Stop SRV monitor if running. This path is taken when the client
+        # is given an SRV URI to a standalone/replica set; when the topology
+        # is discovered, since it's not a sharded cluster, the SRV monitor
+        # needs to be stopped.
+        @srv_monitor_lock.synchronize do
+          if @srv_monitor
+            @srv_monitor.stop!
+          end
+        end
+      end
+    end
   end
 end
 
 require 'mongo/cluster/sdam_flow'
+require 'mongo/cluster/srv_monitor'

data/lib/mongo/cluster/periodic_executor.rb

@@ -22,6 +22,7 @@ module Mongo
     #
     # @since 2.5.0
     class PeriodicExecutor
+      include BackgroundThread
 
       # The default time interval for the periodic executor to execute.
       #
@@ -31,47 +32,43 @@ module Mongo
       # Create a periodic executor.
       #
       # @example Create a PeriodicExecutor.
-      #   Mongo::Cluster::PeriodicExecutor.new(reaper, reaper2)
+      #   Mongo::Cluster::PeriodicExecutor.new([reaper, reaper2])
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Logger ] :logger A custom logger to use.
       #
       # @api private
       #
       # @since 2.5.0
-      def initialize(*executors)
+      def initialize(executors = [], options = {})
         @thread = nil
         @executors = executors
+        @stop_semaphore = Semaphore.new
+        @options = options
       end
 
-      # Start the thread.
-      #
-      # @example Start the periodic executor's thread.
-      #   periodic_executor.run!
-      #
-      # @api private
-      #
-      # @since 2.5.0
-      def run!
-        @thread && @thread.alive? ? @thread : start!
-      end
+      attr_reader :options
+
       alias :restart! :run!
 
-      # Stop the executor's thread.
-      #
-      # @example Stop the executors's thread.
-      #   periodic_executor.stop!
-      #
-      # @param [ Boolean ] wait Whether to wait for background threads to
-      #   finish running.
-      #
-      # @api private
-      #
-      # @since 2.5.0
-      def stop!(wait=false)
-        begin; flush; rescue; end
-        @thread.kill
-        if wait
-          @thread.join
+      def do_work
+        execute
+        @stop_semaphore.wait(FREQUENCY)
+      end
+
+      def pre_stop
+        @stop_semaphore.signal
+      end
+
+      def stop(final = false)
+        super
+
+        begin
+          flush
+        rescue
         end
-        !@thread.alive?
+
+        true
       end
 
       # Trigger an execute call on each reaper.
@@ -83,7 +80,8 @@ module Mongo
       #
       # @since 2.5.0
       def execute
-        @executors.each(&:execute) and true
+        @executors.each(&:execute)
+        true
       end
 
       # Execute all pending operations.
@@ -95,18 +93,8 @@ module Mongo
       #
       # @since 2.5.0
       def flush
-        @executors.each(&:flush) and true
-      end
-
-      private
-
-      def start!
-        @thread = Thread.new(FREQUENCY) do |i|
-          loop do
-            sleep(i)
-            execute
-          end
-        end
+        @executors.each(&:flush)
+        true
       end
     end
   end