mongo 2.12.0.rc0 → 2.12.1

data/lib/mongo/cluster/srv_monitor.rb

@@ -1,127 +0,0 @@
-# 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
-  class Cluster
-
-    # 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 SrvMonitor
-      include Loggable
-      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
-
-      attr_reader :cluster
-
-      # @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 = last_result.address_strs
-
-        begin
-          last_result = Timeout.timeout(timeout) do
-            @resolver.get_records(@srv_uri.query_hostname)
-          end
-        rescue Resolv::ResolvTimeout => e
-          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("SRV monitor: unable to resolve hostname #{@srv_uri.query_hostname}: #{e.class}: #{e}")
-          return
-        end
-
-        if last_result.empty?
-          log_warn("SRV monitor: hostname #{@srv_uri.query_hostname} resolved to zero records")
-          return
-        end
-
-        @cluster.set_server_list(last_result.address_strs)
-      end
-
-      def self.finalize(thread)
-        Proc.new do
-          thread.kill
-        end
-      end
-
-      def scan_interval
-        if last_result.empty?
-          [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
-        end
-      end
-
-      def timeout
-        options[:timeout] || DEFAULT_TIMEOUT
-      end
-    end
-  end
-end

data/lib/mongo/srv/warning_result.rb

@@ -1,35 +0,0 @@
-# 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/spec/enterprise_auth/kerberos_spec.rb

@@ -1,58 +0,0 @@
-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
-
-  let(:host) do
-    "#{ENV['SASL_HOST']}"
-  end
-
-  let(:kerberos_db) do
-    "#{ENV['KERBEROS_DB']}"
-  end
-
-  let(:auth_source) do
-    "#{ENV['SASL_DB']}"
-  end
-
-  let(:uri) do
-    uri = "mongodb://#{user}@#{host}/#{kerberos_db}?authMechanism=GSSAPI&authSource=#{auth_source}"
-  end
-
-  let(:client) do
-    Mongo::Client.new(uri)
-  end
-
-  let(:doc) do
-    client.database[:test].find.first
-  end
-
-  it 'correctly authenticates' do
-    expect(doc['kerberos']).to eq(true)
-    expect(doc['authenticated']).to eq('yeah')
-  end
-
-  context 'when canonicalize_host_name is true' do
-    let(:host) do
-      "#{ENV['IP_ADDR']}"
-    end
-
-    let(:uri) do
-      uri = "mongodb://#{user}@#{host}/#{kerberos_db}?authMechanism=GSSAPI&authSource=#{auth_source}&authMechanismProperties=CANONICALIZE_HOST_NAME:true"
-    end
-
-    it 'correctly authenticates when using the IP' do
-      expect(doc['kerberos']).to eq(true)
-      expect(doc['authenticated']).to eq('yeah')
-    end
-  end
-end

data/spec/mongo/cluster/srv_monitor_spec.rb

@@ -1,214 +0,0 @@
-require 'lite_spec_helper'
-
-xdescribe Mongo::Cluster::SrvMonitor do
-  describe '#scan!' do
-    let(:hostname) do
-      'test1.test.build.10gen.cc.'
-    end
-
-    let(:hosts) do
-      [
-        'localhost.test.build.10gen.cc.:27017',
-        'localhost.test.build.10gen.cc.:27018',
-      ]
-    end
-
-    let(:records) do
-      double('records').tap do |records|
-        allow(records).to receive(:hostname).and_return(hostname)
-        allow(records).to receive(:hosts).and_return(hosts)
-        allow(records).to receive(:empty?).and_return(false)
-        allow(records).to receive(:min_ttl).and_return(nil)
-      end
-    end
-
-    let(:srv_uri) do
-      Mongo::URI.get("mongodb+srv://localhost.a.b")
-    end
-
-    let(:cluster) do
-      Mongo::Cluster.new(records.hosts, Mongo::Monitoring.new, { monitoring_io: false })
-    end
-
-    let(:monitoring) do
-      described_class.new(cluster, srv_uri: srv_uri)
-    end
-
-    before do
-      monitoring.scan!
-    end
-
-    context 'when a new DNS record is added' do
-      let(:new_hosts) do
-        hosts + ['test1.test.build.10gen.cc.:27019']
-      end
-
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
-        end
-      end
-
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_return(new_records)
-        end
-      end
-
-      it 'adds the new host to the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
-      end
-    end
-
-    context 'when a DNS record is removed' do
-      let(:new_hosts) do
-        hosts - ['test1.test.build.10gen.cc.:27018']
-      end
-
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
-        end
-      end
-
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_return(new_records)
-        end
-      end
-
-      it 'adds the new host to the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
-      end
-    end
-
-    context 'when a single DNS record is replaced' do
-      let(:new_hosts) do
-        hosts - ['test1.test.build.10gen.cc.:27018'] +  ['test1.test.build.10gen.cc.:27019']
-      end
-
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
-        end
-      end
-
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_return(new_records)
-        end
-      end
-
-      it 'adds the new host to the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
-      end
-    end
-
-    context 'when all DNS records are replaced with a single record' do
-      let(:new_hosts) do
-        ['test1.test.build.10gen.cc.:27019']
-      end
-
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
-        end
-      end
-
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_return(new_records)
-        end
-      end
-
-      it 'adds the new host to the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
-      end
-    end
-
-    context 'when all DNS records are replaced with multiple records' do
-      let(:new_hosts) do
-        [
-          'test1.test.build.10gen.cc.:27019',
-          'test1.test.build.10gen.cc.:27020',
-        ]
-      end
-
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
-        end
-      end
-
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_return(new_records)
-        end
-      end
-
-      it 'adds the new host to the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
-      end
-    end
-
-    context 'when the DNS lookup times out' do
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_raise(Resolv::ResolvTimeout)
-        end
-      end
-
-      it 'does not add or remove any hosts from the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(hosts.sort)
-      end
-    end
-
-    context 'when the DNS lookup is unable to resolve the hostname' do
-     let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_raise(Resolv::ResolvError)
-        end
-      end
-
-      it 'does not add or remove any hosts from the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(hosts.sort)
-      end
-    end
-
-    context 'when no DNS records are returned' do
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return([])
-          allow(records).to receive(:empty?).and_return(true)
-          allow(records).to receive(:min_ttl).and_return(nil)
-        end
-      end
-
-      let(:resolver) do
-        double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_return(new_records)
-        end
-      end
-
-      it 'does not add or remove any hosts from the cluster' do
-        expect(cluster.addresses.map(&:to_s).sort).to eq(hosts.sort)
-      end
-    end
-  end
-end

data/spec/mongo/operation/read_preference_spec.rb

@@ -1,245 +0,0 @@
-require 'spec_helper'
-
-describe Mongo::Operation::ReadPreferenceSupported do
-
-  let(:selector) do
-    { name: 'test' }
-  end
-
-  let(:options) do
-    {}
-  end
-
-  let(:cluster_double) do
-    double('cluster')
-  end
-
-  let(:single?) do
-    true
-  end
-
-  let(:mongos?) do
-    false
-  end
-
-  let(:read_pref) do
-    Mongo::ServerSelector.get
-  end
-
-  let(:operation) do
-    Class.new do
-      include Mongo::Operation::ReadPreferenceSupported
-    end.new.tap do |rp|
-      allow(rp).to receive(:read).and_return(read_pref)
-      allow(rp).to receive(:selector).and_return(selector)
-      allow(rp).to receive(:options).and_return(options)
-    end
-  end
-
-  let(:server) do
-    double('server').tap do |c|
-      allow(c).to receive(:cluster).and_return(cluster_double)
-      allow(cluster_double).to receive(:single?).and_return(single?)
-      allow(c).to receive(:mongos?).and_return(mongos?)
-    end
-  end
-
-  shared_context 'a selector updater' do
-
-    let(:read_pref) do
-      Mongo::ServerSelector.get(:mode => mode)
-    end
-
-    let(:expected) do
-      { :$query => selector, :$readPreference => read_pref.to_mongos }
-    end
-
-    it 'returns a special selector' do
-      expect(operation.send(:update_selector_for_read_pref, operation.send(:selector), server)).to eq(expected)
-    end
-
-    context 'when the selector already has $query in it' do
-
-      let(:selector) do
-        { :$query => { :name => 'test' },
-          :$orderby => { :name => -1 } }
-      end
-
-      let(:expected) do
-        selector.merge(:$readPreference => read_pref.to_mongos)
-      end
-
-      it 'returns an unaltered special selector' do
-        expect(operation.send(:update_selector_for_read_pref, operation.send(:selector), server)).to eq(expected)
-      end
-    end
-  end
-
-  shared_context 'not a selector updater' do
-
-    let(:read_pref) do
-      Mongo::ServerSelector.get(:mode => mode)
-    end
-
-    it 'returns a selector' do
-      expect(operation.send(:update_selector_for_read_pref, operation.send(:selector), server)).to eq(selector)
-    end
-  end
-
-  context 'when the server is a mongos' do
-
-    let(:mongos?) do
-      true
-    end
-
-    context 'when the read preference mode is primary' do
-
-      let(:mode) do
-        :primary
-      end
-
-      it_behaves_like 'not a selector updater'
-    end
-
-    context 'when the read preference mode is primary_preferred' do
-
-      let(:mode) do
-        :primary_preferred
-      end
-
-      it_behaves_like 'a selector updater'
-    end
-
-    context 'when the read preference mode is secondary' do
-
-      let(:mode) do
-        :secondary
-      end
-
-      it_behaves_like 'a selector updater'
-    end
-
-    context 'when the read preference mode is secondary_preferred' do
-
-      let(:mode) do
-        :secondary_preferred
-      end
-
-      it_behaves_like 'not a selector updater'
-    end
-
-    context 'when the read preference mode is nearest' do
-
-      let(:mode) do
-        :nearest
-      end
-
-      it_behaves_like 'a selector updater'
-    end
-  end
-
-  context 'when the server is not a mongos' do
-
-    let(:mongos?) do
-      false
-    end
-
-    let(:mode) do
-      :secondary_preferred
-    end
-
-    it_behaves_like 'not a selector updater'
-  end
-
-  context 'when the topology is Single' do
-
-    let(:single?) do
-      true
-    end
-
-    context 'when the server is a mongos' do
-
-      let(:mongos?) do
-        true
-      end
-
-      let(:expected) do
-        { }
-      end
-
-      it 'does not set the slave_ok flag' do
-        expect(operation.send(:update_options_for_slave_ok, operation.send(:options), server)).to eq(expected)
-      end
-    end
-
-    context 'when the server is not a mongos' do
-
-      let(:mongos?) do
-        false
-      end
-
-      let(:expected) do
-        { :flags => [ :slave_ok ] }
-      end
-
-      it 'sets the slave_ok flag' do
-        expect(operation.send(:update_options_for_slave_ok, operation.send(:options), server)).to eq(expected)
-      end
-    end
-  end
-
-  context 'when the topology is not Single' do
-
-    let(:single?) do
-      false
-    end
-
-    context 'when there is no read preference set' do
-
-      let(:read_pref) do
-        Mongo::ServerSelector.get
-      end
-
-      let(:expected) do
-        { }
-      end
-
-      it 'does not set the slave_ok flag' do
-        expect(operation.send(:update_options_for_slave_ok, operation.send(:options), server)).to eq(expected)
-      end
-    end
-
-    context 'when there is a read preference' do
-
-      context 'when the read preference requires the slave_ok flag' do
-
-        let(:read_pref) do
-          Mongo::ServerSelector.get(:mode => :secondary)
-        end
-
-        let(:expected) do
-          { :flags => [ :slave_ok ] }
-        end
-
-        it 'sets the slave_ok flag' do
-          expect(operation.send(:update_options_for_slave_ok, operation.send(:options), server)).to eq(expected)
-        end
-      end
-
-      context 'when the read preference does not require the slave_ok flag' do
-
-        let(:read_pref) do
-          Mongo::ServerSelector.get(:mode => :primary)
-        end
-
-        let(:expected) do
-          { }
-        end
-
-        it 'does not set the slave_ok flag' do
-          expect(operation.send(:update_options_for_slave_ok, operation.send(:options), server)).to eq(expected)
-        end
-      end
-    end
-  end
-end