mongo 2.11.2 → 2.13.0.beta1

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/server/connectable.rb

@@ -1,107 +0,0 @@
-# Copyright (C) 2015-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 Server
-
-    # This provides common behavior for connection objects.
-    #
-    # @since 2.0.0
-    module Connectable
-
-      # The ssl option prefix.
-      #
-      # @since 2.1.0
-      # @deprecated
-      SSL = 'ssl'.freeze
-
-      # The default time in seconds to timeout an operation executed on a socket.
-      #
-      # @since 2.0.0
-      #
-      # @deprecated Timeouts on Ruby sockets aren't effective so this default
-      #   option is no longer used. Will be removed in driver version 3.0.
-      TIMEOUT = 5.freeze
-
-      # @return [ Integer ] pid The process id when the connection was created.
-      attr_reader :pid
-
-      # Determine if the server is connectable. This will check not only if the
-      # connection exists, but if messages can send to it successfully.
-      #
-      # @example Is the server connectable?
-      #   connection.connectable?
-      #
-      # @return [ true, false ] If the connection is connectable.
-      #
-      # @since 2.1.0
-      #
-      # @deprecated No longer necessary with Server Selection specification.
-      def connectable?; end
-
-      # Determine if the connection is currently connected.
-      #
-      # @example Is the connection connected?
-      #   connection.connected?
-      #
-      # @return [ true, false ] If connected.
-      #
-      # @deprecated Use #connectable? instead
-      def connected?
-        !!@socket && @socket.alive?
-      end
-
-      protected
-
-      attr_reader :socket
-
-      private
-
-      def ssl_options
-        @ssl_options ||= if options[:ssl]
-          options.select { |k, v| k.to_s.start_with?('ssl') }
-        else
-          {}
-        end.freeze
-      end
-
-      def ensure_connected
-        ensure_same_process!
-        begin
-          connect!
-          result = yield socket
-          success = true
-          result
-        ensure
-          unless success
-            disconnect!(reason: :error)
-          end
-        end
-      end
-
-      def ensure_same_process!
-        if pid != Process.pid
-          # When we reconnect here, CMAP events won't be correctly sent
-          # since the CMAP spec does not permit a connection to be disconnected
-          # and then reconnected
-          log_warn("Detected PID change - Mongo client should have been reconnected (old pid #{pid}, new pid #{Process.pid}")
-          disconnect!(reason: :stale)
-          @closed = false
-          @pid = Process.pid
-          connect!
-        end
-      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