mongo 2.7.2 → 2.8.0.rc0

data/lib/mongo/server/connection.rb

@@ -18,7 +18,7 @@ module Mongo
     # This class models the socket connections for servers and their behavior.
     #
     # @since 2.0.0
-    class Connection
+    class Connection < ConnectionBase
       include Connectable
       include Monitoring::Publishable
       include Retryable
@@ -66,7 +66,12 @@ module Mongo
       # @deprecated No longer necessary with Server Selection specification.
       PING_OP_MSG_BYTES = PING_OP_MSG_MESSAGE.serialize.to_s.freeze
 
-      # Initialize a new socket connection from the client to the server.
+      # Creates a new connection object to the specified target address
+      # with the specified options.
+      #
+      # The constructor does not perform any I/O (and thus does not create
+      # sockets, handshakes nor authenticates); call connect! method on the
+      # connection object to create the network connection.
       #
       # @api private
       #
@@ -84,11 +89,10 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(server, options = {})
-        @address = server.address
         @monitoring = server.monitoring
         @options = options.freeze
         @server = server
-        @ssl_options = options.reject { |k, v| !k.to_s.start_with?(SSL) }
+        @ssl_options = options.select { |k, v| k.to_s.start_with?(SSL) }.freeze
         @socket = nil
         @last_checkin = nil
         @auth_mechanism = nil
@@ -109,17 +113,9 @@ module Mongo
         options[:generation]
       end
 
-      def_delegators :@server,
-                     :features,
-                     :max_bson_object_size,
-                     :max_message_size,
-                     :mongos?,
-                     :app_metadata,
-                     :compressor,
-                     :cluster_time,
-                     :update_cluster_time
-
-      # Tell the underlying socket to establish a connection to the host.
+      # Establishes a network connection to the target address.
+      #
+      # If the connection is already established, this method does nothing.
       #
       # @example Connect to the host.
       #   connection.connect!
@@ -131,18 +127,15 @@ module Mongo
       #
       # @since 2.0.0
       def connect!
-        unless socket && socket.connectable?
-          begin
-            # Need to assign to the instance variable here because
-            # I/O done by #handshake! and #connect! reference the socket
-            @socket = address.socket(socket_timeout, ssl_options)
-            address.connect_socket!(socket)
-            handshake!
-            authenticate!
-          rescue Exception
-            @socket = nil
-            raise
-          end
+        unless @socket
+          socket = address.socket(socket_timeout, ssl_options,
+            connect_timeout: address.connect_timeout)
+          handshake!(socket)
+          pending_connection = PendingConnection.new(socket, @server, monitoring, options)
+          authenticate!(pending_connection)
+          # When @socket is assigned, the socket should have handshaken and
+          # authenticated and be usable.
+          @socket = socket
         end
         true
       end
@@ -168,36 +161,6 @@ module Mongo
         true
       end
 
-      # Dispatch a single message to the connection. If the message
-      # requires a response, a reply will be returned.
-      #
-      # @example Dispatch the message.
-      #   connection.dispatch([ insert ])
-      #
-      # @note This method is named dispatch since 'send' is a core Ruby method on
-      #   all objects.
-      #
-      # @note For backwards compatibility, this method accepts the messages
-      #   as an array. However, exactly one message must be given per invocation.
-      #
-      # @param [ Array<Message> ] messages A one-element array containing
-      #   the message to dispatch.
-      # @param [ Integer ] operation_id The operation id to link messages.
-      #
-      # @return [ Protocol::Message | nil ] The reply if needed.
-      #
-      # @since 2.0.0
-      def dispatch(messages, operation_id = nil)
-        # The monitoring code does not correctly handle multiple messages,
-        # and the driver internally does not send more than one message at
-        # a time ever. Thus prohibit multiple message use for now.
-        if messages.length != 1
-          raise ArgumentError, 'Can only dispatch one message at a time'
-        end
-        message = messages.first
-        deliver(message)
-      end
-
       # Ping the connection to see if the server is responding to commands.
       # This is non-blocking on the server side.
       #
@@ -249,92 +212,80 @@ module Mongo
 
       private
 
-      def deliver(message)
-        buffer = serialize(message)
-        ensure_connected do |socket|
-          operation_id = Monitoring.next_operation_id
-          command_started(address, operation_id, message.payload)
-          start = Time.now
-          result = nil
-          begin
-            socket.write(buffer.to_s)
-            result = if message.replyable?
-              Protocol::Message.deserialize(socket, max_message_size, message.request_id)
-            else
-              nil
-            end
-          rescue Exception => e
-            total_duration = Time.now - start
-            command_failed(nil, address, operation_id, message.payload, e.message, total_duration)
-            raise
-          else
-            total_duration = Time.now - start
-            command_completed(result, address, operation_id, message.payload, total_duration)
-          end
-          result
-        end
-      end
-
-      def handshake!
-        unless socket && socket.connectable?
+      def handshake!(socket)
+        unless socket
           raise Error::HandshakeError, "Cannot handshake because there is no usable socket"
         end
 
+        response = average_rtt = nil
         @server.handle_handshake_failure! do
-          response, exc, rtt, average_rtt =
-            @server.monitor.round_trip_time_averager.measure do
-              socket.write(app_metadata.ismaster_bytes)
-              Protocol::Message.deserialize(socket, max_message_size).documents[0]
-            end
+          begin
+            response, exc, rtt, average_rtt =
+              @server.monitor.round_trip_time_averager.measure do
+                socket.write(app_metadata.ismaster_bytes)
+                Protocol::Message.deserialize(socket, max_message_size).documents[0]
+              end
 
-          if exc
-            raise exc
+            if exc
+              raise exc
+            end
+          rescue => e
+            log_warn("Failed to handshake with #{address}: #{e.class}: #{e}")
+            raise
           end
+        end
 
-          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
-            # 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.
-            @auth_mechanism = if response['saslSupportedMechs']
-              if response['saslSupportedMechs'].include?(Mongo::Auth::SCRAM::SCRAM_SHA_256_MECHANISM)
-                :scram256
-              else
-                :scram
-              end
+        post_handshake(response, average_rtt)
+      end
+
+      # This is a separate method to keep the nesting level down.
+      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
+          # 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.
+          @auth_mechanism = if response['saslSupportedMechs']
+            if response['saslSupportedMechs'].include?(Mongo::Auth::SCRAM::SCRAM_SHA_256_MECHANISM)
+              :scram256
             else
-              # MongoDB servers < 2.6 are no longer suported.
-              # Wire versions should always be returned in ismaster.
-              # See also https://jira.mongodb.org/browse/RUBY-1584.
-              min_wire_version = response[Description::MIN_WIRE_VERSION]
-              max_wire_version = response[Description::MAX_WIRE_VERSION]
-              features = Description::Features.new(min_wire_version..max_wire_version)
-              if features.scram_sha_1_enabled?
-                :scram
-              else
-                :mongodb_cr
-              end
+              :scram
             end
           else
-            @auth_mechanism = nil
+            # MongoDB servers < 2.6 are no longer suported.
+            # Wire versions should always be returned in ismaster.
+            # See also https://jira.mongodb.org/browse/RUBY-1584.
+            min_wire_version = response[Description::MIN_WIRE_VERSION]
+            max_wire_version = response[Description::MAX_WIRE_VERSION]
+            features = Description::Features.new(min_wire_version..max_wire_version)
+            if features.scram_sha_1_enabled?
+              :scram
+            else
+              :mongodb_cr
+            end
           end
-
-          new_description = Description.new(@server.description.address, response, average_rtt)
-          @server.monitor.publish(Event::DESCRIPTION_CHANGED, @server.description, new_description)
+        else
+          @auth_mechanism = nil
         end
+
+        new_description = Description.new(address, response, average_rtt)
+        @server.monitor.publish(Event::DESCRIPTION_CHANGED, @server.description, new_description)
       end
 
-      def authenticate!
+      def authenticate!(pending_connection)
         if options[:user] || options[:auth_mech]
-          user = Auth::User.new(Options::Redacted.new(:auth_mech => default_mechanism, :client_key => @client_key).merge(options))
+          user = Auth::User.new(Options::Redacted.new(:auth_mech => default_mechanism).merge(options))
           @server.handle_auth_failure! do
-            reply = Auth.get(user).login(self)
-            @client_key ||= user.send(:client_key) if user.mechanism == :scram
-            reply
+            begin
+              Auth.get(user).login(pending_connection)
+            rescue => e
+              log_warn("Failed to handshake with #{address}: #{e.class}: #{e}")
+              raise
+            end
           end
         end
       end
@@ -343,15 +294,15 @@ module Mongo
         @auth_mechanism || (@server.features.scram_sha_1_enabled? ? :scram : :mongodb_cr)
       end
 
-      def serialize(message, buffer = BSON::ByteBuffer.new)
-        start_size = 0
-        message.compress!(compressor, options[:zlib_compression_level]).serialize(buffer, max_bson_object_size)
-        if max_message_size &&
-          (buffer.length - start_size) > max_message_size
-        then
-          raise Error::MaxMessageSize.new(max_message_size)
+      def deliver(message)
+        begin
+          super
+        # Important: timeout errors are not handled here
+        rescue Error::SocketError
+          @server.unknown!
+          @server.pool.disconnect!
+          raise
         end
-        buffer
       end
     end
   end

data/lib/mongo/server/connection_base.rb

@@ -0,0 +1,133 @@
+# Copyright (C) 2019 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 common connection functionality.
+    #
+    # @note Although methods of this module are part of the public API,
+    #   the fact that these methods are defined on this module and not on
+    #   the classes which include this module is not part of the public API.
+    #
+    # @api semipublic
+    class ConnectionBase
+      extend Forwardable
+      include Monitoring::Publishable
+
+      # @return [ Hash ] options The passed in options.
+      attr_reader :options
+
+      # @return [ Mongo::Address ] address The address to connect to.
+      def address
+        @server.address
+      end
+
+      def_delegators :@server,
+                     :features,
+                     :max_bson_object_size,
+                     :max_message_size,
+                     :mongos?,
+                     :compressor,
+                     :cluster_time,
+                     :update_cluster_time
+
+      def app_metadata
+        @app_metadata ||= begin
+          same = true
+          AppMetadata::AUTH_OPTION_KEYS.each do |key|
+            if @server.options[key] != options[key]
+              same = false
+              break
+            end
+          end
+          if same
+            @server.app_metadata
+          else
+            AppMetadata.new(options)
+          end
+        end
+      end
+
+      # Dispatch a single message to the connection. If the message
+      # requires a response, a reply will be returned.
+      #
+      # @example Dispatch the message.
+      #   connection.dispatch([ insert ])
+      #
+      # @note This method is named dispatch since 'send' is a core Ruby method on
+      #   all objects.
+      #
+      # @note For backwards compatibility, this method accepts the messages
+      #   as an array. However, exactly one message must be given per invocation.
+      #
+      # @param [ Array<Message> ] messages A one-element array containing
+      #   the message to dispatch.
+      # @param [ Integer ] operation_id The operation id to link messages.
+      #
+      # @return [ Protocol::Message | nil ] The reply if needed.
+      #
+      # @since 2.0.0
+      def dispatch(messages, operation_id = nil)
+        # The monitoring code does not correctly handle multiple messages,
+        # and the driver internally does not send more than one message at
+        # a time ever. Thus prohibit multiple message use for now.
+        if messages.length != 1
+          raise ArgumentError, 'Can only dispatch one message at a time'
+        end
+        message = messages.first
+        deliver(message)
+      end
+
+      private
+
+      def deliver(message)
+        buffer = serialize(message)
+        ensure_connected do |socket|
+          operation_id = Monitoring.next_operation_id
+          command_started(address, operation_id, message.payload)
+          start = Time.now
+          result = nil
+          begin
+            socket.write(buffer.to_s)
+            result = if message.replyable?
+              Protocol::Message.deserialize(socket, max_message_size, message.request_id)
+            else
+              nil
+            end
+          rescue Exception => e
+            total_duration = Time.now - start
+            command_failed(nil, address, operation_id, message.payload, e.message, total_duration)
+            raise
+          else
+            total_duration = Time.now - start
+            command_completed(result, address, operation_id, message.payload, total_duration)
+          end
+          result
+        end
+      end
+
+      def serialize(message, buffer = BSON::ByteBuffer.new)
+        start_size = 0
+        message.compress!(compressor, options[:zlib_compression_level]).serialize(buffer, max_bson_object_size)
+        if max_message_size &&
+          (buffer.length - start_size) > max_message_size
+        then
+          raise Error::MaxMessageSize.new(max_message_size)
+        end
+        buffer
+      end
+    end
+  end
+end

data/lib/mongo/server/connection_pool.rb

@@ -42,8 +42,13 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(options = {}, &block)
-        @options = options.freeze
-        @queue = Queue.new(options, &block)
+        @options = options.dup.freeze
+        @queue = queue = Queue.new(@options, &block)
+
+        finalizer = proc do
+          queue.disconnect!
+        end
+        ObjectSpace.define_finalizer(self, finalizer)
       end
 
       # @return [ Hash ] options The pool options.
@@ -76,7 +81,10 @@ module Mongo
         queue.dequeue
       end
 
-      # Disconnect the connection pool.
+      # Closes all idle connections in the pool and schedules currently checked
+      # out connections to be closed when they are checked back into the pool.
+      # The pool remains operational and can create new connections when
+      # requested.
       #
       # @example Disconnect the connection pool.
       #   pool.disconnect!
@@ -120,27 +128,6 @@ module Mongo
       protected
 
       attr_reader :queue
-
-      private
-
-      class << self
-
-        # Creates a new connection pool for the provided server.
-        #
-        # @example Create a new connection pool.
-        #   Mongo::Server::ConnectionPool.get(server)
-        #
-        # @param [ Mongo::Server ] server The server.
-        #
-        # @return [ Mongo::Server::ConnectionPool ] The connection pool.
-        #
-        # @since 2.0.0
-        def get(server)
-          ConnectionPool.new(server.options) do |generation|
-            Connection.new(server, server.options.merge(generation: generation))
-          end
-        end
-      end
     end
   end
 end