mongo 2.23.0 → 2.24.1

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2015-2020 MongoDB Inc.
 #
@@ -18,7 +17,6 @@
 module Mongo
   class Server
     class Monitor
-
       # This class models the monitor connections and their behavior.
       #
       # @since 2.0.0
@@ -58,9 +56,8 @@ module Mongo
         def initialize(address, options = {})
           @address = address
           @options = options.dup.freeze
-          unless @app_metadata = options[:app_metadata]
-            raise ArgumentError, 'App metadata is required'
-          end
+          raise ArgumentError, 'App metadata is required' unless @app_metadata = options[:app_metadata]
+
           @socket = nil
           @pid = Process.pid
           @compressor = nil
@@ -109,14 +106,12 @@ module Mongo
         def dispatch_bytes(bytes, **opts)
           write_bytes(bytes)
           read_response(
-            socket_timeout: opts[:read_socket_timeout],
+            socket_timeout: opts[:read_socket_timeout]
           )
         end
 
         def write_bytes(bytes)
-          unless connected?
-            raise ArgumentError, "Trying to dispatch on an unconnected connection #{self}"
-          end
+          raise ArgumentError, "Trying to dispatch on an unconnected connection #{self}" unless connected?
 
           add_server_connection_id do
             add_server_diagnostics do
@@ -128,16 +123,14 @@ module Mongo
         # @option opts [ Numeric ] :socket_timeout The timeout to use for
         #   each read operation.
         def read_response(**opts)
-          unless connected?
-            raise ArgumentError, "Trying to read on an unconnected connection #{self}"
-          end
+          raise ArgumentError, "Trying to read on an unconnected connection #{self}" unless connected?
 
           add_server_connection_id do
             add_server_diagnostics do
               Protocol::Message.deserialize(socket,
-                Protocol::Message::MAX_MESSAGE_SIZE,
-                nil,
-                **opts)
+                                            Protocol::Message::MAX_MESSAGE_SIZE,
+                                            nil,
+                                            **opts)
             end
           end
         end
@@ -156,13 +149,12 @@ module Mongo
         #
         # @since 2.0.0
         def connect!
-          if @socket
-            raise ArgumentError, 'Monitoring connection already connected'
-          end
+          raise ArgumentError, 'Monitoring connection already connected' if @socket
 
           @socket = add_server_diagnostics do
             address.socket(socket_timeout, ssl_options.merge(
-              connection_address: address, monitor: true))
+                                             connection_address: address, monitor: true
+                                           ))
           end
           true
         end
@@ -181,9 +173,13 @@ module Mongo
         # @return [ true ] If the disconnect succeeded.
         #
         # @since 2.0.0
-        def disconnect!(options = nil)
+        def disconnect!(_options = nil)
           if socket
-            socket.close rescue nil
+            begin
+              socket.close
+            rescue StandardError
+              nil
+            end
             @socket = nil
           end
           true
@@ -210,13 +206,12 @@ module Mongo
           set_hello_ok!(reply)
           @server_connection_id = reply['connectionId']
           reply
-        rescue => exc
+        rescue StandardError => e
           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],
-          )
+          Utils.warn_bg_exception(msg, e,
+                                  logger: options[:logger],
+                                  log_prefix: options[:log_prefix],
+                                  bg_error_backtrace: options[:bg_error_backtrace])
           raise
         end
 
@@ -229,14 +224,12 @@ module Mongo
         def check_document
           server_api = @app_metadata.server_api || options[:server_api]
           doc = if hello_ok? || server_api
-            _doc = HELLO_DOC
-            if server_api
-              _doc = _doc.merge(Utils.transform_server_api(server_api))
-            end
-            _doc
-          else
-            LEGACY_HELLO_DOC
-          end
+                  _doc = HELLO_DOC
+                  _doc = _doc.merge(Utils.transform_server_api(server_api)) if server_api
+                  _doc
+                else
+                  LEGACY_HELLO_DOC
+                end
           # compressors must be set to maintain correct compression status
           # in the server description. See RUBY-2427
           if compressors = options[:compressors]

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