mongo 2.14.0 → 2.18.1

data/lib/mongo/server/pending_connection.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -63,59 +66,80 @@ module Mongo
         end
 
         result = handshake!(speculative_auth_doc: speculative_auth_doc)
-        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
-          # We default auth mechanism to scram256, but if user specified
-          # scram explicitly we may be able to authenticate speculatively
-          # with scram.
-          when :scram, :scram256
-            authenticate!(
-              speculative_auth_client_nonce: speculative_auth.conversation.client_nonce,
-              speculative_auth_mech: speculative_auth_user.mechanism,
-              speculative_auth_result: speculative_auth_result,
-            )
-          else
-            raise NotImplementedError, "Speculative auth unexpectedly succeeded for mechanism #{speculative_auth_user.mechanism.inspect}"
+
+        if description.unknown?
+          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
+            # We default auth mechanism to scram256, but if user specified
+            # scram explicitly we may be able to authenticate speculatively
+            # with scram.
+            when :scram, :scram256
+              authenticate!(
+                speculative_auth_client_nonce: speculative_auth.conversation.client_nonce,
+                speculative_auth_mech: speculative_auth_user.mechanism,
+                speculative_auth_result: speculative_auth_result,
+              )
+            else
+              raise Error::InternalDriverError, "Speculative auth unexpectedly succeeded for mechanism #{speculative_auth_user.mechanism.inspect}"
+            end
+          elsif !description.arbiter?
+            authenticate!
           end
-        elsif !description.arbiter?
-          authenticate!
+        rescue Mongo::Error, Mongo::Error::AuthError => exc
+          exc.service_id = service_id
+          raise
+        end
+
+        if description.unknown?
+          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
       end
 
       private
 
       # @param [ BSON::Document | nil ] speculative_auth_doc The document to
-      #   provide in speculativeAuthenticate field of ismaster command.
+      #   provide in speculativeAuthenticate field of handshake command.
       #
-      # @return [ BSON::Document ] The document of the ismaster response for
+      # @return [ BSON::Document ] The document of the handshake response for
       #   this particular connection.
       def handshake!(speculative_auth_doc: nil)
         unless socket
-          raise Error::HandshakeError, "Cannot handshake because there is no usable socket (for #{address})"
+          raise Error::InternalDriverError, "Cannot handshake because there is no usable socket (for #{address})"
         end
 
-        ismaster_doc = app_metadata.validated_document
-        if speculative_auth_doc
-          ismaster_doc = ismaster_doc.merge(speculativeAuthenticate: speculative_auth_doc)
-        end
-
-        ismaster_command = Protocol::Query.new(Database::ADMIN, Database::COMMAND,
-          ismaster_doc, :limit => -1)
-
-        response = nil
+        hello_command = handshake_command(
+          handshake_document(
+            app_metadata,
+            speculative_auth_doc: speculative_auth_doc,
+            load_balancer: server.load_balancer?,
+            server_api: options[:server_api]
+          )
+        )
+        doc = nil
         @server.handle_handshake_failure! do
           begin
             response = @server.round_trip_time_averager.measure do
               add_server_diagnostics do
-                socket.write(ismaster_command.serialize.to_s)
-                Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE).documents.first
+                socket.write(hello_command.serialize.to_s)
+                Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE)
               end
             end
+            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,
@@ -127,9 +151,13 @@ module Mongo
           end
         end
 
-        post_handshake(response, @server.round_trip_time_averager.average_round_trip_time)
+        if @server.force_load_balancer?
+          doc['serviceId'] ||= "fake:#{rand(2**32-1)+1}"
+        end
+
+        post_handshake(doc, @server.round_trip_time_averager.average_round_trip_time)
 
-        response
+        doc
       end
 
       # @param [ String | nil ] speculative_auth_client_nonce The client
@@ -139,7 +167,7 @@ module Mongo
       #   for speculative auth, if speculative auth succeeded. If speculative
       #   auth was not performed or it failed, this must be nil.
       # @param [ BSON::Document | nil ] speculative_auth_result The
-      #   value of speculativeAuthenticate field of ismaster response of
+      #   value of speculativeAuthenticate field of hello response of
       #   the handshake on this connection.
       def authenticate!(
         speculative_auth_client_nonce: nil,
@@ -176,12 +204,12 @@ module Mongo
       # This is a separate method to keep the nesting level down.
       #
       # @return [ Server::Description ] The server description calculated from
-      #   ismaster response for this particular connection.
+      #   the handshake response for this particular connection.
       def post_handshake(response, average_rtt)
         if response["ok"] == 1
           # Auth mechanism is entirely dependent on the contents of
-          # ismaster response *for this connection*.
-          # Ismaster received by the monitoring connection should advertise
+          # hello response *for this connection*.
+          # Hello received by the monitoring connection should advertise
           # the same wire protocol, but if it doesn't, we use whatever
           # the monitoring connection advertised for filling out the
           # server description and whatever the non-monitoring connection
@@ -193,7 +221,12 @@ module Mongo
           @sasl_supported_mechanisms = nil
         end
 
-        @description = Description.new(address, response, average_rtt).tap do |new_description|
+        @description = Description.new(
+          address, response,
+          average_round_trip_time: average_rtt,
+          load_balancer: server.load_balancer?,
+          force_load_balancer: options[:connect] == :load_balanced,
+        ).tap do |new_description|
           @server.cluster.run_sdam_flow(@server.description, new_description)
         end
       end
@@ -215,7 +248,7 @@ module Mongo
           user_options = Options::Redacted.new(
             # When speculative auth is performed, we always use SCRAM-SHA-256.
             # At the same time we perform SCRAM mechanism negotiation in the
-            # ismaster request.
+            # hello request.
             # If the credentials we are trying to authenticate with do not
             # map to an existing user, SCRAM mechanism negotiation will not
             # return anything which would cause the driver to use

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/lib/mongo/server/push_monitor.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,11 +18,11 @@
 module Mongo
   class Server
 
-    # A monitor utilizing server-pushed ismaster requests.
+    # A monitor utilizing server-pushed hello requests.
     #
     # When a Monitor handshakes with a 4.4+ server, it creates an instance
-    # of PushMonitor. PushMonitor subsequently executes server-pushed ismaster
-    # (i.e. awaited & exhausted ismaster) to receive topology changes from the
+    # of PushMonitor. PushMonitor subsequently executes server-pushed hello
+    # (i.e. awaited & exhausted hello) to receive topology changes from the
     # server as quickly as possible. The Monitor still monitors the server
     # for round-trip time calculations and to perform immediate checks as
     # requested by the application.
@@ -33,6 +36,14 @@ module Mongo
         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
+        @app_metadata = options[:app_metadata]
+        @check_document = options[:check_document]
         @monitor = monitor
         @topology_version = topology_version
         @monitoring = monitoring
@@ -65,9 +76,9 @@ module Mongo
         @lock.synchronize do
           @stop_requested = true
           if @connection
-            # Interrupt any in-progress exhausted ismaster reads by
+            # Interrupt any in-progress exhausted hello reads by
             # disconnecting the connection.
-            @connection.send(:socket).close
+            @connection.send(:socket).close rescue nil
           end
         end
         super.tap do
@@ -86,29 +97,44 @@ module Mongo
         end
 
         result = monitoring.publish_heartbeat(server, awaited: true) do
-          ismaster
+          check
         end
         new_description = monitor.run_sdam_flow(result, awaited: true)
-        # When ismaster fails due to a fail point, the response does not
+        # When hello fails due to a fail point, the response does not
         # include topology version. In this case we need to keep our existing
         # topology version so that we can resume monitoring.
         # The spec does not appear to directly address this case but
         # https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-monitoring.rst#streaming-ismaster
         # says that topologyVersion should only be updated from successful
-        # ismaster responses.
+        # hello responses.
         if new_description.topology_version
           @topology_version = new_description.topology_version
         end
-      rescue Mongo::Error => exc
-        msg = "Error running awaited ismaster on #{server.address}"
+      rescue IOError, SocketError, SystemCallError, Mongo::Error => exc
+        stop_requested = @lock.synchronize { @stop_requested }
+        if stop_requested
+          # Ignore the exception, see RUBY-2771.
+          return
+        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],
         )
+
+        # If a request failed on a connection, stop push monitoring.
+        # In case the server is dead we don't want to have two connections
+        # trying to connect unsuccessfully at the same time.
+        stop!
+
+        # Request an immediate check on the monitor to get reinstated as
+        # soon as possible in case the server is actually alive.
+        server.scan_semaphore.signal
       end
 
-      def ismaster
+      def check
         @lock.synchronize do
           if @connection && @connection.pid != Process.pid
             log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{@connection.pid}, new pid #{Process.pid}")
@@ -128,7 +154,7 @@ module Mongo
 
         resp_msg = begin
           unless @server_pushing
-            write_ismaster
+            write_check_command
           end
           read_response
         rescue Mongo::Error
@@ -139,17 +165,20 @@ module Mongo
           raise
         end
         @server_pushing = resp_msg.flags.include?(:more_to_come)
-        result = resp_msg.documents.first
+        result = Operation::Result.new(resp_msg)
+        result.validate!
+        result.documents.first
       end
 
-      def write_ismaster
-        payload = Monitor::Connection::ISMASTER_OP_MSG.merge(
+      def write_check_command
+        document = @check_document.merge(
           topologyVersion: topology_version.to_doc,
           maxAwaitTimeMS: monitor.heartbeat_interval * 1000,
         )
-
-        req_msg = Protocol::Msg.new([:exhaust_allowed], {}, payload)
-        @lock.synchronize { @connection }.write_bytes(req_msg.serialize.to_s)
+        command = Protocol::Msg.new(
+          [:exhaust_allowed], {}, document.merge({'$db' => Database::ADMIN})
+        )
+        @lock.synchronize { @connection }.write_bytes(command.serialize.to_s)
       end
 
       def read_response
@@ -162,10 +191,15 @@ module Mongo
         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 ismaster 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
+
+      def to_s
+        "#<#{self.class.name}:#{object_id} #{server.address}>"
+      end
+
     end
   end
 end

data/lib/mongo/server/round_trip_time_averager.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2018-2020 MongoDB Inc.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -31,7 +34,7 @@ module Mongo
       attr_reader :average_round_trip_time
 
       def measure
-        start = Time.now
+        start = Utils.monotonic_time
         begin
           rv = yield
         rescue Error::SocketError, Error::SocketTimeoutError
@@ -41,9 +44,9 @@ module Mongo
         rescue Error, Error::AuthError => exc
           # For other errors, RTT is valid.
         end
-        last_round_trip_time = Time.now - start
+        last_round_trip_time = Utils.monotonic_time - start
 
-        # If ismaster fails, we need to return the last round trip time
+        # 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

data/lib/mongo/server.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -51,6 +54,9 @@ module Mongo
     #   done by this server. Note: setting this option to false will make
     #   the server non-functional. It is intended for use in tests which
     #   manually invoke SDAM state transitions.
+    # @option options [ true | false ] :load_balancer Whether this server
+    #   is a load balancer.
+    # @option options [ String ] :connect The client connection mode.
     #
     # @since 2.0.0
     def initialize(address, cluster, monitoring, event_listeners, options = {})
@@ -66,12 +72,17 @@ module Mongo
       end
       @scan_semaphore = DistinguishingSemaphore.new
       @round_trip_time_averager = RoundTripTimeAverager.new
-      @description = Description.new(address, {})
+      @description = Description.new(address, {},
+        load_balancer: !!@options[:load_balancer],
+        force_load_balancer: force_load_balancer?,
+      )
       @last_scan = nil
+      @last_scan_monotime = nil
       unless options[:monitoring_io] == false
         @monitor = Monitor.new(self, event_listeners, monitoring,
           options.merge(
-            app_metadata: Monitor::AppMetadata.new(cluster.options),
+            app_metadata: cluster.monitor_app_metadata,
+            push_monitor_app_metadata: cluster.push_monitor_app_metadata,
             heartbeat_interval: cluster.heartbeat_interval,
         ))
         unless _monitor == false
@@ -102,6 +113,15 @@ module Mongo
     #   description the monitor refreshes.
     attr_reader :description
 
+    # Returns whether this server is forced to be a load balancer.
+    #
+    # @return [ true | false ] Whether this server is forced to be a load balancer.
+    #
+    # @api private
+    def force_load_balancer?
+      options[:connect] == :load_balanced
+    end
+
     # @return [ Time | nil ] last_scan The time when the last server scan
     #   completed, or nil if the server has not been scanned yet.
     #
@@ -114,6 +134,18 @@ module Mongo
       end
     end
 
+    # @return [ Float | nil ] last_scan_monotime The monotonic time when the last server scan
+    #   completed, or nil if the server has not been scanned yet.
+    # @api private
+    def last_scan_monotime
+      if description && !description.config.empty?
+        description.last_update_monotime
+      else
+        @last_scan_monotime
+      end
+    end
+
+
     # @deprecated
     def heartbeat_frequency
       cluster.heartbeat_interval
@@ -163,6 +195,7 @@ module Mongo
                    :secondary?,
                    :standalone?,
                    :unknown?,
+                   :load_balancer?,
                    :last_write_date,
                    :logical_session_timeout
 
@@ -172,6 +205,11 @@ module Mongo
                    :cluster_time,
                    :update_cluster_time
 
+    # @api private
+    def_delegators :cluster,
+                   :monitor_app_metadata,
+                   :push_monitor_app_metadata
+
     def_delegators :features,
                    :check_driver_support!
 
@@ -200,20 +238,6 @@ module Mongo
       address == other.address
     end
 
-    # Get a new context for this server in which to send messages.
-    #
-    # @example Get the server context.
-    #   server.context
-    #
-    # @return [ Mongo::Server::Context ] context The server context.
-    #
-    # @since 2.0.0
-    #
-    # @deprecated Will be removed in version 3.0
-    def context
-      Context.new(self)
-    end
-
     # Determine if a connection to the server is able to be established and
     # messages can be sent to it.
     #
@@ -272,19 +296,6 @@ module Mongo
       @connected
     end
 
-    # When the server is flagged for garbage collection, stop the monitor
-    # thread.
-    #
-    # @example Finalize the object.
-    #   Server.finalize(monitor)
-    #
-    # @param [ Server::Monitor ] monitor The server monitor.
-    #
-    # @since 2.2.0
-    def self.finalize(monitor)
-      proc { monitor.stop! }
-    end
-
     # Start monitoring the server.
     #
     # Used internally by the driver to add a server to a cluster
@@ -292,14 +303,20 @@ module Mongo
     #
     # @api private
     def start_monitoring
+      publish_opening_event
+      if options[:monitoring_io] != false
+        monitor.run!
+      end
+    end
+
+    # Publishes the server opening event.
+    #
+    # @api private
+    def publish_opening_event
       publish_sdam_event(
         Monitoring::SERVER_OPENING,
         Monitoring::Event::ServerOpening.new(address, cluster.topology)
       )
-      if options[:monitoring_io] != false
-        ObjectSpace.define_finalizer(self, self.class.finalize(monitor))
-        monitor.run!
-      end
     end
 
     # Get a pretty printed server inspection.
@@ -319,6 +336,8 @@ module Mongo
     # @api private
     def status
       case
+      when load_balancer?
+        'LB'
       when primary?
         'PRIMARY'
       when secondary?
@@ -425,8 +444,8 @@ module Mongo
     # @return [ Object ] The result of the block execution.
     #
     # @since 2.3.0
-    def with_connection(&block)
-      pool.with_connection(&block)
+    def with_connection(connection_global_id: nil, &block)
+      pool.with_connection(connection_global_id: connection_global_id, &block)
     end
 
     # Handle handshake failure.
@@ -436,7 +455,11 @@ module Mongo
     def handle_handshake_failure!
       yield
     rescue Mongo::Error::SocketError, Mongo::Error::SocketTimeoutError => e
-      unknown!(generation: e.generation, stop_push_monitor: true)
+      unknown!(
+        generation: e.generation,
+        service_id: e.service_id,
+        stop_push_monitor: true,
+      )
       raise
     end
 
@@ -459,7 +482,11 @@ module Mongo
       raise
     rescue Mongo::Error::SocketError => e
       # non-timeout network error
-      unknown!(generation: e.generation, stop_push_monitor: true)
+      unknown!(
+        generation: e.generation,
+        service_id: e.service_id,
+        stop_push_monitor: true,
+      )
       raise
     rescue Auth::Unauthorized
       # auth error, keep server description and topology as they are
@@ -484,9 +511,15 @@ module Mongo
     # @note Retryable writes are only available on server versions 3.6+ and with
     #   sharded clusters or replica sets.
     #
+    # @note Some of the conditions in this method automatically return false for
+    #       for load balanced topologies. The conditions in this method should
+    #       always be true, since load-balanced topologies are only available on
+    #       MongoDB 5.0+, and not for standalone topologies. Therefore, we can
+    #       assume that retry writes are enabled.
+    #
     # @since 2.5.0
     def retry_writes?
-      !!(features.sessions_enabled? && logical_session_timeout && !standalone?)
+      !!(features.sessions_enabled? && logical_session_timeout && !standalone?) || load_balancer?
     end
 
     # Marks server unknown and publishes the associated SDAM event
@@ -509,9 +542,27 @@ module Mongo
     #   of the error response that is causing the server to be marked unknown.
     # @option options [ true | false ] :stop_push_monitor Whether to stop
     #   the PushMonitor associated with the server, if any.
+    # @option options [ Object ] :service_id Discard state for the specified
+    #   service id only.
     #
     # @since 2.4.0, SDAM events are sent as of version 2.7.0
     def unknown!(options = {})
+      if load_balancer?
+        # When the client is in load-balanced topology, servers (the one and
+        # only that can be) starts out as a load balancer and stays as a
+        # load balancer indefinitely. As such it is not marked unknown.
+        #
+        # However, this method also clears connection pool for the server
+        # when the latter is marked unknown, and this part needs to happen
+        # when the server is a load balancer.
+        if service_id = options[:service_id]
+          pool.disconnect!(service_id: service_id)
+        elsif Lint.enabled?
+          raise Error::LintError, 'Load balancer was asked to be marked unknown without a service id'
+        end
+        return
+      end
+
       if options[:generation] && options[:generation] < pool.generation
         return
       end
@@ -529,10 +580,16 @@ module Mongo
       # SDAM flow will update description on the server without in-place
       # mutations and invoke SDAM transitions as needed.
       config = {}
+      if options[:service_id]
+        config['serviceId'] = options[:service_id]
+      end
       if options[:topology_version]
         config['topologyVersion'] = options[:topology_version]
       end
-      new_description = Description.new(address, config)
+      new_description = Description.new(address, config,
+        load_balancer: load_balancer?,
+        force_load_balancer: options[:connect] == :load_balanced,
+      )
       cluster.run_sdam_flow(description, new_description, options)
     end
 
@@ -541,11 +598,14 @@ module Mongo
       @description = description
     end
 
+    # @param [ Object ] :service_id Close connections with the specified
+    #   service id only.
+    #
     # @api private
-    def clear_connection_pool
+    def clear_connection_pool(service_id: nil)
       @pool_lock.synchronize do
         if @pool
-          @pool.disconnect!
+          @pool.disconnect!(service_id: service_id)
         end
       end
     end
@@ -558,6 +618,7 @@ module Mongo
     # @api private
     def update_last_scan
       @last_scan = Time.now
+      @last_scan_monotime = Utils.monotonic_time
     end
   end
 end
@@ -568,7 +629,6 @@ require 'mongo/server/connection_base'
 require 'mongo/server/pending_connection'
 require 'mongo/server/connection'
 require 'mongo/server/connection_pool'
-require 'mongo/server/context'
 require 'mongo/server/description'
 require 'mongo/server/monitor'
 require 'mongo/server/round_trip_time_averager'