mongo 2.10.5 → 2.11.0.rc0

data/lib/mongo/srv/monitor.rb

@@ -0,0 +1,96 @@
+# 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.
+# 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
+  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.
+    #
+    # @api private
+    class Monitor
+      include Loggable
+
+      MIN_RESCAN_FREQUENCY = 60
+
+      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
+
+      def start_monitor!
+        @thread = Thread.new do
+          loop do
+            sleep(rescan_frequency)
+            scan!
+          end
+        end
+
+        ObjectSpace.define_finalizer(self, self.class.finalize(@thread))
+      end
+
+      def scan!
+        @old_hosts = @records.hosts
+
+        begin
+          @records = @resolver.get_records(@records.hostname)
+        rescue Resolv::ResolvTimeout => e
+          log_warn("Timed out trying to resolve hostname #{@records.hostname}")
+          return
+        rescue Resolv::ResolvError => e
+          log_warn("Unable to resolve hostname #{@records.hostname}")
+          return
+        end
+
+        if @records.empty?
+          @no_records_found = true
+          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
+      end
+
+      def self.finalize(thread)
+        Proc.new do
+          thread.kill
+        end
+      end
+
+      private
+
+      def rescan_frequency
+        if @no_records_found
+          Server:: Monitor::HEARTBEAT_FREQUENCY
+        elsif @records.min_ttl.nil?
+          MIN_RESCAN_FREQUENCY
+        else
+          [@records.min_ttl, MIN_RESCAN_FREQUENCY].max
+        end
+      end
+    end
+  end
+end

data/lib/mongo/srv/resolver.rb

@@ -0,0 +1,130 @@
+# Copyright (C) 2017-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
+  module Srv
+
+    # Encapsulates the necessary behavior for querying SRV records as
+    # required by the driver.
+    #
+    # @api private
+    class Resolver
+      include Loggable
+
+      # @return [ String ] RECORD_PREFIX The prefix prepended to each hostname
+      #   before querying SRV records.
+      RECORD_PREFIX = '_mongodb._tcp.'.freeze
+
+      # Creates a new Resolver.
+      #
+      # @param [ Hash ] options The options for the resolver.
+      #
+      # @option options [ Boolean ] :raise_on_invalid Whether or not to raise
+      #   an exception if either a record with a mismatched domain is found
+      #   or if no records are found. Defaults to true.
+      # @option options [ Hash ] :resolv_options For internal driver use only.
+      #   Options to pass through to Resolv::DNS constructor for SRV lookups.
+      def initialize(options = nil)
+        @options = if options
+          options.dup
+        else
+          {}
+        end.freeze
+        @resolver = Resolv::DNS.new(@options[:resolv_options])
+      end
+
+      # Obtains all of the SRV records for a given hostname.
+      #
+      # In the event that a record with a mismatched domain is found or no
+      # records are found, if the :raise_on_invalid option is true,
+      # an exception will be raised, otherwise a warning will be logged.
+      #
+      # @param [ String ] hostname The hostname whose records should be obtained.
+      #
+      # @raise [ Mongo::Error::MismatchedDomain ] If the :raise_in_invalid
+      #   Resolver option is true and a record with a domain name that does
+      #   not match the hostname's is found.
+      # @raise [ Mongo::Error::NoSRVRecords ] If the :raise_in_invalid Resolver
+      #   option is true and no records are found.
+      #
+      # @return [ Mongo::Srv::Result ] SRV lookup result.
+      def get_records(hostname)
+        query_name = RECORD_PREFIX + hostname
+        resources = @resolver.getresources(query_name, Resolv::DNS::Resource::IN::SRV)
+
+        # Collect all of the records into a Result object, raising an error
+        # or logging a warning if a record with a mismatched domain is found.
+        # Note that in the case a warning is raised, the record is _not_
+        # 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
+        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
+        end
+
+        result
+      end
+
+      # Obtains the TXT records of a host.
+      #
+      # @param [ String ] hostname The host whose TXT records should be obtained.
+      #
+      # @return [ nil | String ] URI options string from TXT record
+      #   associated with the hostname, or nil if there is no such record.
+      #
+      # @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
+
+        if records.length > 1
+          msg = "Only one TXT record is allowed: querying hostname #{hostname} returned #{records.length} records"
+
+          raise Error::InvalidTXTRecord, msg
+        end
+
+        records[0].strings.join
+      end
+
+      private
+
+      # Checks whether an error should be raised due to either a record with
+      # a mismatched domain being found or no records being found.
+      #
+      # @return [ Boolean ] Whether an error should be raised.
+      def raise_on_invalid?
+        @raise_on_invalid ||= @options[:raise_on_invalid] || true
+      end
+    end
+  end
+end

data/lib/mongo/srv/result.rb

@@ -0,0 +1,126 @@
+# Copyright (C) 2017-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
+
+  module Srv
+
+    # SRV record lookup result.
+    #
+    # Contains server addresses that the query resolved to, and minimum TTL
+    # of the DNS records.
+    #
+    # @api private
+    class Result
+      include Address::Validator
+
+      # @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
+
+      # @return [ String ] query_hostname The hostname pointing to the DNS records.
+      attr_reader :query_hostname
+
+      # @return [ Array<String> ] address_strs The host strings of the SRV records
+      #   for the query hostname.
+      attr_reader :address_strs
+
+      # @return [ Integer | nil ] min_ttl The smallest TTL found among the
+      #   records (or nil if no records have been added).
+      attr_accessor :min_ttl
+
+      # Create a new object to keep track of the SRV records of the hostname.
+      #
+      # @param [ String ] hostname The hostname pointing to the DNS records.
+      def initialize(hostname)
+        @query_hostname = hostname
+        @address_strs = []
+        @min_ttl = nil
+      end
+
+      # Checks whether there are any records.
+      #
+      # @return [ Boolean ] Whether or not there are any records.
+      def empty?
+        @address_strs.empty?
+      end
+
+      # Adds a new record.
+      #
+      # @param [ Resolv::DNS::Resource ] record An SRV record found for the hostname.
+      def add_record(record)
+        record_host = normalize_hostname(record.target.to_s)
+        port = record.port
+        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
+        @address_strs << address_str
+
+        if @min_ttl.nil?
+          @min_ttl = record.ttl
+        else
+          @min_ttl = [@min_ttl, record.ttl].min
+        end
+
+        nil
+      end
+
+      private
+
+      # Transforms the provided hostname to simplify its validation later on.
+      #
+      # This method is safe to call during both initial DNS seed list discovery
+      # and during SRV monitoring, in that it does not convert invalid hostnames
+      # into valid ones.
+      #
+      # - Converts the hostname to lower case.
+      # - Removes one trailing dot, if there is exactly one. If the hostname
+      #   has multiple trailing dots, it is unchanged.
+      #
+      # @param [ String ] host Hostname to transform.
+      def normalize_hostname(host)
+        host = host.downcase
+        unless host.end_with?('..')
+          host = host.sub(/\.\z/, '')
+        end
+        host
+      end
+
+      # Ensures that a record's domain name matches that of the hostname.
+      #
+      # A hostname's domain name consists of each of the '.' delineated
+      # parts after the first. For example, the hostname 'foo.bar.baz'
+      # has the domain name 'bar.baz'.
+      #
+      # @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('.')
+
+        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])
+        end
+      end
+    end
+  end
+end

data/lib/mongo/srv/warning_result.rb

@@ -0,0 +1,35 @@
+# 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
+
+  module Srv
+
+    # SRV record lookup result which warns on errors rather than raising
+    # exceptions.
+    #
+    # @api private
+    class WarningResult < Result
+
+      # Adds a new record.
+      #
+      # @param [ Resolv::DNS::Resource ] record An SRV record found for the hostname.
+      def add_record(record)
+        super
+      rescue Error::InvalidAddress, Error::MismatchedDomain => e
+        log_warn(e.message)
+      end
+    end
+  end
+end

data/lib/mongo/uri.rb

@@ -28,13 +28,14 @@ module Mongo
   # @since 2.0.0
   class URI
     include Loggable
+    include Address::Validator
 
     # The uri parser object options.
     #
     # @since 2.0.0
     attr_reader :options
 
-    # The options specified in the uri.
+    # Mongo::Options::Redacted of the options specified in the uri.
     #
     # @since 2.1.0
     attr_reader :uri_options
@@ -64,6 +65,7 @@ module Mongo
     # Error details for an invalid scheme.
     #
     # @since 2.1.0
+    # @deprecated
     INVALID_SCHEME = "Invalid scheme. Scheme must be '#{MONGODB_SCHEME}' or '#{MONGODB_SRV_SCHEME}'".freeze
 
     # MongoDB URI format specification.
@@ -80,7 +82,7 @@ module Mongo
     # Unsafe characters that must be urlencoded.
     #
     # @since 2.1.0
-    UNSAFE = /[\:\/\+\@]/
+    UNSAFE = /[\:\/\@]/
 
     # Percent sign that must be encoded in user creds.
     #
@@ -224,7 +226,7 @@ module Mongo
         when MONGODB_SRV_SCHEME
           SRVProtocol.new(string, opts)
         else
-          raise Error::InvalidURI.new(string, INVALID_SCHEME)
+          raise Error::InvalidURI.new(string, "Invalid scheme '#{scheme}'. Scheme must be '#{MONGODB_SCHEME}' or '#{MONGODB_SRV_SCHEME}'")
       end
     end
 
@@ -235,14 +237,18 @@ module Mongo
     # @example Get the client options.
     #   uri.client_options
     #
-    # @return [ Hash ] The options passed to the Mongo::Client
+    # @return [ Mongo::Options::Redacted ] The options passed to the Mongo::Client
     #
     # @since 2.0.0
     def client_options
-      opts = uri_options.merge(:database => database)
+      opts = default_client_options.merge(uri_options)
       @user ? opts.merge(credentials) : opts
     end
 
+    def srv_records
+      nil
+    end
+
     # Create the new uri from the provided string.
     #
     # @example Create the new URI.
@@ -258,7 +264,9 @@ module Mongo
       @string = string
       @options = options
       parsed_scheme, _, remaining = string.partition(SCHEME_DELIM)
-      raise_invalid_error!(INVALID_SCHEME) unless parsed_scheme == scheme
+      unless parsed_scheme == scheme
+        raise_invalid_error!("Invalid scheme '#{parsed_scheme}'. Scheme must be '#{MONGODB_SCHEME}'. Use URI#get to parse SRV URIs.")
+      end
       if remaining.empty?
         raise_invalid_error!('No hosts in the URI')
       end
@@ -359,7 +367,7 @@ module Mongo
           raise_invalid_error!('Empty host given in the host list')
         end
         decode(host).tap do |host|
-          validate_host!(host)
+          validate_address_str!(host)
         end
       end
 
@@ -369,6 +377,8 @@ module Mongo
       if db
         @database = parse_database!(db)
       end
+    rescue Error::InvalidAddress => e
+      raise_invalid_error!(e.message)
     end
 
     def extract_db_opts!(string)
@@ -405,14 +415,12 @@ module Mongo
 
     def parse_user!(string)
       if (string && user = string.partition(AUTH_USER_PWD_DELIM)[0])
-        if user.length > 0
-          raise_invalid_error!(UNESCAPED_USER_PWD) if user =~ UNSAFE
-          user_decoded = decode(user)
-          if user_decoded =~ PERCENT_CHAR && encode(user_decoded) != user
-            raise_invalid_error!(UNESCAPED_USER_PWD)
-          end
-          user_decoded
+        raise_invalid_error!(UNESCAPED_USER_PWD) if user =~ UNSAFE
+        user_decoded = decode(user)
+        if user_decoded =~ PERCENT_CHAR && encode(user_decoded) != user
+          raise_invalid_error!(UNESCAPED_USER_PWD)
         end
+        user_decoded
       end
     end
 
@@ -434,50 +442,32 @@ module Mongo
       decode(string) if string.length > 0
     end
 
-    def validate_port_string!(port)
-      unless port.nil? || (port.length > 0 && port.to_i > 0 && port.to_i <= 65535)
-        raise_invalid_error!(INVALID_PORT)
+    def default_client_options
+      opts = Options::Redacted.new(database: database)
+
+      if @uri_options[:auth_mech] || @user
+        opts[:auth_source] = default_auth_source
       end
-    end
 
-    # Takes a host in ipv4/ipv6/hostname/socket path format and validates
-    # its format.
-    def validate_host!(host)
-      case host
-      when /\A\[[\d:]+\](?::(\d+))?\z/
-        # ipv6 with optional port
-        if port_str = $1
-          validate_port_string!(port_str)
-        end
-      when /\A\//, /\.sock\z/
-        # Unix socket path.
-        # Spec requires us to validate that the path has no unescaped
-        # slashes, but if this were to be the case, parsing would have
-        # already failed elsewhere because the URI would've been split in
-        # a weird place.
-        # The spec also allows relative socket paths and requires that
-        # socket paths end in ".sock". We accept all paths but special case
-        # the .sock extension to avoid relative paths falling into the
-        # host:port case below.
-      when /[\/\[\]]/
-        # Not a host:port nor an ipv4 address with optional port.
-        # Possibly botched ipv6 address with e.g. port delimiter present and
-        # port missing, or extra junk before or after.
-        raise_invalid_error!("Invalid hostname: #{host}")
-      when /:.*:/m
-        raise_invalid_error!("Multiple port delimiters are not allowed: #{host}")
-      else
-        # host:port or ipv4 address with optional port number
-        host, port = host.split(':')
-        if host.empty?
-          raise_invalid_error!("Host is empty: #{host}")
-        end
+      if @uri_options[:auth_mech] == :gssapi
+        opts[:auth_mech_properties] = default_auth_mech_properties
+      end
 
-        if port && port.empty?
-          raise_invalid_error!("Port is empty: #{port}")
-        end
+      opts
+    end
+
+    def default_auth_mech_properties
+      { service_name: 'mongodb' }
+    end
 
-        validate_port_string!(port)
+    def default_auth_source
+      case @uri_options[:auth_mech]
+      when :gssapi, :mongodb_x509
+        :external
+      when :plain
+        @database || :external
+      else 
+        @database || Database::ADMIN
       end
     end
 
@@ -490,7 +480,7 @@ module Mongo
     end
 
     def decode(value)
-      ::URI::DEFAULT_PARSER.unescape(value)
+      ::URI.decode(value)
     end
 
     def encode(value)