mongo 2.11.4 → 2.12.3

data/lib/mongo/server/connection_pool/populator.rb

@@ -21,7 +21,7 @@ module Mongo
     class Populator
       include BackgroundThread
 
-      # @param [ Server::ConnectionPool ] The connection pool.
+      # @param [ Server::ConnectionPool ] pool The connection pool.
       # @param [ Hash ] options The options.
       #
       # @option options [ Logger ] :logger A custom logger to use.

data/lib/mongo/server/description.rb

@@ -370,8 +370,11 @@ module Mongo
 
       # Get the me field value.
       #
-      # @example Get the me field value.
-      #   description.me
+      # @note The value in me field may differ from the server description's
+      #   address. This can happen, for example, in split horizon configurations.
+      #   The SDAM spec only requires removing servers whose me does not match
+      #   their address in some of the situations (e.g. when the server in
+      #   question is an RS member but not a primary).
       #
       # @return [ String ] The me field.
       #
@@ -723,7 +726,10 @@ module Mongo
       def ==(other)
         return false if self.class != other.class
         return false if unknown? || other.unknown?
-        compare_config(other)
+
+        (config.keys + other.config.keys).uniq.all? do |k|
+          config[k] == other.config[k] || EXCLUDE_FOR_COMPARISON.include?(k)
+        end
       end
       alias_method :eql?, :==
 
@@ -750,14 +756,6 @@ module Mongo
 
         required_wv >= min_wire_version && required_wv <= max_wire_version
       end
-
-      private
-
-      def compare_config(other)
-        (config.keys + other.config.keys).uniq.all? do |k|
-          config[k] == other.config[k] || EXCLUDE_FOR_COMPARISON.include?(k)
-        end
-      end
     end
   end
 end

data/lib/mongo/server/monitor.rb

@@ -94,6 +94,8 @@ module Mongo
 
       # The compressor is determined during the handshake, so it must be an attribute
       # of the connection.
+      #
+      # @deprecated
       def_delegators :connection, :compressor
 
       # @return [ Monitoring ] monitoring The monitoring.

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

@@ -19,7 +19,7 @@ module Mongo
       # This class models the monitor connections and their behavior.
       #
       # @since 2.0.0
-      class Connection
+      class Connection < Server::ConnectionCommon
         include Retryable
         include Connectable
         include Loggable
@@ -64,12 +64,14 @@ module Mongo
         # Key for compression algorithms in the response from the server during handshake.
         #
         # @since 2.5.0
+        # @deprecated
         COMPRESSION = 'compression'.freeze
 
         # Warning message that the server has no compression algorithms in common with those requested
         #   by the client.
         #
         # @since 2.5.0
+        # @deprecated
         COMPRESSION_WARNING = 'The server has no compression algorithms in common with those requested. ' +
                                 'Compression will not be used.'.freeze
 
@@ -125,11 +127,6 @@ module Mongo
         # @return [ Mongo::Address ] address The address to connect to.
         attr_reader :address
 
-        # The compressor, which is determined during the handshake.
-        #
-        # @since 2.5.0
-        attr_reader :compressor
-
         # Send the preserialized ismaster call.
         #
         # @example Send a preserialized ismaster message.
@@ -209,18 +206,6 @@ module Mongo
 
         private
 
-        def set_compressor!(reply)
-          server_compressors = reply[COMPRESSION]
-
-          if options[:compressors]
-            if intersection = (server_compressors & options[:compressors])
-              @compressor = intersection[0]
-            else
-              log_warn(COMPRESSION_WARNING)
-            end
-          end
-        end
-
         def handshake!(socket)
           if @app_metadata
             socket.write(@app_metadata.ismaster_bytes)

data/lib/mongo/server/pending_connection.rb

@@ -21,8 +21,9 @@ module Mongo
     class PendingConnection < ConnectionBase
       extend Forwardable
 
-      def initialize(socket, server, monitoring, options = {})
+      def initialize(socket, description, server, monitoring, options = {})
         @socket = socket
+        @description = description
         @options = options
         @server = server
         @monitoring = monitoring

data/lib/mongo/session.rb

@@ -578,7 +578,7 @@ module Mongo
               txn_num: txn_num,
               write_concern: write_concern,
             }
-            Operation::Command.new(spec).execute(server)
+            Operation::Command.new(spec).execute(server, client: @client)
           end
         end
       ensure
@@ -622,7 +622,7 @@ module Mongo
               db_name: 'admin',
               session: self,
               txn_num: txn_num
-            ).execute(server)
+            ).execute(server, client: @client)
           end
         end
 
@@ -697,7 +697,7 @@ module Mongo
     # The exception instance should already have all of the labels set on it
     # (both client- and server-side generated ones).
     #
-    # @param [ Error ] The exception instance to process.
+    # @param [ Error ] error The exception instance to process.
     #
     # @api private
     def unpin_maybe(error)

data/lib/mongo/session/session_pool.rb

@@ -113,9 +113,14 @@ module Mongo
       def end_sessions
         while !@queue.empty?
           server = ServerSelector.get(mode: :primary_preferred).select_server(@cluster)
-          Operation::Command.new(
-              :selector => {endSessions: @queue.shift(10_000).collect { |s| s.session_id }},
-              :db_name => Database::ADMIN).execute(server)
+          op = Operation::Command.new(
+            selector: {
+              endSessions: @queue.shift(10_000).map(&:session_id),
+            },
+            db_name: Database::ADMIN,
+          )
+          # end_sessions does not take a client as an argument
+          op.execute(server, client: nil)
         end
       rescue Mongo::Error, Error::AuthError
       end

data/lib/mongo/socket.rb

@@ -40,6 +40,11 @@ module Mongo
     # @since 2.0.0
     TIMEOUT_PACK = 'l_2'.freeze
 
+    # Write data to the socket in chunks of this size.
+    #
+    # @api private
+    WRITE_CHUNK_SIZE = 65536
+
     # @return [ Integer ] family The type of host family.
     attr_reader :family
 
@@ -87,7 +92,7 @@ module Mongo
     #
     # @since 2.0.0
     def close
-      @socket.close rescue true
+      @socket.close rescue nil
       true
     end
 
@@ -105,20 +110,6 @@ module Mongo
       handle_errors { @socket.gets(*args) }
     end
 
-    # Create the new socket for the provided family - ipv4, piv6, or unix.
-    #
-    # @example Create a new ipv4 socket.
-    #   Socket.new(Socket::PF_INET)
-    #
-    # @param [ Integer ] family The socket domain.
-    #
-    # @since 2.0.0
-    def initialize(family)
-      @family = family
-      @socket = ::Socket.new(family, SOCK_STREAM, 0)
-      set_socket_options(@socket)
-    end
-
     # Will read all data from the socket for the provided number of bytes.
     # If no data is returned, an exception will be raised.
     #
@@ -172,7 +163,29 @@ module Mongo
     #
     # @since 2.0.0
     def write(*args)
-      handle_errors { @socket.write(*args) }
+      handle_errors do
+        # This method used to forward arguments to @socket.write in a
+        # single call like so:
+        #
+        # @socket.write(*args)
+        #
+        # Turns out, when each buffer to be written is large (e.g. 32 MiB),
+        # this write call would take an extremely long time (20+ seconds)
+        # while using 100% CPU. Splitting the writes into chunks produced
+        # massively better performance (0.05 seconds to write the 32 MiB of
+        # data on the same hardware). Unfortunately splitting the data,
+        # one would assume, results in it being copied, but this seems to be
+        # a much more minor issue compared to CPU cost of writing large buffers.
+        args.each do |buf|
+          buf = buf.to_s
+          i = 0
+          while i < buf.length
+            chunk = buf[i...i+WRITE_CHUNK_SIZE]
+            @socket.write(chunk)
+            i += WRITE_CHUNK_SIZE
+          end
+        end
+      end
     end
 
     # Tests if this socket has reached EOF. Primarily used for liveness checks.

data/lib/mongo/socket/ssl.rb

@@ -46,12 +46,22 @@ module Mongo
       # @since 2.0.0
       def connect!
         Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError) do
-          handle_errors { @tcp_socket.connect(::Socket.pack_sockaddr_in(port, host)) }
+          handle_errors do
+            @tcp_socket.connect(::Socket.pack_sockaddr_in(port, host))
+          end
           @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
-          @socket.hostname = @host_name
-          @socket.sync_close = true
-          handle_errors { @socket.connect }
-          verify_certificate!(@socket)
+          begin
+            @socket.hostname = @host_name
+            @socket.sync_close = true
+            handle_errors do
+              @socket.connect
+            end
+            verify_certificate!(@socket)
+          rescue
+            @socket.close
+            @socket = nil
+            raise
+          end
           self
         end
       end
@@ -76,9 +86,14 @@ module Mongo
         @context = create_context(options)
         @family = family
         @tcp_socket = ::Socket.new(family, SOCK_STREAM, 0)
-        @tcp_socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
-        set_socket_options(@tcp_socket)
-        connect!
+        begin
+          @tcp_socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
+          set_socket_options(@tcp_socket)
+          connect!
+        rescue
+          @tcp_socket.close
+          raise
+        end
       end
 
       # Read a single byte from the socket.

data/lib/mongo/socket/tcp.rb

@@ -40,7 +40,9 @@ module Mongo
       def connect!
         Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError) do
           socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
-          handle_errors { socket.connect(::Socket.pack_sockaddr_in(port, host)) }
+          handle_errors do
+            socket.connect(::Socket.pack_sockaddr_in(port, host))
+          end
           self
         end
       end
@@ -63,8 +65,15 @@ module Mongo
       # @since 2.0.0
       def initialize(host, port, timeout, family, options = {})
         @host, @port, @timeout, @options = host, port, timeout, options
-        super(family)
-        connect!
+        @family = family
+        @socket = ::Socket.new(family, SOCK_STREAM, 0)
+        begin
+          set_socket_options(@socket)
+          connect!
+        rescue
+          @socket.close
+          raise
+        end
       end
 
       private

data/lib/mongo/srv/monitor.rb

@@ -13,65 +13,94 @@
 # limitations under the License.
 
 module Mongo
-  module SRV
+  module Srv
 
-    # Polls SRV records for the URI that a cluster was created for and
-    # updates the list of servers in the cluster when records change.
+    # Periodically retrieves SRV records for the cluster's SRV URI, and
+    # sets the cluster's server list to the SRV lookup result.
+    #
+    # If an error is encountered during SRV lookup or an SRV record is invalid
+    # or disallowed for security reasons, a warning is logged and monitoring
+    # continues.
     #
     # @api private
     class Monitor
       include Loggable
-
-      MIN_RESCAN_FREQUENCY = 60
+      include BackgroundThread
+
+      MIN_SCAN_INTERVAL = 60
+
+      DEFAULT_TIMEOUT = 10
+
+      # Creates the SRV monitor.
+      #
+      # @param [ Cluster ] cluster The cluster.
+      # @param [ Hash ] options The cluster options.
+      #
+      # @option options [ Float ] :timeout The timeout to use for DNS lookups.
+      # @option options [ URI::SRVProtocol ] :srv_uri The SRV URI to monitor.
+      # @option options [ Hash ] :resolv_options For internal driver use only.
+      #   Options to pass through to Resolv::DNS constructor for SRV lookups.
+      def initialize(cluster, options = nil)
+        options = if options
+          options.dup
+        else
+          {}
+        end
+        @cluster = cluster
+        @resolver = Srv::Resolver.new(options)
+        unless @srv_uri = options.delete(:srv_uri)
+          raise ArgumentError, 'SRV URI is required'
+        end
+        @options = options.freeze
+        @last_result = @srv_uri.srv_result
+        @stop_semaphore = Semaphore.new
+      end
 
       attr_reader :options
 
-      def initialize(cluster, resolver, srv_records, options = nil)
-        @options = options || {}
-        @cluster = cluster
-        @resolver = resolver
-        @records = srv_records
-        @no_records_found = false
-      end
+      attr_reader :cluster
 
-      def start_monitor!
-        @thread = Thread.new do
-          loop do
-            sleep(rescan_frequency)
-            scan!
-          end
-        end
+      # @return [ Srv::Result ] Last known SRV lookup result. Used for
+      #   determining intervals between SRV lookups, which depend on SRV DNS
+      #   records' TTL values.
+      attr_reader :last_result
 
+      def start!
+        super
         ObjectSpace.define_finalizer(self, self.class.finalize(@thread))
       end
 
+      private
+
+      def do_work
+        scan!
+        @stop_semaphore.wait(scan_interval)
+      end
+
       def scan!
-        @old_hosts = @records.hosts
+        old_hosts = last_result.address_strs
 
         begin
-          @records = @resolver.get_records(@records.hostname)
+          last_result = Timeout.timeout(timeout) do
+            @resolver.get_records(@srv_uri.query_hostname)
+          end
         rescue Resolv::ResolvTimeout => e
-          log_warn("Timed out trying to resolve hostname #{@records.hostname}")
+          log_warn("SRV monitor: timed out trying to resolve hostname #{@srv_uri.query_hostname}: #{e.class}: #{e}")
+          return
+        rescue ::Timeout::Error
+          log_warn("SRV monitor: timed out trying to resolve hostname #{@srv_uri.query_hostname} (timeout=#{timeout})")
           return
         rescue Resolv::ResolvError => e
-          log_warn("Unable to resolve hostname #{@records.hostname}")
+          log_warn("SRV monitor: unable to resolve hostname #{@srv_uri.query_hostname}: #{e.class}: #{e}")
           return
         end
 
-        if @records.empty?
-          @no_records_found = true
+        if last_result.empty?
+          log_warn("SRV monitor: hostname #{@srv_uri.query_hostname} resolved to zero records")
           return
         end
 
-        @no_records_found = false
-
-        (@old_hosts - @records.hosts).each do |host|
-          @cluster.remove(host)
-        end
-
-        (@records.hosts - @old_hosts).each do |host|
-          @cluster.add(host)
-        end
+        @cluster.set_server_list(last_result.address_strs)
       end
 
       def self.finalize(thread)
@@ -80,17 +109,19 @@ module Mongo
         end
       end
 
-      private
-
-      def rescan_frequency
-        if @no_records_found
-          Server:: Monitor::HEARTBEAT_FREQUENCY
-        elsif @records.min_ttl.nil?
-          MIN_RESCAN_FREQUENCY
+      def scan_interval
+        if last_result.empty?
+          [cluster.heartbeat_interval, MIN_SCAN_INTERVAL].min
+        elsif last_result.min_ttl.nil?
+          MIN_SCAN_INTERVAL
         else
-          [@records.min_ttl, MIN_RESCAN_FREQUENCY].max
+          [last_result.min_ttl, MIN_SCAN_INTERVAL].max
         end
       end
+
+      def timeout
+        options[:timeout] || DEFAULT_TIMEOUT
+      end
     end
   end
 end