mongo 2.10.5 → 2.11.0.rc0

data/lib/mongo/uri/srv_protocol.rb

@@ -33,6 +33,8 @@ module Mongo
     # @since 2.5.0
     class SRVProtocol < URI
 
+      attr_reader :srv_records
+
       # Gets the options hash that needs to be passed to a Mongo::Client on instantiation, so we
       # don't have to merge the txt record options, credentials, and database in at that point -
       # we only have a single point here.
@@ -49,49 +51,93 @@ module Mongo
         @user ? opts.merge(credentials) : opts
       end
 
-      private
+      # @return [ Srv::Result ] SRV lookup result.
+      #
+      # @api private
+      attr_reader :srv_result
+
+      # The hostname that is specified in the URI and used to look up
+      # SRV records.
+      #
+      # This attribute needs to be defined because SRVProtocol changes
+      # #servers to be the result of the lookup rather than the hostname
+      # specified in the URI.
+      #
+      # @return [ String ] The hostname used in SRV lookup.
+      #
+      # @api private
+      attr_reader :query_hostname
 
-      RECORD_PREFIX = '_mongodb._tcp.'.freeze
+      private
 
+      # @return [ String ] DOT_PARTITION The '.' character used to delineate the parts of a
+      #   hostname.
+      #
+      # @deprecated
       DOT_PARTITION = '.'.freeze
 
+      # @return [ Array<String> ] VALID_TXT_OPTIONS The valid options for a TXT record to specify.
       VALID_TXT_OPTIONS = ['replicaset', 'authsource'].freeze
 
+      # @return [ String ] INVALID_HOST Error message format string indicating that the hostname in
+      #   in the URI does not fit the expected form.
       INVALID_HOST = "One and only one host is required in a connection string with the " +
                        "'#{MONGODB_SRV_SCHEME}' protocol.".freeze
 
+      # @return [ String ] INVALID_PORT Error message format string indicating that a port was
+      #   included with an SRV hostname.
       INVALID_PORT = "It is not allowed to specify a port in a connection string with the " +
                        "'#{MONGODB_SRV_SCHEME}' protocol.".freeze
 
+      # @return [ String ] INVALID_DOMAIN Error message format string indicating that the domain name
+      #   of the hostname does not fit the expected form.
       # @deprecated
       INVALID_DOMAIN = "The domain name must consist of at least two parts: the domain name, " +
                          "and a TLD.".freeze
 
+      # @return [ String ] NO_SRV_RECORDS Error message format string indicating that no SRV records
+      #   were found.
       NO_SRV_RECORDS = "The DNS query returned no SRV records at hostname (%s)".freeze
 
-      MORE_THAN_ONE_TXT_RECORD_FOUND = "Only one TXT record is allowed. Querying hostname (%s) " +
-                                         "returned more than one result.".freeze
-
+      # @return [ String ] INVALID_TXT_RECORD_OPTION Error message format string indicating that an
+      #   unexpected TXT record option was found.
       INVALID_TXT_RECORD_OPTION = "TXT records can only specify the options " +
                                     "[#{VALID_TXT_OPTIONS.join(', ')}].".freeze
 
-      MISMATCHED_DOMAINNAME = "Parent domain name in SRV record result (%s) does not match " +
-                                 "that of the hostname (%s)".freeze
-
+      # @return [ String ] FORMAT The expected SRV URI format.
       FORMAT = 'mongodb+srv://[username:password@]host[/[database][?options]]'.freeze
 
+      # Gets the MongoDB SRV URI scheme.
+      #
+      # @return [ String ] The MongoDB SRV URI scheme.
       def scheme
         MONGODB_SRV_SCHEME
       end
 
+      # Raises an InvalidURI error.
+      #
+      # @param [ String ] details A detailed error message.
+      #
+      # @raise [ Mongo::Error::InvalidURI ]
       def raise_invalid_error!(details)
         raise Error::InvalidURI.new(@string, details, FORMAT)
       end
 
+      # Gets the SRV resolver.
+      #
+      # @return [ Mongo::Srv::Resolver ]
       def resolver
-        @resolver ||= Resolv::DNS.new
+        @resolver ||= Srv::Resolver.new(
+          raise_on_invalid: true,
+          resolv_options: options[:resolv_options],
+        )
       end
 
+      # Parses the credentials from the URI and performs DNS queries to obtain
+      # the hosts and TXT options.
+      #
+      # @param [ String ] remaining The portion of the URI pertaining to the
+      #   authentication credentials and the hosts.
       def parse!(remaining)
         super
 
@@ -99,14 +145,21 @@ module Mongo
           raise_invalid_error!(INVALID_HOST)
         end
         hostname = @servers.first
-        validate_hostname(hostname)
+        validate_srv_hostname(hostname)
+        @query_hostname = hostname
 
-        records = get_records(hostname)
-        @txt_options = get_txt_opts(hostname) || {}
+        @srv_result = resolver.get_records(hostname)
+        if srv_result.empty?
+          raise Error::NoSRVRecords.new(NO_SRV_RECORDS % hostname)
+        end
+        @txt_options = get_txt_options(hostname) || {}
+        records = srv_result.address_strs
         records.each do |record|
-          validate_host!(record)
+          validate_address_str!(record)
         end
         @servers = records
+      rescue Error::InvalidAddress => e
+        raise_invalid_error!(e.message)
       end
 
       # Validates the hostname used in an SRV URI.
@@ -118,7 +171,7 @@ module Mongo
       # components (foo.bar.tld).
       #
       # Raises Error::InvalidURI if validation fails.
-      def validate_hostname(hostname)
+      def validate_srv_hostname(hostname)
         raise_invalid_error!(INVALID_PORT) if hostname.include?(HOST_PORT_DELIM)
 
         if hostname.start_with?('.')
@@ -136,39 +189,33 @@ module Mongo
         end
       end
 
-      def get_records(hostname)
-        query_name = RECORD_PREFIX + hostname
-        records = resolver.getresources(query_name, Resolv::DNS::Resource::IN::SRV).collect do |record|
-          record_host = record.target.to_s
-          port = record.port
-          validate_record!(record_host, hostname)
-          "#{record_host}#{HOST_PORT_DELIM}#{port}"
-        end
-        raise Error::NoSRVRecords.new(NO_SRV_RECORDS % hostname) if records.empty?
-        records
-      end
-
-      def validate_record!(record_host, hostname)
-        domainname = hostname.split(DOT_PARTITION)[1..-1]
-        host_parts = record_host.split(DOT_PARTITION)
-        unless (host_parts.size > domainname.size) && (domainname == host_parts[-domainname.length..-1])
-          raise Error::MismatchedDomain.new(MISMATCHED_DOMAINNAME % [record_host, domainname])
-        end
-      end
-
-      def get_txt_opts(host)
-        records = resolver.getresources(host, Resolv::DNS::Resource::IN::TXT)
-        unless records.empty?
-          if records.size > 1
-            raise Error::InvalidTXTRecord.new(MORE_THAN_ONE_TXT_RECORD_FOUND % host)
-          end
-          options_string = records[0].strings.join
+      # Obtains the TXT options of a host.
+      #
+      # @param [ String ] hostname The hostname whose records should be obtained.
+      #
+      # @return [ Hash ] The TXT record options (an empyt hash if no TXT
+      #   records are found).
+      #
+      # @raise [ Mongo::Error::InvalidTXTRecord ] If more than one TXT record is found.
+      def get_txt_options(hostname)
+        options_string = resolver.get_txt_options_string(hostname)
+        if options_string
           parse_txt_options!(options_string)
+        else
+          {}
         end
       end
 
+      # Parses the TXT record options into a hash and adds the options to set of all URI options
+      # parsed.
+      #
+      # @param [ String ] string The concatenated TXT options.
+      #
+      # @return [ Hash ] The parsed TXT options.
+      #
+      # @raise [ Mongo::Error::InvalidTXTRecord ] If the TXT record does not fit the expected form
+      #   or the option specified is not a valid TXT option.
       def parse_txt_options!(string)
-        return {} unless string
         string.split(INDIV_URI_OPTS_DELIM).reduce({}) do |txt_options, opt|
           raise Error::InvalidTXTRecord.new(INVALID_OPTS_VALUE_DELIM) unless opt.index(URI_OPTS_VALUE_DELIM)
           key, value = opt.split(URI_OPTS_VALUE_DELIM)

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.10.5'.freeze
+  VERSION = '2.11.0.rc0'.freeze
 end

data/mongo.gemspec

@@ -4,10 +4,7 @@ require 'mongo/version'
 
 Gem::Specification.new do |s|
   s.name              = 'mongo'
-  # The dup call makes `bundle install` work on ruby 1.9.3.
-  # Without it rubygems tries to modify version which fails because
-  # Mongo::VERSION is frozen.
-  s.version           = Mongo::VERSION.dup
+  s.version           = Mongo::VERSION
   s.platform          = Gem::Platform::RUBY
 
   s.authors           = ['Tyler Brock', 'Emily Stolfo', 'Durran Jordan']
@@ -32,5 +29,7 @@ Gem::Specification.new do |s|
   s.require_paths     = ['lib']
   s.bindir            = 'bin'
 
+  s.required_ruby_version = ">= 2.3"
+
   s.add_dependency 'bson', '>=4.4.2', '<5.0.0'
 end

data/spec/README.md

@@ -78,12 +78,17 @@ configuration is needed:
 
 A sharded cluster can be configured with mlaunch:
 
-    mlaunch init --replicaset --name ruby-driver-rs --sharded 1 \
+    mlaunch init --replicaset --name ruby-driver-rs --sharded 1 --mongos 2 \
       --dir /tmp/mdb-sc --setParameter enableTestCommands=1
 
 As with the replica set, the test suite will automatically detect sharded
 cluster topology.
 
+Note that some tests require a sharded cluster with exactly one shard and
+other tests require a sharded cluster with more than one shard. Tests requiring
+a single shard can be run against a deployment with multiple shards by
+specifying only one mongos address in MONGODB_URI.
+
 ## TLS With Verification
 
 The test suite includes a set of TLS certificates for configuring a server

data/spec/enterprise_auth/kerberos_spec.rb

@@ -1,6 +1,13 @@
 require 'mongo'
+require 'support/lite_constraints'
+
+RSpec.configure do |config|
+  config.extend(LiteConstraints)
+end
 
 describe 'kerberos authentication' do
+  require_mongo_kerberos
+
   let(:user) do
    "#{ENV['SASL_USER']}%40#{ENV['SASL_HOST'].upcase}"
   end
@@ -25,13 +32,7 @@ describe 'kerberos authentication' do
     Mongo::Client.new(uri)
   end
 
-  before do
-    skip 'ENTERPRISE_AUTH_TESTS env var not specified' unless ENV['ENTERPRISE_AUTH_TESTS']
-  end
-
   let(:doc) do
-    require 'mongo_kerberos'
-
     client.database[:test].find.first
   end
 

data/spec/integration/change_stream_examples_spec.rb

@@ -22,10 +22,6 @@ describe 'change streams examples in Ruby' do
     inventory.drop
   end
 
-  after do
-    client.close(true)
-  end
-
   context 'example 1 - basic watching'do
 
     it 'returns a change after an insertion' do

data/spec/integration/client_construction_spec.rb

@@ -31,6 +31,18 @@ describe 'Client construction' do
       expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::Single)
       expect(client.options[:connect]).to eq :direct
     end
+
+    it 'creates connection pool and keeps it populated' do
+      client = ClientRegistry.instance.new_local_client([SpecConfig.instance.addresses.first],
+        base_options.merge(min_pool_size: 1))
+      # allow connection pool to populate
+      sleep 0.1
+
+      server = client.cluster.next_primary
+      expect(server.pool.size).to eq(1)
+      client['client_construction'].insert_one(test: 1)
+      expect(server.pool.size).to eq(1)
+    end
   end
 
   context 'in replica set topology' do
@@ -61,7 +73,7 @@ describe 'Client construction' do
     end
 
     it 'connects directly' do
-      primary_address = ClusterConfig.instance.primary_address
+      primary_address = ClusterConfig.instance.primary_address_str
       client = ClientRegistry.instance.new_local_client([primary_address],
         base_options.merge(connect: :direct))
       client['client_construction'].insert_one(test: 1)
@@ -84,7 +96,7 @@ describe 'Client construction' do
     end
 
     it 'connects directly' do
-      primary_address = ClusterConfig.instance.primary_address
+      primary_address = ClusterConfig.instance.primary_address_str
       client = ClientRegistry.instance.new_local_client([SpecConfig.instance.addresses.first],
         base_options.merge(connect: :direct))
       client['client_construction'].insert_one(test: 1)

data/spec/integration/connect_single_rs_name_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe 'Direct connection with RS name' do
   before(:all) do
     # preload
-    ClientRegistry.instance.close_all_clients
     ClusterConfig.instance.replica_set_name
-    ClientRegistry.instance.close_all_clients
   end
 
+  clean_slate_for_all
+
   shared_examples_for 'passes RS name to topology' do
     it 'passes RS name to topology' do
       expect(client.cluster.topology.replica_set_name).to eq(replica_set_name)

data/spec/integration/connection_pool_populator_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+
+describe 'Connection pool populator integration' do
+  let(:options) { {} }
+
+  let(:server_options) do
+    SpecConfig.instance.test_options.merge(options).merge(SpecConfig.instance.auth_options)
+  end
+
+  let(:address) do
+    Mongo::Address.new(SpecConfig.instance.addresses.first)
+  end
+
+  let(:monitoring) do
+    Mongo::Monitoring.new(monitoring: false)
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  declare_topology_double
+
+  let(:cluster) do
+    double('cluster').tap do |cl|
+      allow(cl).to receive(:topology).and_return(topology)
+      allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:options).and_return({})
+      allow(cl).to receive(:update_cluster_time)
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:run_sdam_flow)
+    end
+  end
+
+  let(:server) do
+    register_server(
+      Mongo::Server.new(address, cluster, monitoring, listeners,
+        {monitoring_io: false}.update(server_options)
+      ).tap do |server|
+        allow(server).to receive(:description).and_return(ClusterConfig.instance.primary_description)
+      end
+    )
+  end
+
+  let(:pool) do
+    server.pool
+  end
+
+  describe '#initialize' do
+    context 'when a min size is provided' do
+
+      let(:options) do
+        { min_pool_size: 2, max_pool_size: 5 }
+      end
+
+      it 'creates the pool with min pool size connections' do
+        pool
+        sleep 2
+
+        expect(pool.size).to eq(2)
+        expect(pool.available_count).to eq(2)
+      end
+
+      it 'does not use the same objects in the pool' do
+        expect(pool.check_out).to_not equal(pool.check_out)
+      end
+    end
+
+    context 'when min size is zero' do
+
+      it 'does not start the background thread' do
+        pool
+        sleep 2
+
+        expect(pool.size).to eq(0)
+        expect(pool.instance_variable_get('@populator').running?).to be false
+      end
+    end
+  end
+
+  describe '#clear' do
+    context 'when a min size is provided' do
+       let(:options) do
+        { min_pool_size: 1 }
+      end
+
+      it 'repopulates the pool periodically only up to min size' do
+        pool
+
+        sleep 2
+        expect(pool.size).to eq(1)
+        expect(pool.available_count).to eq(1)
+        first_connection = pool.check_out
+        pool.check_in(first_connection)
+
+        pool.clear
+
+        sleep 2
+        expect(pool.size).to eq(1)
+        expect(pool.available_count).to eq(1)
+        second_connection = pool.check_out
+        pool.check_in(second_connection)
+        expect(second_connection).to_not eq(first_connection)
+
+        # When populate is re-run, the pool size should not change
+        pool.populate
+        expect(pool.size).to eq(1)
+        expect(pool.available_count).to eq(1)
+        third_connection = pool.check_out
+        expect(third_connection).to eq(second_connection)
+      end
+    end
+  end
+
+  describe '#check_in' do
+    context 'when a min size is provided' do
+       let(:options) do
+        { min_pool_size: 1 }
+      end
+
+      it 'repopulates the pool after check_in of a closed connection' do
+        pool
+
+        sleep 2
+        expect(pool.size).to eq(1)
+        first_connection = pool.check_out
+        first_connection.disconnect!
+        expect(pool.size).to eq(1)
+
+        pool.check_in(first_connection)
+
+        sleep 2
+        expect(pool.size).to eq(1)
+        expect(pool.available_count).to eq(1)
+        second_connection = pool.check_out
+        expect(second_connection).to_not eq(first_connection)
+      end
+    end
+  end
+
+  describe '#check_out' do
+    context 'when min size and idle time are provided' do
+
+      let(:options) do
+        { max_pool_size: 2, min_pool_size: 2, max_idle_time: 0.5 }
+      end
+
+      it 'repopulates the pool after check_out empties idle connections' do
+        pool
+
+        first_connection = pool.check_out
+        second_connection = pool.check_out
+
+        first_connection.record_checkin!
+        second_connection.record_checkin!
+
+        pool.check_in(first_connection)
+        pool.check_in(second_connection)
+
+        expect(pool.size).to eq(2)
+
+        # let both connections become idle
+        sleep 0.5
+
+        # check_out should discard first two connections, trigger in-flow
+        # creation of a single connection, then wake up populate thread
+        third_connection = pool.check_out
+        expect(third_connection).to_not eq(first_connection)
+        expect(third_connection).to_not eq(second_connection)
+
+        # populate thread should create a new connection for the pool
+        sleep 2
+        expect(pool.size).to eq(2)
+        fourth_connection = pool.check_out
+        expect(fourth_connection).to_not eq(first_connection)
+        expect(fourth_connection).to_not eq(second_connection)
+        expect(fourth_connection).to_not eq(third_connection)
+      end
+    end
+  end
+
+  describe '#close' do
+    context 'when min size is provided' do
+
+      let(:options) do
+        { min_pool_size: 2, max_pool_size: 5 }
+      end
+
+      it 'terminates and does not repopulate the pool after pool is closed' do
+        pool
+
+        sleep 2
+        expect(pool.size).to eq(2)
+
+        connection = pool.check_out
+
+        expect(pool.size).to eq(2)
+        pool.close(force: true)
+
+        expect(pool.closed?).to be true
+        expect(pool.instance_variable_get('@available_connections').empty?).to be true
+        expect(pool.instance_variable_get('@checked_out_connections').empty?).to be true
+
+        # populate thread should terminate
+        sleep 2
+        expect(pool.instance_variable_get('@populator').running?).to be false
+        expect(pool.closed?).to be true
+      end
+    end
+  end
+
+  describe '#close_idle_sockets' do
+    context 'when min size and idle time are provided' do
+      let(:options) do
+        { min_pool_size: 1, max_idle_time: 0.5 }
+      end
+
+      it 'repopulates pool after sockets are closes' do
+        pool
+
+        sleep 2
+        expect(pool.size).to eq(1)
+
+        connection = pool.check_out
+        connection.record_checkin!
+        pool.check_in(connection)
+
+        # let the connection become idle
+        sleep 0.5
+
+        # close idle_sockets should trigger populate
+        pool.close_idle_sockets
+
+        sleep 2
+        expect(pool.size).to eq(1)
+        expect(pool.check_out).not_to eq(connection)
+      end
+    end
+  end
+
+  describe '#populate' do
+    let(:options) do
+      { min_pool_size: 1 }
+    end
+
+    context 'when populate encounters a network error twice' do
+      it 'retries once and does not stop the populator' do
+        expect_any_instance_of(Mongo::Server::ConnectionPool).to \
+          receive(:create_and_add_connection).twice.and_raise(Mongo::Error::SocketError)
+        pool
+        sleep 2
+        expect(pool.populator.running?).to be true
+      end
+    end
+
+    context 'when populate encounters a non-network error' do
+      it 'does not retry and does not stop the populator' do
+        expect_any_instance_of(Mongo::Server::ConnectionPool).to \
+          receive(:create_and_add_connection).and_raise(Mongo::Error)
+        pool
+        sleep 2
+        expect(pool.populator.running?).to be true
+      end
+    end
+  end
+
+  describe 'when forking is enabled' do
+    only_mri
+
+    context 'when min size is provided' do
+      min_server_version '2.8'
+
+      it 'populates the parent and child pools' do
+        client = ClientRegistry.instance.new_local_client([SpecConfig.instance.addresses.first],
+          server_options.merge(min_pool_size: 2, max_pool_size: 5))
+        # let pool populate
+        sleep 2
+        server = client.cluster.next_primary
+        pool = server.pool
+        expect(pool.size).to eq(2)
+
+        fork do
+          # follow forking guidance
+          client.close
+          client.reconnect
+          # let pool populate
+          sleep 2
+
+          server = client.cluster.next_primary
+          pool = server.pool
+          expect(pool.size).to eq(2)
+        end
+      end
+    end
+  end
+end