mongo 2.22.0 → 2.24.0

data/lib/mongo/socket.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -22,7 +21,6 @@ require 'mongo/socket/ocsp_verifier'
 require 'mongo/socket/ocsp_cache'
 
 module Mongo
-
   # Provides additional data around sockets for the driver's use.
   #
   # @since 2.0.0
@@ -34,23 +32,23 @@ module Mongo
     #
     # @since 2.0.0
     # @deprecated
-    SSL_ERROR = 'MongoDB may not be configured with TLS support'.freeze
+    SSL_ERROR = 'MongoDB may not be configured with TLS support'
 
     # Error message for timeouts on socket calls.
     #
     # @since 2.0.0
     # @deprecated
-    TIMEOUT_ERROR = 'Socket request timed out'.freeze
+    TIMEOUT_ERROR = 'Socket request timed out'
 
     # The pack directive for timeouts.
     #
     # @since 2.0.0
-    TIMEOUT_PACK = 'l_2'.freeze
+    TIMEOUT_PACK = 'l_2'
 
     # Write data to the socket in chunks of this size.
     #
     # @api private
-    WRITE_CHUNK_SIZE = 65536
+    WRITE_CHUNK_SIZE = 65_536
 
     # Initializes common socket attributes.
     #
@@ -120,13 +118,17 @@ module Mongo
     #
     # @api private
     def summary
-      fileno = @socket&.fileno rescue '<no socket>' || '<no socket>'
+      fileno = begin
+        @socket&.fileno
+      rescue StandardError
+        '<no socket>'
+      end
       if monitor?
         indicator = if options[:push]
-          'pm'
-        else
-          'm'
-        end
+                      'pm'
+                    else
+                      'm'
+                    end
         "#{connection_address};#{indicator};fd=#{fileno}"
       else
         "#{connection_address};c:#{connection_generation};fd=#{fileno}"
@@ -143,7 +145,7 @@ module Mongo
     # @deprecated Use #connectable? on the connection instead.
     def alive?
       sock_arr = [ @socket ]
-      if Kernel::select(sock_arr, nil, sock_arr, 0)
+      if Kernel.select(sock_arr, nil, sock_arr, 0)
         # The eof? call is supposed to return immediately since select
         # indicated the socket is readable. However, if @socket is a TLS
         # socket, eof? can block anyway - see RUBY-2140.
@@ -173,7 +175,7 @@ module Mongo
         ::Timeout.timeout(5) do
           @socket&.close
         end
-      rescue
+      rescue StandardError
         # Silence all errors
       end
       true
@@ -213,9 +215,8 @@ module Mongo
     #
     # @since 2.0.0
     def read(length, socket_timeout: nil, timeout: nil)
-      if !socket_timeout.nil? && !timeout.nil?
-        raise ArgumentError, 'Both timeout and socket_timeout cannot be set'
-      end
+      raise ArgumentError, 'Both timeout and socket_timeout cannot be set' if !socket_timeout.nil? && !timeout.nil?
+
       if !socket_timeout.nil? || timeout.nil?
         read_without_timeout(length, socket_timeout)
       else
@@ -286,13 +287,11 @@ module Mongo
         String.new.tap do |data|
           while data.length < length
             socket_timeout = deadline - Utils.monotonic_time
-            if socket_timeout <= 0
-              raise Mongo::Error::TimeoutError
-            end
+            raise Mongo::Error::TimeoutError if socket_timeout <= 0
+
             chunk = read_from_socket(length - data.length, socket_timeout: socket_timeout, csot: true)
-            unless chunk.length > 0
-              raise IOError, "Expected to read > 0 bytes but read 0 bytes"
-            end
+            raise IOError, 'Expected to read > 0 bytes but read 0 bytes' unless chunk.length > 0
+
             data << chunk
           end
         end
@@ -312,16 +311,14 @@ module Mongo
         String.new.tap do |data|
           while data.length < length
             chunk = read_from_socket(length - data.length, socket_timeout: socket_timeout)
-            unless chunk.length > 0
-              raise IOError, "Expected to read > 0 bytes but read 0 bytes"
-            end
+            raise IOError, 'Expected to read > 0 bytes but read 0 bytes' unless chunk.length > 0
+
             data << chunk
           end
         end
       end
     end
 
-
     # Reads the +length+ bytes from the socket. The read operation may involve
     # multiple socket reads, each read is limited to +timeout+ second,
     # if the parameter is provided.
@@ -333,11 +330,9 @@ module Mongo
     # @return [ Object ] The data from the socket.
     def read_from_socket(length, socket_timeout: nil, csot: false)
       # Just in case
-      if length == 0
-        return ''.force_encoding('BINARY')
-      end
+      return ''.force_encoding('BINARY') if length == 0
 
-      _timeout = socket_timeout || self.timeout
+      _timeout = socket_timeout || timeout
       if _timeout
         if _timeout > 0
           deadline = Utils.monotonic_time + _timeout
@@ -355,9 +350,7 @@ module Mongo
 
       # If we want to read less than the buffer size, just allocate the
       # memory that is necessary
-      if length < buf_size
-        buf_size = length
-      end
+      buf_size = length if length < buf_size
 
       # The binary encoding is important, otherwise Ruby performs encoding
       # conversions of some sort during the write into the buffer which
@@ -367,25 +360,19 @@ module Mongo
       begin
         while retrieved < length
           retrieve = length - retrieved
-          if retrieve > buf_size
-            retrieve = buf_size
-          end
+          retrieve = buf_size if retrieve > buf_size
           chunk = @socket.read_nonblock(retrieve, buf)
 
           # If we read the entire wanted length in one operation,
           # return the data as is which saves one memory allocation and
           # one copy per read
-          if retrieved == 0 && chunk.length == length
-            return chunk
-          end
+          return chunk if retrieved == 0 && chunk.length == length
 
           # If we are here, we are reading the wanted length in
           # multiple operations. Allocate the total buffer here rather
           # than up front so that the special case above won't be
           # allocating twice
-          if data.nil?
-            data = allocate_string(length)
-          end
+          data = allocate_string(length) if data.nil?
 
           # ... and we need to copy the chunks at this point
           data[retrieved, chunk.length] = chunk
@@ -393,40 +380,36 @@ module Mongo
         end
       # As explained in https://ruby-doc.com/core-trunk/IO.html#method-c-select,
       # reading from a TLS socket may require writing which may raise WaitWritable
-      rescue IO::WaitReadable, IO::WaitWritable => exc
+      rescue IO::WaitReadable, IO::WaitWritable => e
         if deadline
           select_timeout = deadline - Utils.monotonic_time
-          if select_timeout <= 0
-            raise_timeout_error!("Took more than #{_timeout} seconds to receive data", csot)
-          end
-        end
-        if exc.is_a?(IO::WaitReadable)
-          if pipe
-            select_args = [[@socket, pipe], nil, [@socket, pipe], select_timeout]
-          else
-            select_args = [[@socket], nil, [@socket], select_timeout]
-          end
-        else
-          select_args = [nil, [@socket], [@socket], select_timeout]
+          raise_timeout_error!("Took more than #{_timeout} seconds to receive data", csot) if select_timeout <= 0
         end
+        select_args = if e.is_a?(IO::WaitReadable)
+                        if pipe
+                          [ [ @socket, pipe ], nil, [ @socket, pipe ], select_timeout ]
+                        else
+                          [ [ @socket ], nil, [ @socket ], select_timeout ]
+                        end
+                      else
+                        [ nil, [ @socket ], [ @socket ], select_timeout ]
+                      end
 
         rv = Kernel.select(*select_args)
-        if Lint.enabled?
-          if pipe && rv&.include?(pipe)
-            # If the return value of select is the read end of the pipe, and
-            # an IOError is not raised, then that means the socket is still
-            # open. Select is interrupted be closing the write end of the
-            # pipe, which either returns the pipe if the socket is open, or
-            # raises an IOError if it isn't. Select is interrupted after all
-            # of the pending and checked out connections have been interrupted
-            # and closed, and this only happens once the pool is cleared with
-            # interrupt_in_use connections flag. This means that in order for
-            # the socket to still be open when the select is interrupted, and
-            # that socket is being read from, that means after clear was
-            # called, a connection from the previous generation was checked
-            # out of the pool, for reading on its socket. This should be impossible.
-            raise Mongo::LintError, "Select interrupted for live socket. This should be impossible."
-          end
+        if Lint.enabled? && pipe && rv&.include?(pipe)
+          # If the return value of select is the read end of the pipe, and
+          # an IOError is not raised, then that means the socket is still
+          # open. Select is interrupted be closing the write end of the
+          # pipe, which either returns the pipe if the socket is open, or
+          # raises an IOError if it isn't. Select is interrupted after all
+          # of the pending and checked out connections have been interrupted
+          # and closed, and this only happens once the pool is cleared with
+          # interrupt_in_use connections flag. This means that in order for
+          # the socket to still be open when the select is interrupted, and
+          # that socket is being read from, that means after clear was
+          # called, a connection from the previous generation was checked
+          # out of the pool, for reading on its socket. This should be impossible.
+          raise Mongo::LintError, 'Select interrupted for live socket. This should be impossible.'
         end
 
         if BSON::Environment.jruby?
@@ -437,9 +420,7 @@ module Mongo
           # Check the deadline ourselves.
           if deadline
             select_timeout = deadline - Utils.monotonic_time
-            if select_timeout <= 0
-              raise_timeout_error!("Took more than #{_timeout} seconds to receive data", csot)
-            end
+            raise_timeout_error!("Took more than #{_timeout} seconds to receive data", csot) if select_timeout <= 0
           end
         elsif rv.nil?
           raise_timeout_error!("Took more than #{_timeout} seconds to receive data (select call timed out)", csot)
@@ -451,20 +432,20 @@ module Mongo
     end
 
     def allocate_string(capacity)
-      String.new('', :capacity => capacity, :encoding => 'BINARY')
+      String.new('', capacity: capacity, encoding: 'BINARY')
     end
 
     def read_buffer_size
       # Buffer size for non-TLS reads
       # 64kb
-      65536
+      65_536
     end
 
     # Writes data to the socket instance.
     #
     # This is a separate method from +write+ for ease of mocking in the tests.
     # This method should not perform any exception mapping, upstream code
-    # sholud map exceptions.
+    # should map exceptions.
     #
     # @param [ Array<Object> ] args The data to be written.
     # @param [ Numeric ] :timeout The total timeout to the whole write operation.
@@ -478,7 +459,7 @@ module Mongo
       end
     end
 
-    # Writes data to to the socket.
+    # Writes data to the socket.
     #
     # @param [ Array<Object> ] args The data to be written.
     #
@@ -506,7 +487,7 @@ module Mongo
       end
     end
 
-    # Writes data to to the socket, the write duration is limited to +timeout+.
+    # Writes data to the socket, the write duration is limited to +timeout+.
     #
     # @param [ Array<Object> ] args The data to be written.
     # @param [ Numeric ] :timeout The total timeout to the whole write operation.
@@ -514,6 +495,7 @@ module Mongo
     # @return [ Integer ] The length of bytes written to the socket.
     def write_with_timeout(*args, timeout:)
       raise ArgumentError, 'timeout cannot be nil' if timeout.nil?
+
       raise_timeout_error!("Negative timeout #{timeout} given to socket", true) if timeout < 0
 
       written = 0
@@ -537,7 +519,7 @@ module Mongo
         begin
           written += @socket.write_nonblock(chunk[written..-1])
         rescue IO::WaitWritable, Errno::EINTR
-          if !wait_for_socket_to_be_writable(deadline)
+          unless wait_for_socket_to_be_writable(deadline)
             raise_timeout_error!("Took more than #{timeout} seconds to receive data", true)
           end
 
@@ -550,7 +532,7 @@ module Mongo
 
     def wait_for_socket_to_be_writable(deadline)
       select_timeout = deadline - Utils.monotonic_time
-      rv = Kernel.select(nil, [@socket], nil, select_timeout)
+      rv = Kernel.select(nil, [ @socket ], nil, select_timeout)
 
       if BSON::Environment.jruby?
         # Ignore the return value of Kernel.select.
@@ -583,7 +565,7 @@ module Mongo
       set_option(sock, :TCP_KEEPCNT, DEFAULT_TCP_KEEPCNT)
       set_option(sock, :TCP_KEEPIDLE, DEFAULT_TCP_KEEPIDLE)
       set_option(sock, :TCP_USER_TIMEOUT, DEFAULT_TCP_USER_TIMEOUT)
-    rescue
+    rescue StandardError
       # JRuby 9.2.13.0 and lower do not define TCP_KEEPINTVL etc. constants.
       # JRuby 9.2.14.0 defines the constants but does not allow to get or
       # set them with this error:
@@ -591,12 +573,12 @@ module Mongo
     end
 
     def set_option(sock, option, default)
-      if Socket.const_defined?(option)
-        system_default = sock.getsockopt(IPPROTO_TCP, option).int
-        if system_default > default
-          sock.setsockopt(IPPROTO_TCP, option, default)
-        end
-      end
+      return unless Socket.const_defined?(option)
+
+      system_default = sock.getsockopt(IPPROTO_TCP, option).int
+      return unless system_default > default
+
+      sock.setsockopt(IPPROTO_TCP, option, default)
     end
 
     def set_socket_options(sock)
@@ -605,15 +587,13 @@ module Mongo
     end
 
     def map_exceptions
-      begin
-        yield
-      rescue Errno::ETIMEDOUT => e
-        raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{human_address})"
-      rescue IOError, SystemCallError, ::SocketError => e
-        raise Error::SocketError, "#{e.class}: #{e} (for #{human_address})"
-      rescue OpenSSL::SSL::SSLError => e
-        raise Error::SocketError, "#{e.class}: #{e} (for #{human_address})"
-      end
+      yield
+    rescue Errno::ETIMEDOUT => e
+      raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{human_address})"
+    rescue IOError, SystemCallError, ::SocketError => e
+      raise Error::SocketError, "#{e.class}: #{e} (for #{human_address})"
+    rescue OpenSSL::SSL::SSLError => e
+      raise Error::SocketError, "#{e.class}: #{e} (for #{human_address})"
     end
 
     def human_address
@@ -621,11 +601,9 @@ module Mongo
     end
 
     def raise_timeout_error!(message = nil, csot = false)
-      if csot
-        raise Mongo::Error::TimeoutError
-      else
-        raise Errno::ETIMEDOUT, message
-      end
+      raise Mongo::Error::TimeoutError if csot
+
+      raise Errno::ETIMEDOUT, message
     end
   end
 end

data/lib/mongo/srv/monitor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   module Srv
-
     # Periodically retrieves SRV records for the cluster's SRV URI, and
     # sets the cluster's server list to the SRV lookup result.
     #
@@ -44,18 +42,15 @@ module Mongo
       #   Options to pass through to Resolv::DNS constructor for SRV lookups.
       def initialize(cluster, **opts)
         @cluster = cluster
-        unless @srv_uri = opts.delete(:srv_uri)
-          raise ArgumentError, 'SRV URI is required'
-        end
+        raise ArgumentError, 'SRV URI is required' unless @srv_uri = opts.delete(:srv_uri)
+
         @options = opts.freeze
         @resolver = Srv::Resolver.new(**opts)
         @last_result = @srv_uri.srv_result
         @stop_semaphore = Semaphore.new
       end
 
-      attr_reader :options
-
-      attr_reader :cluster
+      attr_reader :options, :cluster
 
       # @return [ Srv::Result ] Last known SRV lookup result. Used for
       #   determining intervals between SRV lookups, which depend on SRV DNS
@@ -72,7 +67,11 @@ module Mongo
       def scan!
         begin
           last_result = Timeout.timeout(timeout) do
-            @resolver.get_records(@srv_uri.query_hostname)
+            @resolver.get_records(
+              @srv_uri.query_hostname,
+              @srv_uri.uri_options[:srv_service_name] || options[:srv_service_name],
+              @srv_uri.uri_options[:srv_max_hosts] || @options[:srv_max_hosts]
+            )
           end
         rescue Resolv::ResolvTimeout => e
           log_warn("SRV monitor: timed out trying to resolve hostname #{@srv_uri.query_hostname}: #{e.class}: #{e}")
@@ -95,11 +94,11 @@ module Mongo
 
       def scan_interval
         if last_result.empty?
-          [cluster.heartbeat_interval, MIN_SCAN_INTERVAL].min
+          [ cluster.heartbeat_interval, MIN_SCAN_INTERVAL ].min
         elsif last_result.min_ttl.nil?
           MIN_SCAN_INTERVAL
         else
-          [last_result.min_ttl, MIN_SCAN_INTERVAL].max
+          [ last_result.min_ttl, MIN_SCAN_INTERVAL ].max
         end
       end
 

data/lib/mongo/srv/resolver.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2017-2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   module Srv
-
     # Encapsulates the necessary behavior for querying SRV records as
     # required by the driver.
     #
@@ -27,7 +25,7 @@ module Mongo
 
       # @return [ String ] RECORD_PREFIX The prefix prepended to each hostname
       #   before querying SRV records.
-      RECORD_PREFIX = '_mongodb._tcp.'.freeze
+      RECORD_PREFIX = '_mongodb._tcp.'
 
       # Generates the record prefix with a custom SRV service name if it is
       # provided.
@@ -35,8 +33,8 @@ module Mongo
       # @option srv_service_name [ String | nil ] The SRV service name to use
       #   in the record prefix.
       # @return [ String ] The generated record prefix.
-      def record_prefix(srv_service_name=nil)
-        return srv_service_name ? "_#{srv_service_name}._tcp." : RECORD_PREFIX
+      def record_prefix(srv_service_name = nil)
+        srv_service_name ? "_#{srv_service_name}._tcp." : RECORD_PREFIX
       end
 
       # Creates a new Resolver.
@@ -81,7 +79,7 @@ module Mongo
       #   option is true and no records are found.
       #
       # @return [ Mongo::Srv::Result ] SRV lookup result.
-      def get_records(hostname, srv_service_name=nil, srv_max_hosts=nil)
+      def get_records(hostname, srv_service_name = nil, srv_max_hosts = nil)
         query_name = record_prefix(srv_service_name) + hostname
         resources = @resolver.getresources(query_name, Resolv::DNS::Resource::IN::SRV)
 
@@ -91,30 +89,25 @@ module Mongo
         # added to the Result object.
         result = Srv::Result.new(hostname)
         resources.each do |record|
-          begin
-            result.add_record(record)
-          rescue Error::MismatchedDomain => e
-            if raise_on_invalid?
-              raise
-            else
-              log_warn(e.message)
-            end
-          end
+          result.add_record(record)
+        rescue Error::MismatchedDomain => e
+          raise if raise_on_invalid?
+
+          log_warn(e.message)
         end
 
         # If no records are found, either raise an error or log a warning
         # based on the Resolver's :raise_on_invalid option.
         if result.empty?
-          if raise_on_invalid?
-            raise Error::NoSRVRecords.new(URI::SRVProtocol::NO_SRV_RECORDS % hostname)
-          else
-            log_warn(URI::SRVProtocol::NO_SRV_RECORDS % hostname)
-          end
+          raise Error::NoSRVRecords.new(URI::SRVProtocol::NO_SRV_RECORDS % hostname) if raise_on_invalid?
+
+          log_warn(URI::SRVProtocol::NO_SRV_RECORDS % hostname)
+
         end
 
         # if srv_max_hosts is in [1, #addresses)
         if (1...result.address_strs.length).include? srv_max_hosts
-          sampled_records = resources.shuffle.first(srv_max_hosts)
+          sampled_records = resources.sample(srv_max_hosts)
           result = Srv::Result.new(hostname)
           sampled_records.each { |record| result.add_record(record) }
         end
@@ -131,9 +124,7 @@ module Mongo
       # @raise [ Mongo::Error::InvalidTXTRecord ] If more than one TXT record is found.
       def get_txt_options_string(hostname)
         records = @resolver.getresources(hostname, Resolv::DNS::Resource::IN::TXT)
-        if records.empty?
-          return nil
-        end
+        return nil if records.empty?
 
         if records.length > 1
           msg = "Only one TXT record is allowed: querying hostname #{hostname} returned #{records.length} records"

data/lib/mongo/srv/result.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2017-2020 MongoDB Inc.
 #
@@ -17,7 +16,6 @@
 
 module Mongo
   module Srv
-
     # SRV record lookup result.
     #
     # Contains server addresses that the query resolved to, and minimum TTL
@@ -29,8 +27,8 @@ module Mongo
 
       # @return [ String ] MISMATCHED_DOMAINNAME Error message format string indicating that an SRV
       #   record found does not match the domain of a hostname.
-      MISMATCHED_DOMAINNAME = "Parent domain name in SRV record result (%s) does not match " +
-                                 "that of the hostname (%s)".freeze
+      MISMATCHED_DOMAINNAME = 'Parent domain name in SRV record result (%s) does not match ' +
+                              'that of the hostname (%s)'
 
       # @return [ String ] query_hostname The hostname pointing to the DNS records.
       attr_reader :query_hostname
@@ -68,18 +66,18 @@ module Mongo
         validate_hostname!(record_host)
         validate_same_origin!(record_host)
         address_str = if record_host.index(':')
-          # IPV6 address
-          "[#{record_host}]:#{port}"
-        else
-          "#{record_host}:#{port}"
-        end
+                        # IPV6 address
+                        "[#{record_host}]:#{port}"
+                      else
+                        "#{record_host}:#{port}"
+                      end
         @address_strs << address_str
 
-        if @min_ttl.nil?
-          @min_ttl = record.ttl
-        else
-          @min_ttl = [@min_ttl, record.ttl].min
-        end
+        @min_ttl = if @min_ttl.nil?
+                     record.ttl
+                   else
+                     [ @min_ttl, record.ttl ].min
+                   end
 
         nil
       end
@@ -99,9 +97,7 @@ module Mongo
       # @param [ String ] host Hostname to transform.
       def normalize_hostname(host)
         host = host.downcase
-        unless host.end_with?('..')
-          host = host.sub(/\.\z/, '')
-        end
+        host = host.delete_suffix('.') unless host.end_with?('..')
         host
       end
 
@@ -111,16 +107,24 @@ module Mongo
       # parts after the first. For example, the hostname 'foo.bar.baz'
       # has the domain name 'bar.baz'.
       #
+      # If the hostname has less than three parts, its domain name is the hostname itself.
+      #
       # @param [ String ] record_host The host of the SRV record.
       #
       # @raise [ Mongo::Error::MismatchedDomain ] If the record's domain name doesn't match that of
       #   the hostname.
       def validate_same_origin!(record_host)
-        domain_name ||= query_hostname.split('.')[1..-1]
-        host_parts = record_host.split('.')
+        srv_host_domain = query_hostname.split('.')
+        srv_is_less_than_three_parts = srv_host_domain.length < 3
+        srv_host_domain = srv_host_domain[1..-1] unless srv_is_less_than_three_parts
+        record_host_parts = record_host.split('.')
+
+        if srv_is_less_than_three_parts && record_host_parts.length <= srv_host_domain.length
+          raise Error::MismatchedDomain.new(format(MISMATCHED_DOMAINNAME, record_host, srv_host_domain))
+        end
 
-        unless (host_parts.size > domain_name.size) && (domain_name == host_parts[-domain_name.length..-1])
-          raise Error::MismatchedDomain.new(MISMATCHED_DOMAINNAME % [record_host, domain_name])
+        unless (record_host_parts.size > srv_host_domain.size) && (srv_host_domain == record_host_parts[-srv_host_domain.size..-1])
+          raise Error::MismatchedDomain.new(format(MISMATCHED_DOMAINNAME, record_host, srv_host_domain))
         end
       end
     end

data/lib/mongo/srv.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2019-2020 MongoDB Inc.
 #