mongo 2.6.4 → 2.7.0.rc0

data/lib/mongo/server.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2018 MongoDB, Inc.
+# Copyright (C) 2014-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.
@@ -12,13 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/server/connectable'
-require 'mongo/server/connection'
-require 'mongo/server/connection_pool'
-require 'mongo/server/context'
-require 'mongo/server/description'
-require 'mongo/server/monitor'
-
 module Mongo
 
   # Represents a single server on the server side that can be standalone, part of
@@ -28,6 +21,53 @@ module Mongo
   class Server
     extend Forwardable
     include Monitoring::Publishable
+    include Event::Publisher
+
+    # The default time in seconds to timeout a connection attempt.
+    #
+    # @since 2.4.3
+    CONNECT_TIMEOUT = 10.freeze
+
+    # Instantiate a new server object. Will start the background refresh and
+    # subscribe to the appropriate events.
+    #
+    # @api private
+    #
+    # @example Initialize the server.
+    #   Mongo::Server.new('127.0.0.1:27017', cluster, monitoring, listeners)
+    #
+    # @note Server must never be directly instantiated outside of a Cluster.
+    #
+    # @param [ Address ] address The host:port address to connect to.
+    # @param [ Cluster ] cluster  The cluster the server belongs to.
+    # @param [ Monitoring ] monitoring The monitoring.
+    # @param [ Event::Listeners ] event_listeners The event listeners.
+    # @param [ Hash ] options The server options.
+    #
+    # @option options [ Boolean ] :monitor For internal driver use only:
+    #   whether to monitor the server after instantiating it.
+    # @option options [ true, false ] :monitoring_io For internal driver
+    #   use only. Set to false to prevent SDAM-related I/O from being
+    #   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.
+    #
+    # @since 2.0.0
+    def initialize(address, cluster, monitoring, event_listeners, options = {})
+      @address = address
+      @cluster = cluster
+      @monitoring = monitoring
+      options = options.dup
+      monitor = options.delete(:monitor)
+      @options = options.freeze
+      @event_listeners = event_listeners
+      @monitor = Monitor.new(address, event_listeners, monitoring,
+        options.merge(app_metadata: Monitor::AppMetadata.new(cluster.options)))
+      unless monitor == false
+        start_monitoring
+      end
+      @connected = true
+    end
 
     # @return [ String ] The configured address for the server.
     attr_reader :address
@@ -44,13 +84,13 @@ module Mongo
     # @return [ Monitoring ] monitoring The monitoring.
     attr_reader :monitoring
 
-    # The default time in seconds to timeout a connection attempt.
-    #
-    # @since 2.4.3
-    CONNECT_TIMEOUT = 10.freeze
-
     # Get the description from the monitor and scan on monitor.
-    def_delegators :monitor, :description, :scan!, :heartbeat_frequency, :last_scan, :compressor
+    def_delegators :monitor,
+      :description,
+      :scan!,
+      :heartbeat_frequency,
+      :last_scan,
+      :compressor
     alias :heartbeat_frequency_seconds :heartbeat_frequency
 
     # Delegate convenience methods to the monitor description.
@@ -71,7 +111,6 @@ module Mongo
                    :secondary?,
                    :standalone?,
                    :unknown?,
-                   :unknown!,
                    :last_write_date,
                    :logical_session_timeout
 
@@ -131,12 +170,27 @@ module Mongo
     # @example Disconnect the server.
     #   server.disconnect!
     #
-    # @return [ true ] Always tru with no exception.
+    # @param [ Boolean ] wait Whether to wait for background threads to
+    #   finish running.
+    #
+    # @return [ true ] Always true with no exception.
     #
     # @since 2.0.0
-    def disconnect!
+    def disconnect!(wait=false)
       pool.disconnect!
-      monitor.stop! and true
+      monitor.stop!(wait)
+      @connected = false
+      true
+    end
+
+    # Whether the server is connected.
+    #
+    # @return [ true|false ] Whether the server is connected.
+    #
+    # @api private
+    # @since 2.7.0
+    def connected?
+      @connected
     end
 
     # When the server is flagged for garbage collection, stop the monitor
@@ -152,36 +206,21 @@ module Mongo
       proc { monitor.stop! }
     end
 
-    # Instantiate a new server object. Will start the background refresh and
-    # subscribe to the appropriate events.
+    # Start monitoring the server.
     #
-    # @api private
-    #
-    # @example Initialize the server.
-    #   Mongo::Server.new('127.0.0.1:27017', cluster, monitoring, listeners)
+    # Used internally by the driver to add a server to a cluster
+    # while delaying monitoring until the server is in the cluster.
     #
-    # @note Server must never be directly instantiated outside of a Cluster.
-    #
-    # @param [ Address ] address The host:port address to connect to.
-    # @param [ Cluster ] cluster  The cluster the server belongs to.
-    # @param [ Monitoring ] monitoring The monitoring.
-    # @param [ Event::Listeners ] event_listeners The event listeners.
-    # @param [ Hash ] options The server options.
-    #
-    # @since 2.0.0
-    def initialize(address, cluster, monitoring, event_listeners, options = {})
-      @address = address
-      @cluster = cluster
-      @monitoring = monitoring
-      @options = options.freeze
+    # @api private
+    def start_monitoring
       publish_sdam_event(
         Monitoring::SERVER_OPENING,
         Monitoring::Event::ServerOpening.new(address, cluster.topology)
       )
-      @monitor = Monitor.new(address, event_listeners, options.merge(app_metadata: cluster.app_metadata))
-      monitor.scan!
-      monitor.run!
-      ObjectSpace.define_finalizer(self, self.class.finalize(monitor))
+      if options[:monitoring_io] != false
+        monitor.run!
+        ObjectSpace.define_finalizer(self, self.class.finalize(monitor))
+      end
     end
 
     # Get a pretty printed server inspection.
@@ -196,6 +235,36 @@ module Mongo
       "#<Mongo::Server:0x#{object_id} address=#{address.host}:#{address.port}>"
     end
 
+    # @note This method is experimental and subject to change.
+    #
+    # @api experimental
+    # @since 2.7.0
+    def summary
+      status = case
+      when primary?
+        'PRIMARY'
+      when secondary?
+        'SECONDARY'
+      when standalone?
+        'STANDALONE'
+      when arbiter?
+        'ARBITER'
+      when ghost?
+        'GHOST'
+      when other?
+        'OTHER'
+      end
+      if replica_set_name
+        status += " replica_set=#{replica_set_name}"
+      end
+      address_bit = if address
+        "#{address.host}:#{address.port}"
+      else
+        'nil'
+      end
+      "#<Server address=#{address_bit} #{status}>"
+    end
+
     # Get the connection pool for this server.
     #
     # @example Get the connection pool for the server.
@@ -233,7 +302,8 @@ module Mongo
     #
     # @since 2.1.0
     def reconnect!
-      monitor.restart! and true
+      monitor.restart!
+      @connected = true
     end
 
     # Execute a block of code with a connection, that is checked out of the
@@ -251,6 +321,17 @@ module Mongo
       pool.with_connection(&block)
     end
 
+    # Handle handshake failure.
+    #
+    # @since 2.7.0
+    # @api private
+    def handle_handshake_failure!
+      yield
+    rescue Mongo::Error::SocketError, Mongo::Error::SocketTimeoutError
+      unknown!
+      raise
+    end
+
     # Handle authentication failure.
     #
     # @example Handle possible authentication failure.
@@ -265,8 +346,17 @@ module Mongo
     # @since 2.3.0
     def handle_auth_failure!
       yield
-    rescue Auth::Unauthorized
+    rescue Mongo::Error::SocketTimeoutError
+      # possibly cluster is slow, do not give up on it
+      raise
+    rescue Mongo::Error::SocketError
+      # non-timeout network error
       unknown!
+      pool.disconnect!
+      raise
+    rescue Auth::Unauthorized
+      # auth error, keep server description and topology as they are
+      pool.disconnect!
       raise
     end
 
@@ -284,5 +374,30 @@ module Mongo
     def retry_writes?
       !!(features.sessions_enabled? && logical_session_timeout && !standalone?)
     end
+
+    # Marks server unknown and publishes the associated SDAM event
+    # (server description changed).
+    #
+    # @since 2.4.0, SDAM events are sent as of version 2.7.0
+    def unknown!
+      # Just dispatch the description changed event here, SDAM flow
+      # will update description on the server without in-place mutations
+      # and invoke SDAM transitions as needed.
+      publish(Event::DESCRIPTION_CHANGED, description, Description.new(address))
+    end
+
+    # @api private
+    def update_description(description)
+      monitor.instance_variable_set('@description', description)
+    end
   end
 end
+
+require 'mongo/server/app_metadata'
+require 'mongo/server/connectable'
+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'

data/lib/mongo/{cluster → server}/app_metadata.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2016-2018 MongoDB, Inc.
+# Copyright (C) 2016-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.
@@ -15,8 +15,7 @@
 require 'rbconfig'
 
 module Mongo
-  class Cluster
-
+  class Server
     # Application metadata that is sent to the server in an ismaster command,
     #   when a new connection is established.
     #
@@ -46,19 +45,33 @@ module Mongo
       # @api private
       #
       # @example Instantiate the app metadata.
-      #   Mongo::Cluster.AppMetadata.new(cluster)
+      #   Mongo::Server::AppMetadata.new(options)
       #
-      # @param [ Mongo::Cluster ] cluster The cluster.
+      # @param [ Hash ] options Metadata options.
+      # @option options [ String, Symbol ] :app_name Application name that is
+      #   printed to the mongod logs upon establishing a connection in server
+      #   versions >= 3.4.
+      # @option options [ Symbol ] :auth_mech The authentication mechanism to
+      #   use. One of :mongodb_cr, :mongodb_x509, :plain, :scram, :scram256
+      # @option options [ String ] :auth_source The source to authenticate from.
+      # @option options [ Array<String> ] :compressors A list of potential
+      #   compressors to use, in order of preference. The driver chooses the
+      #   first compressor that is also supported by the server. Currently the
+      #   driver only supports 'zlib'.
+      # @option options [ String ] :platform Platform information to include in
+      #   the metadata printed to the mongod logs upon establishing a connection
+      #   in server versions >= 3.4.
+      # @option options [ String ] :user The user name.
       #
       # @since 2.4.0
-      def initialize(cluster)
-        @app_name = cluster.options[:app_name].to_s if cluster.options[:app_name]
-        @platform = cluster.options[:platform]
-        @compressors = cluster.options[:compressors] || []
-
-        if cluster.options[:user] && !cluster.options[:auth_mech]
-          auth_db = cluster.options[:auth_source] || 'admin'
-          @request_auth_mech = "#{auth_db}.#{cluster.options[:user]}"
+      def initialize(options)
+        @app_name = options[:app_name].to_s if options[:app_name]
+        @platform = options[:platform]
+        @compressors = options[:compressors] || []
+
+        if options[:user] && !options[:auth_mech]
+          auth_db = options[:auth_source] || 'admin'
+          @request_auth_mech = "#{auth_db}.#{options[:user]}"
         end
       end
 

data/lib/mongo/server/connectable.rb

@@ -1,11 +1,11 @@
-# Copyright (C) 2015-2018 MongoDB, Inc.
-
+# Copyright (C) 2015-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
-
+#
+#   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.
@@ -15,7 +15,7 @@
 module Mongo
   class Server
 
-    # This provides common behaviour for connection objects.
+    # This provides common behavior for connection objects.
     #
     # @since 2.0.0
     module Connectable
@@ -86,7 +86,9 @@ module Mongo
           success = true
           result
         ensure
-          success or disconnect!
+          unless success
+            disconnect!
+          end
         end
       end
 
@@ -96,12 +98,6 @@ module Mongo
           @pid = Process.pid
         end
       end
-
-      def read(request_id = nil)
-        ensure_connected do |socket|
-          Protocol::Message.deserialize(socket, max_message_size, request_id)
-        end
-      end
     end
   end
 end

data/lib/mongo/server/connection.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2018 MongoDB, Inc.
+# Copyright (C) 2014-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.
@@ -50,7 +50,7 @@ module Mongo
       # @since 2.5.0
       #
       # @deprecated No longer necessary with Server Selection specification.
-      PING_OP_MSG_MESSAGE = Protocol::Msg.new([:none], {}, PING_OP_MSG)
+      PING_OP_MSG_MESSAGE = Protocol::Msg.new([], {}, PING_OP_MSG)
 
       # The ping message as raw bytes.
       #
@@ -66,11 +66,49 @@ 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.
+      #
+      # @api private
+      #
+      # @example Create the connection.
+      #   Connection.new(server)
+      #
+      # @note Connection must never be directly instantiated outside of a
+      #   Server.
+      #
+      # @param [ Mongo::Server ] server The server the connection is for.
+      # @param [ Hash ] options The connection options.
+      #
+      # @option options [ Integer ] :generation Connection pool's generation
+      #   for this connection.
+      #
+      # @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) }
+        @socket = nil
+        @last_checkin = nil
+        @auth_mechanism = nil
+        @pid = Process.pid
+      end
+
       # The last time the connection was checked back into a pool.
       #
       # @since 2.5.0
       attr_reader :last_checkin
 
+      # Connection pool generation from which this connection was created.
+      # May be nil.
+      #
+      # @since 2.7.0
+      # @api private
+      def generation
+        options[:generation]
+      end
+
       def_delegators :@server,
                      :features,
                      :max_bson_object_size,
@@ -94,10 +132,17 @@ module Mongo
       # @since 2.0.0
       def connect!
         unless socket && socket.connectable?
-          @socket = address.socket(socket_timeout, ssl_options)
-          address.connect_socket!(socket)
-          handshake!
-          authenticate!
+          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
         end
         true
       end
@@ -123,55 +168,34 @@ module Mongo
         true
       end
 
-      # Dispatch the provided messages to the connection. If the last message
-      # requires a response a reply will be returned.
+      # Dispatch a single message to the connection. If the message
+      # requires a response, a reply will be returned.
       #
-      # @example Dispatch the messages.
-      #   connection.dispatch([ insert, command ])
+      # @example Dispatch the message.
+      #   connection.dispatch([ insert ])
       #
       # @note This method is named dispatch since 'send' is a core Ruby method on
       #   all objects.
       #
-      # @param [ Array<Message> ] messages The messages to dispatch.
+      # @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)
-        if monitoring.subscribers?(Monitoring::COMMAND)
-          publish_command(messages, operation_id || Monitoring.next_operation_id) do |msgs|
-            deliver(msgs)
-          end
-        else
-          deliver(messages)
+        # 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
-      end
-
-      # Initialize a new socket connection from the client to the server.
-      #
-      # @api private
-      #
-      # @example Create the connection.
-      #   Connection.new(server)
-      #
-      # @note Connection must never be directly instantiated outside of a
-      #   Server.
-      #
-      # @param [ Mongo::Server ] server The server the connection is for.
-      # @param [ Hash ] options The connection options.
-      #
-      # @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) }
-        @socket = nil
-        @last_checkin = nil
-        @auth_mechanism = nil
-        @pid = Process.pid
+        message = messages.first
+        deliver(message)
       end
 
       # Ping the connection to see if the server is responding to commands.
@@ -225,32 +249,82 @@ module Mongo
 
       private
 
-      def deliver(messages)
-        write(messages)
-        messages.last.replyable? ? read(messages.last.request_id) : nil
+      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!
-        if socket && socket.connectable?
-          socket.write(app_metadata.ismaster_bytes)
-          response = Protocol::Message.deserialize(socket, max_message_size).documents[0]
-          min_wire_version = response[Description::MIN_WIRE_VERSION] || Description::LEGACY_WIRE_VERSION
-          max_wire_version = response[Description::MAX_WIRE_VERSION] || Description::LEGACY_WIRE_VERSION
-          features = Description::Features.new(min_wire_version..max_wire_version)
+        unless socket && socket.connectable?
+          raise Error::HandshakeError, "Cannot handshake because there is no usable socket"
+        end
+
+        @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
+
+          if exc
+            raise exc
+          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
-                              elsif features.scram_sha_1_enabled? || @server.features.scram_sha_1_enabled?
-                                :scram
-                              else
-                                :mongodb_cr
-                              end
+              if response['saslSupportedMechs'].include?(Mongo::Auth::SCRAM::SCRAM_SHA_256_MECHANISM)
+                :scram256
+              else
+                :scram
+              end
+            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
+            end
+          else
+            @auth_mechanism = nil
           end
+
+          new_description = Description.new(@server.description.address, response, average_rtt)
+          @server.monitor.publish(Event::DESCRIPTION_CHANGED, @server.description, new_description)
         end
       end
 
@@ -269,17 +343,15 @@ module Mongo
         @auth_mechanism || (@server.features.scram_sha_1_enabled? ? :scram : :mongodb_cr)
       end
 
-      def write(messages, buffer = BSON::ByteBuffer.new)
+      def serialize(message, buffer = BSON::ByteBuffer.new)
         start_size = 0
-        messages.each do |message|
-          message.compress!(compressor, options[:zlib_compression_level]).serialize(buffer, max_bson_object_size)
-          if max_message_size &&
-            (buffer.length - start_size) > max_message_size
-            raise Error::MaxMessageSize.new(max_message_size)
-            start_size = buffer.length
-          end
+        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
-        ensure_connected{ |socket| socket.write(buffer.to_s) }
+        buffer
       end
     end
   end