mongo 2.22.0 → 2.24.0

data/lib/mongo/server/monitor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   class Server
-
     # Responsible for periodically polling a server via hello commands to
     # keep the server's status up to date.
     #
@@ -35,19 +33,19 @@ module Mongo
       # The default interval between server status refreshes is 10 seconds.
       #
       # @since 2.0.0
-      DEFAULT_HEARTBEAT_INTERVAL = 10.freeze
+      DEFAULT_HEARTBEAT_INTERVAL = 10
 
       # The minimum time between forced server scans. Is
       # minHeartbeatFrequencyMS in the SDAM spec.
       #
       # @since 2.0.0
-      MIN_SCAN_INTERVAL = 0.5.freeze
+      MIN_SCAN_INTERVAL = 0.5
 
       # The weighting factor (alpha) for calculating the average moving round trip time.
       #
       # @since 2.0.0
       # @deprecated Will be removed in version 3.0.
-      RTT_WEIGHT_FACTOR = 0.2.freeze
+      RTT_WEIGHT_FACTOR = 0.2
 
       # Create the new server monitor.
       #
@@ -58,7 +56,7 @@ module Mongo
       #
       # @param [ Server ] server The server to monitor.
       # @param [ Event::Listeners ] event_listeners The event listeners.
-      # @param [ Monitoring ] monitoring The monitoring..
+      # @param [ Monitoring ] monitoring The monitoring.
       # @param [ Hash ] options The options.
       #
       # @option options [ Float ] :connect_timeout The timeout, in seconds, to
@@ -76,15 +74,10 @@ module Mongo
       # @since 2.0.0
       # @api private
       def initialize(server, event_listeners, monitoring, options = {})
-        unless monitoring.is_a?(Monitoring)
-          raise ArgumentError, "Wrong monitoring type: #{monitoring.inspect}"
-        end
-        unless options[:app_metadata]
-          raise ArgumentError, 'App metadata is required'
-        end
-        unless options[:push_monitor_app_metadata]
-          raise ArgumentError, 'Push monitor app metadata is required'
-        end
+        raise ArgumentError, "Wrong monitoring type: #{monitoring.inspect}" unless monitoring.is_a?(Monitoring)
+        raise ArgumentError, 'App metadata is required' unless options[:app_metadata]
+        raise ArgumentError, 'Push monitor app metadata is required' unless options[:push_monitor_app_metadata]
+
         @server = server
         @event_listeners = event_listeners
         @monitoring = monitoring
@@ -142,14 +135,10 @@ module Mongo
         # thread exits when requested.
         loop do
           delta = @next_wanted_scan - Time.now
-          if delta > 0
-            signaled = server.scan_semaphore.wait(delta)
-            if signaled || @stop_requested
-              break
-            end
-          else
-            break
-          end
+          break unless delta > 0
+
+          signaled = server.scan_semaphore.wait(delta)
+          break if signaled || @stop_requested
         end
       end
 
@@ -172,19 +161,17 @@ module Mongo
 
       def create_push_monitor!(topology_version)
         @update_mutex.synchronize do
-          if @push_monitor && !@push_monitor.running?
-            @push_monitor = nil
-          end
+          @push_monitor = nil if @push_monitor && !@push_monitor.running?
 
           @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
-            )),
+                                             socket_timeout: heartbeat_interval + connection.socket_timeout,
+                                             app_metadata: options[:push_monitor_app_metadata],
+                                             check_document: @connection.check_document
+                                           ))
           )
         end
       end
@@ -225,7 +212,7 @@ module Mongo
 
           begin
             result = do_scan
-          rescue => e
+          rescue StandardError => e
             run_sdam_flow({}, scan_error: e)
           else
             run_sdam_flow(result)
@@ -286,19 +273,16 @@ module Mongo
       end
 
       def do_scan
-        begin
-          monitoring.publish_heartbeat(server) do
-            check
-          end
-        rescue => exc
-          msg = "Error checking #{server.address}"
-          Utils.warn_bg_exception(msg, exc,
-            logger: options[:logger],
-            log_prefix: options[:log_prefix],
-            bg_error_backtrace: options[:bg_error_backtrace],
-          )
-          raise exc
+        monitoring.publish_heartbeat(server) do
+          check
         end
+      rescue StandardError => e
+        msg = "Error checking #{server.address}"
+        Utils.warn_bg_exception(msg, e,
+                                logger: options[:logger],
+                                log_prefix: options[:log_prefix],
+                                bg_error_backtrace: options[:bg_error_backtrace])
+        raise e
       end
 
       def check
@@ -310,18 +294,16 @@ module Mongo
 
         if @connection
           result = server.round_trip_time_calculator.measure do
-            begin
-              doc = @connection.check_document
-              cmd = Protocol::Query.new(
-                Database::ADMIN, Database::COMMAND, doc, :limit => -1
-              )
-              message = @connection.dispatch_bytes(cmd.serialize.to_s)
-              message.documents.first
-            rescue Mongo::Error
-              @connection.disconnect!
-              @connection = nil
-              raise
-            end
+            doc = @connection.check_document
+            cmd = Protocol::Query.new(
+              Database::ADMIN, Database::COMMAND, doc, limit: -1
+            )
+            message = @connection.dispatch_bytes(cmd.serialize.to_s)
+            message.documents.first
+          rescue Mongo::Error
+            @connection.disconnect!
+            @connection = nil
+            raise
           end
         else
           connection = Connection.new(server.address, options)
@@ -331,9 +313,12 @@ module Mongo
           end
           @connection = connection
           if tv_doc = result['topologyVersion']
-            # Successful response, server 4.4+
-            create_push_monitor!(TopologyVersion.new(tv_doc))
-            push_monitor.run!
+            if streaming_enabled?
+              create_push_monitor!(TopologyVersion.new(tv_doc))
+              push_monitor.run!
+            else
+              stop_push_monitor!
+            end
           else
             # Failed response or pre-4.4 server
             stop_push_monitor!
@@ -347,8 +332,28 @@ module Mongo
       #   can sleep for a very long time.
       def throttle_scan_frequency!
         delta = @next_earliest_scan - Time.now
-        if delta > 0
-          sleep(delta)
+        return unless delta > 0
+
+        sleep(delta)
+      end
+
+      # Returns whether the streaming protocol is enabled, based on the
+      # serverMonitoringMode option. Default mode is :auto.
+      #
+      # - :stream - always use streaming when server supports it
+      # - :poll - never use streaming
+      # - :auto - use polling on FaaS platforms, streaming otherwise
+      #
+      # @return [ true | false ] Whether streaming is enabled.
+      def streaming_enabled?
+        mode = options[:server_monitoring_mode] || :auto
+        case mode
+        when :poll
+          false
+        when :stream
+          true
+        when :auto
+          !Server::AppMetadata::Environment.new.faas?
         end
       end
     end

data/lib/mongo/server/pending_connection.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2019-2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   class Server
-
     # This class encapsulates connections during handshake and authentication.
     #
     # @api private
@@ -44,6 +42,7 @@ module Mongo
           # but at this point we don't know the mechanism that ultimately
           # will be used (since this depends on the data returned by
           # the handshake, specifically server version).
+          #
           # However, we know that only 4.4+ servers support speculative
           # authentication, and those servers also generally support
           # SCRAM-SHA-256. We expect that user accounts created for 4.4+
@@ -51,15 +50,17 @@ module Mongo
           # user accounts migrated from pre-4.4 servers may only allow
           # SCRAM-SHA-1. The use of SCRAM-SHA-256 by default is thus
           # sensible, and it is also mandated by the speculative auth spec.
-          # If no mechanism was specified and we are talking to a 3.0+
+          #
+          # If no mechanism was specified and we are talking to a 4.2
           # server, we'll send speculative auth document, the server will
           # ignore it and we'll perform authentication using explicit
-          # command after having defaulted the mechanism later to CR.
+          # command.
+          #
           # If no mechanism was specified and we are talking to a 4.4+
           # server and the user account doesn't allow SCRAM-SHA-256, we will
           # authenticate in a separate command with SCRAM-SHA-1 after
           # going through SCRAM mechanism negotiation.
-          default_options = Options::Redacted.new(:auth_mech => :scram256)
+          default_options = Options::Redacted.new(auth_mech: :scram256)
           speculative_auth_user = Auth::User.new(default_options.merge(options))
           speculative_auth = Auth.get(speculative_auth_user, self)
           speculative_auth_doc = speculative_auth.conversation.speculative_auth_document
@@ -68,17 +69,15 @@ module Mongo
         result = handshake!(speculative_auth_doc: speculative_auth_doc)
 
         if description.unknown?
-          raise Error::InternalDriverError, "Connection description cannot be unknown after successful handshake: #{description.inspect}"
+          raise Error::InternalDriverError,
+                "Connection description cannot be unknown after successful handshake: #{description.inspect}"
         end
 
         begin
           if speculative_auth_doc && (speculative_auth_result = result['speculativeAuthenticate'])
-            unless description.features.scram_sha_1_enabled?
-              raise Error::InvalidServerAuthResponse, "Speculative auth succeeded on a pre-3.0 server"
-            end
             case speculative_auth_user.mechanism
             when :mongodb_x509
-              # Done
+            # Done
             # We default auth mechanism to scram256, but if user specified
             # scram explicitly we may be able to authenticate speculatively
             # with scram.
@@ -86,26 +85,31 @@ module Mongo
               authenticate!(
                 speculative_auth_client_nonce: speculative_auth.conversation.client_nonce,
                 speculative_auth_mech: speculative_auth_user.mechanism,
-                speculative_auth_result: speculative_auth_result,
+                speculative_auth_result: speculative_auth_result
               )
             else
-              raise Error::InternalDriverError, "Speculative auth unexpectedly succeeded for mechanism #{speculative_auth_user.mechanism.inspect}"
+              raise Error::InternalDriverError,
+                    "Speculative auth unexpectedly succeeded for mechanism #{speculative_auth_user.mechanism.inspect}"
             end
           elsif !description.arbiter?
             authenticate!
           end
-        rescue Mongo::Error, Mongo::Error::AuthError => exc
-          exc.service_id = service_id
+        rescue Mongo::Error, Mongo::Error::AuthError => e
+          e.service_id = service_id
           raise
         end
 
         if description.unknown?
-          raise Error::InternalDriverError, "Connection description cannot be unknown after successful authentication: #{description.inspect}"
+          raise Error::InternalDriverError,
+                "Connection description cannot be unknown after successful authentication: #{description.inspect}"
         end
 
-        if server.load_balancer? && !description.mongos?
-          raise Error::BadLoadBalancerTarget, "Load-balanced operation requires being connected a mongos, but the server at #{address.seed} reported itself as #{description.server_type.to_s.gsub('_', ' ')}"
-        end
+        return unless server.load_balancer? && !description.mongos?
+
+        raise Error::BadLoadBalancerTarget,
+              "Load-balanced operation requires being connected a mongos, but the server at #{address.seed} reported itself as #{description.server_type.to_s.tr(
+                '_', ' '
+              )}"
       end
 
       private
@@ -148,25 +152,31 @@ module Mongo
         )
         doc = nil
         @server.handle_handshake_failure! do
-          begin
-            response = get_handshake_response(hello_command)
-            result = Operation::Result.new([response])
-            result.validate!
-            doc = result.documents.first
-          rescue => exc
-            msg = "Failed to handshake with #{address}"
-            Utils.warn_bg_exception(msg, exc,
-              logger: options[:logger],
-              log_prefix: options[:log_prefix],
-              bg_error_backtrace: options[:bg_error_backtrace],
-            )
-            raise
+          response = get_handshake_response(hello_command)
+          result = Operation::Result.new([ response ])
+          result.validate!
+          doc = result.documents.first
+        rescue StandardError => e
+          msg = "Failed to handshake with #{address}"
+          Utils.warn_bg_exception(msg, e,
+                                  logger: options[:logger],
+                                  log_prefix: options[:log_prefix],
+                                  bg_error_backtrace: options[:bg_error_backtrace])
+          # The SystemOverloadedError label marks errors as back-pressure
+          # signals that should not cause the server to be marked Unknown.
+          # Per the SDAM spec, this label only applies to network errors
+          # during the handshake. Command errors (e.g. OperationFailure
+          # with "node is shutting down" codes) must still flow through
+          # normal SDAM error handling so the server is marked Unknown
+          # and the pool is cleared.
+          if e.is_a?(::Mongo::Error) && (e.is_a?(Error::SocketError) || e.is_a?(Error::SocketTimeoutError))
+            e.add_label('SystemOverloadedError')
+            e.add_label('RetryableError')
           end
+          raise
         end
 
-        if @server.force_load_balancer?
-          doc['serviceId'] ||= "fake:#{rand(2**32-1)+1}"
-        end
+        doc['serviceId'] ||= "fake:#{rand((2**32) - 1) + 1}" if @server.force_load_balancer?
 
         post_handshake(
           doc,
@@ -191,26 +201,23 @@ module Mongo
         speculative_auth_mech: nil,
         speculative_auth_result: nil
       )
-        if options[:user] || options[:auth_mech]
-          @server.handle_auth_failure! do
-            begin
-              auth = Auth.get(
-                resolved_user(speculative_auth_mech: speculative_auth_mech),
-                self,
-                speculative_auth_client_nonce: speculative_auth_client_nonce,
-                speculative_auth_result: speculative_auth_result,
-              )
-              auth.login
-            rescue => exc
-              msg = "Failed to authenticate to #{address}"
-              Utils.warn_bg_exception(msg, exc,
-                logger: options[:logger],
-                log_prefix: options[:log_prefix],
-                bg_error_backtrace: options[:bg_error_backtrace],
-              )
-              raise
-            end
-          end
+        return unless options[:user] || options[:auth_mech]
+
+        @server.handle_auth_failure! do
+          auth = Auth.get(
+            resolved_user(speculative_auth_mech: speculative_auth_mech),
+            self,
+            speculative_auth_client_nonce: speculative_auth_client_nonce,
+            speculative_auth_result: speculative_auth_result
+          )
+          auth.login
+        rescue StandardError => e
+          msg = "Failed to authenticate to #{address}"
+          Utils.warn_bg_exception(msg, e,
+                                  logger: options[:logger],
+                                  log_prefix: options[:log_prefix],
+                                  bg_error_backtrace: options[:bg_error_backtrace])
+          raise
         end
       end
 
@@ -222,8 +229,8 @@ module Mongo
       #
       # @return [ Server::Description ] The server description calculated from
       #   the handshake response for this particular connection.
-      def post_handshake(response, average_rtt, minimum_rtt)
-        if response["ok"] == 1
+      def post_handshake(response, average_rtt, _minimum_rtt)
+        if response['ok'] == 1
           # Auth mechanism is entirely dependent on the contents of
           # hello response *for this connection*.
           # Hello received by the monitoring connection should advertise
@@ -242,7 +249,7 @@ module Mongo
           address, response,
           average_round_trip_time: average_rtt,
           load_balancer: server.load_balancer?,
-          force_load_balancer: options[:connect] == :load_balanced,
+          force_load_balancer: options[:connect] == :load_balanced
         ).tap do |new_description|
           @server.cluster.run_sdam_flow(@server.description, new_description)
         end
@@ -276,28 +283,20 @@ module Mongo
             # that is what the conversation was started with, even though
             # SCRAM mechanism negotiation did not return SCRAM-SHA-256 as a
             # valid mechanism to use for these credentials.
-            :auth_mech => speculative_auth_mech || default_mechanism,
+            auth_mech: speculative_auth_mech || default_mechanism
           ).merge(options)
-          if user_options[:auth_mech] == :mongodb_x509
-            user_options[:auth_source] = '$external'
-          end
+          user_options[:auth_source] = '$external' if user_options[:auth_mech] == :mongodb_x509
           Auth::User.new(user_options)
         end
       end
 
       def default_mechanism
-        if description.nil?
-          raise Mongo::Error, 'Trying to query default mechanism when handshake has not completed'
-        end
+        raise Mongo::Error, 'Trying to query default mechanism when handshake has not completed' if description.nil?
 
-        if description.features.scram_sha_1_enabled?
-          if @sasl_supported_mechanisms&.include?('SCRAM-SHA-256')
-            :scram256
-          else
-            :scram
-          end
+        if @sasl_supported_mechanisms&.include?('SCRAM-SHA-256')
+          :scram256
         else
-          :mongodb_cr
+          :scram
         end
       end
     end

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB Inc.
 #
@@ -18,10 +17,8 @@
 module Mongo
   class Server
     class PushMonitor
-
       # @api private
       class Connection < Server::Monitor::Connection
-
         def socket_timeout
           options[:socket_timeout]
         end

data/lib/mongo/server/push_monitor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   class Server
-
     # A monitor utilizing server-pushed hello requests.
     #
     # When a Monitor handshakes with a 4.4+ server, it creates an instance
@@ -33,15 +31,10 @@ module Mongo
       include BackgroundThread
 
       def initialize(monitor, topology_version, monitoring, **options)
-        if topology_version.nil?
-          raise ArgumentError, 'Topology version must be provided but it was nil'
-        end
-        unless options[:app_metadata]
-          raise ArgumentError, 'App metadata is required'
-        end
-        unless options[:check_document]
-          raise ArgumentError, 'Check document is required'
-        end
+        raise ArgumentError, 'Topology version must be provided but it was nil' if topology_version.nil?
+        raise ArgumentError, 'App metadata is required' unless options[:app_metadata]
+        raise ArgumentError, 'Check document is required' unless options[:check_document]
+
         @app_metadata = options[:app_metadata]
         @check_document = options[:check_document]
         @monitor = monitor
@@ -78,7 +71,11 @@ module Mongo
           if @connection
             # Interrupt any in-progress exhausted hello reads by
             # disconnecting the connection.
-            @connection.send(:socket).close rescue nil
+            begin
+              @connection.send(:socket).close
+            rescue StandardError
+              nil
+            end
           end
         end
         super.tap do
@@ -107,10 +104,8 @@ module Mongo
         # https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-monitoring.md#streamable-hello-or-legacy-hello-command
         # says that topologyVersion should only be updated from successful
         # hello responses.
-        if new_description.topology_version
-          @topology_version = new_description.topology_version
-        end
-      rescue IOError, SocketError, SystemCallError, Mongo::Error => exc
+        @topology_version = new_description.topology_version if new_description.topology_version
+      rescue IOError, SocketError, SystemCallError, Mongo::Error => e
         stop_requested = @lock.synchronize { @stop_requested }
         if stop_requested
           # Ignore the exception, see RUBY-2771.
@@ -118,11 +113,10 @@ module Mongo
         end
 
         msg = "Error running awaited hello on #{server.address}"
-        Utils.warn_bg_exception(msg, exc,
-          logger: options[:logger],
-          log_prefix: options[:log_prefix],
-          bg_error_backtrace: options[:bg_error_backtrace],
-        )
+        Utils.warn_bg_exception(msg, e,
+                                logger: options[:logger],
+                                log_prefix: options[:log_prefix],
+                                bg_error_backtrace: options[:bg_error_backtrace])
 
         # If a request failed on a connection, stop push monitoring.
         # In case the server is dead we don't want to have two connections
@@ -153,9 +147,7 @@ module Mongo
         end
 
         resp_msg = begin
-          unless @server_pushing
-            write_check_command
-          end
+          write_check_command unless @server_pushing
           read_response
         rescue Mongo::Error
           @lock.synchronize do
@@ -173,10 +165,10 @@ module Mongo
       def write_check_command
         document = @check_document.merge(
           topologyVersion: topology_version.to_doc,
-          maxAwaitTimeMS: monitor.heartbeat_interval * 1000,
+          maxAwaitTimeMS: monitor.heartbeat_interval * 1000
         )
         command = Protocol::Msg.new(
-          [:exhaust_allowed], {}, document.merge({'$db' => Database::ADMIN})
+          [ :exhaust_allowed ], {}, document.merge({ '$db' => Database::ADMIN })
         )
         @lock.synchronize { @connection }.write_bytes(command.serialize.to_s)
       end
@@ -184,14 +176,15 @@ module Mongo
       def read_response
         if timeout = options[:connect_timeout]
           if timeout < 0
-            raise Mongo::SocketTimeoutError, "Requested to read with a negative timeout: #{}"
+            raise Mongo::SocketTimeoutError, 'Requested to read with a negative timeout: '
           elsif timeout > 0
             timeout += options[:heartbeat_frequency] || Monitor::DEFAULT_HEARTBEAT_INTERVAL
           end
         end
         # We set the timeout twice: once passed into read_socket which applies
         # to each individual read operation, and again around the entire read.
-        Timeout.timeout(timeout, Error::SocketTimeoutError, "Failed to read an awaited hello response in #{timeout} seconds") do
+        Timeout.timeout(timeout, Error::SocketTimeoutError,
+                        "Failed to read an awaited hello response in #{timeout} seconds") do
           @lock.synchronize { @connection }.read_response(socket_timeout: timeout)
         end
       end
@@ -199,7 +192,6 @@ module Mongo
       def to_s
         "#<#{self.class.name}:#{object_id} #{server.address}>"
       end
-
     end
   end
 end

data/lib/mongo/server/round_trip_time_calculator.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2018-2020 MongoDB Inc.
 
@@ -19,10 +18,9 @@ module Mongo
   class Server
     # @api private
     class RoundTripTimeCalculator
-
       # The weighting factor (alpha) for calculating the average moving
       # round trip time.
-      RTT_WEIGHT_FACTOR = 0.2.freeze
+      RTT_WEIGHT_FACTOR = 0.2
       private_constant :RTT_WEIGHT_FACTOR
 
       RTT_SAMPLES_FOR_MINIMUM = 10
@@ -39,9 +37,7 @@ module Mongo
         @rtts = []
       end
 
-      attr_reader :last_round_trip_time
-      attr_reader :average_round_trip_time
-      attr_reader :minimum_round_trip_time
+      attr_reader :last_round_trip_time, :average_round_trip_time, :minimum_round_trip_time
 
       def measure
         start = Utils.monotonic_time
@@ -51,7 +47,7 @@ module Mongo
           # If we encountered a network error, the round-trip is not
           # complete and thus RTT for it does not make sense.
           raise
-        rescue Error, Error::AuthError => exc
+        rescue Error, Error::AuthError => e
           # For other errors, RTT is valid.
         end
         last_rtt = Utils.monotonic_time - start
@@ -59,7 +55,7 @@ module Mongo
         # If hello fails, we need to return the last round trip time
         # because it is used in the heartbeat failed SDAM event,
         # but we must not update the round trip time recorded in the server.
-        unless exc
+        unless e
           @last_round_trip_time = last_rtt
           @lock.synchronize do
             update_average_round_trip_time
@@ -67,19 +63,17 @@ module Mongo
           end
         end
 
-        if exc
-          raise exc
-        else
-          rv
-        end
+        raise e if e
+
+        rv
       end
 
       def update_average_round_trip_time
         @average_round_trip_time = if average_round_trip_time
-          RTT_WEIGHT_FACTOR * last_round_trip_time + (1 - RTT_WEIGHT_FACTOR) * average_round_trip_time
-        else
-          last_round_trip_time
-        end
+                                     (RTT_WEIGHT_FACTOR * last_round_trip_time) + ((1 - RTT_WEIGHT_FACTOR) * average_round_trip_time)
+                                   else
+                                     last_round_trip_time
+                                   end
       end
 
       def update_minimum_round_trip_time