mongo 1.8.6 → 2.15.1

data/lib/mongo/server/pending_connection.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2019-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+
+    # This class encapsulates connections during handshake and authentication.
+    #
+    # @api private
+    class PendingConnection < ConnectionBase
+      extend Forwardable
+
+      def initialize(socket, server, monitoring, options = {})
+        @socket = socket
+        @options = options
+        @server = server
+        @monitoring = monitoring
+        @id = options[:id]
+      end
+
+      # @return [ Integer ] The ID for the connection. This is the same ID
+      #   as that of the regular Connection object for which this
+      #   PendingConnection instance was created.
+      attr_reader :id
+
+      def handshake_and_authenticate!
+        speculative_auth_doc = nil
+        if options[:user] || options[:auth_mech]
+          # To create an Auth instance, we need to specify the mechanism,
+          # 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+
+          # servers would generally allow SCRAM-SHA-256 authentication;
+          # 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+
+          # 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.
+          # 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)
+          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
+        end
+
+        result = handshake!(speculative_auth_doc: speculative_auth_doc)
+
+        if description.unknown?
+          raise Error::InternalDriverError, "Connection description cannot be unknown after successful handshake: #{description.inspect}"
+        end
+
+        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
+
+        if description.unknown?
+          raise Error::InternalDriverError, "Connection description cannot be unknown after successful authentication: #{description.inspect}"
+        end
+      end
+
+      private
+
+      # @param [ BSON::Document | nil ] speculative_auth_doc The document to
+      #   provide in speculativeAuthenticate field of handshake command.
+      #
+      # @return [ BSON::Document ] The document of the handshake response for
+      #   this particular connection.
+      def handshake!(speculative_auth_doc: nil)
+        unless socket
+          raise Error::InternalDriverError, "Cannot handshake because there is no usable socket (for #{address})"
+        end
+
+        hello_doc = handshake_document(
+          app_metadata,
+          speculative_auth_doc: speculative_auth_doc,
+          server_api: options[:server_api],
+        )
+
+        # TODO (DR): OP_MSG should be used if api version is declared.
+        # See https://github.com/mongodb/specifications/blob/master/source/message/OP_MSG.rst#id5
+        hello_command = Protocol::Query.new(Database::ADMIN, Database::COMMAND, hello_doc, :limit => -1)
+
+        doc = nil
+        @server.handle_handshake_failure! do
+          begin
+            response = @server.round_trip_time_averager.measure do
+              add_server_diagnostics do
+                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,
+              logger: options[:logger],
+              log_prefix: options[:log_prefix],
+              bg_error_backtrace: options[:bg_error_backtrace],
+            )
+            raise
+          end
+        end
+
+        post_handshake(doc, @server.round_trip_time_averager.average_round_trip_time)
+
+        doc
+      end
+
+      # @param [ String | nil ] speculative_auth_client_nonce The client
+      #   nonce used in speculative auth on this connection that
+      #   produced the specified speculative auth result.
+      # @param [ Symbol | nil ] speculative_auth_mech Auth mechanism used
+      #   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 hello response of
+      #   the handshake on this connection.
+      def authenticate!(
+        speculative_auth_client_nonce: nil,
+        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
+        end
+      end
+
+      def ensure_connected
+        yield @socket
+      end
+
+      # This is a separate method to keep the nesting level down.
+      #
+      # @return [ Server::Description ] The server description calculated from
+      #   hello response for this particular connection.
+      def post_handshake(response, average_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
+          # 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
+          # (that's this one) advertised for performing auth on that
+          # connection.
+          @sasl_supported_mechanisms = response['saslSupportedMechs']
+          set_compressor!(response)
+        else
+          @sasl_supported_mechanisms = nil
+        end
+
+        @description = Description.new(address, response, average_rtt).tap do |new_description|
+          @server.cluster.run_sdam_flow(@server.description, new_description)
+        end
+      end
+
+      # The user as going to be used for authentication. This user has the
+      # auth mechanism set and, if necessary, auth source.
+      #
+      # @param [ Symbol | nil ] speculative_auth_mech Auth mechanism used
+      #   for speculative auth, if speculative auth succeeded. If speculative
+      #   auth was not performed or it failed, this must be nil.
+      #
+      # @return [ Auth::User ] The resolved user.
+      def resolved_user(speculative_auth_mech: nil)
+        @resolved_user ||= begin
+          unless options[:user] || options[:auth_mech]
+            raise Mongo::Error, 'No authentication information specified in the client'
+          end
+
+          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
+            # 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
+            # SCRAM-SHA-1. However, on 4.4+ servers speculative auth would
+            # succeed (technically just the first round-trip, not the entire
+            # authentication flow) and we would be continuing it here;
+            # in this case, we must use SCRAM-SHA-256 as the mechanism since
+            # 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,
+          ).merge(options)
+          if user_options[:auth_mech] == :mongodb_x509
+            user_options[:auth_source] = '$external'
+          end
+          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
+
+        if description.features.scram_sha_1_enabled?
+          if @sasl_supported_mechanisms&.include?('SCRAM-SHA-256')
+            :scram256
+          else
+            :scram
+          end
+        else
+          :mongodb_cr
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+    class PushMonitor
+
+      # @api private
+      class Connection < Server::Monitor::Connection
+
+        def socket_timeout
+          options[:socket_timeout]
+        end
+      end
+    end
+  end
+end

data/lib/mongo/server/push_monitor.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+
+    # 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 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.
+    #
+    # @api private
+    class PushMonitor
+      extend Forwardable
+      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
+        @app_metadata = options[:app_metadata]
+        @check_document = options[:check_document]
+        @monitor = monitor
+        @topology_version = topology_version
+        @monitoring = monitoring
+        @options = options
+        @lock = Mutex.new
+      end
+
+      # @return [ Monitor ] The monitor to which this push monitor is attached.
+      attr_reader :monitor
+
+      # @return [ TopologyVersion ] Most recently received topology version.
+      attr_reader :topology_version
+
+      # @return [ Monitoring ] monitoring The monitoring.
+      attr_reader :monitoring
+
+      # @return [ Hash ] Push monitor options.
+      attr_reader :options
+
+      # @return [ Server ] The server that is being monitored.
+      def_delegator :monitor, :server
+
+      def start!
+        @lock.synchronize do
+          super
+        end
+      end
+
+      def stop!
+        @lock.synchronize do
+          @stop_requested = true
+          if @connection
+            # Interrupt any in-progress exhausted hello reads by
+            # disconnecting the connection.
+            @connection.send(:socket).close
+          end
+        end
+        super.tap do
+          @lock.synchronize do
+            if @connection
+              @connection.disconnect!
+              @connection = nil
+            end
+          end
+        end
+      end
+
+      def do_work
+        @lock.synchronize do
+          return if @stop_requested
+        end
+
+        result = monitoring.publish_heartbeat(server, awaited: true) do
+          check
+        end
+        new_description = monitor.run_sdam_flow(result, awaited: true)
+        # 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
+        # hello responses.
+        if new_description.topology_version
+          @topology_version = new_description.topology_version
+        end
+      rescue 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],
+        )
+      end
+
+      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}")
+            @connection.disconnect!
+            @connection = nil
+          end
+        end
+
+        @lock.synchronize do
+          unless @connection
+            @server_pushing = false
+            connection = PushMonitor::Connection.new(server.address, options)
+            connection.connect!
+            @connection = connection
+          end
+        end
+
+        resp_msg = begin
+          unless @server_pushing
+            write_check_command
+          end
+          read_response
+        rescue Mongo::Error
+          @lock.synchronize do
+            @connection.disconnect!
+            @connection = nil
+          end
+          raise
+        end
+        @server_pushing = resp_msg.flags.include?(:more_to_come)
+        result = Operation::Result.new(resp_msg)
+        result.validate!
+        result.documents.first
+      end
+
+      def write_check_command
+        document = @check_document.merge(
+          topologyVersion: topology_version.to_doc,
+          maxAwaitTimeMS: monitor.heartbeat_interval * 1000,
+        )
+        command = Protocol::Msg.new(
+          [:exhaust_allowed], {}, document.merge({'$db' => Database::ADMIN})
+        )
+        @lock.synchronize { @connection }.write_bytes(command.serialize.to_s)
+      end
+
+      def read_response
+        if timeout = options[:connect_timeout]
+          if timeout < 0
+            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
+          @lock.synchronize { @connection }.read_response(socket_timeout: timeout)
+        end
+      end
+
+    end
+  end
+end
+
+require 'mongo/server/push_monitor/connection'

data/lib/mongo/server/round_trip_time_averager.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2018-2020 MongoDB Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#  http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  class Server
+    # @api private
+    class RoundTripTimeAverager
+
+      # The weighting factor (alpha) for calculating the average moving
+      # round trip time.
+      RTT_WEIGHT_FACTOR = 0.2.freeze
+      private_constant :RTT_WEIGHT_FACTOR
+
+      def initialize
+        @last_round_trip_time = nil
+        @average_round_trip_time = nil
+      end
+
+      attr_reader :last_round_trip_time
+      attr_reader :average_round_trip_time
+
+      def measure
+        start = Utils.monotonic_time
+        begin
+          rv = yield
+        rescue Error::SocketError, Error::SocketTimeoutError
+          # 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
+          # For other errors, RTT is valid.
+        end
+        last_round_trip_time = Utils.monotonic_time - start
+
+        # 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
+          @last_round_trip_time = last_round_trip_time
+          update_average_round_trip_time
+        end
+
+        if exc
+          raise exc
+        else
+          rv
+        end
+      end
+
+      private
+
+      # This method is separate for testing purposes.
+      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
+      end
+    end
+  end
+end