mongo 2.8.0 → 2.9.0.rc0

data/spec/support/cmap.rb

@@ -0,0 +1,367 @@
+require 'support/cmap/verifier'
+
+module Mongo
+  module Cmap
+
+    # Represents a specification.
+    class Spec
+
+      # @return [ String ] description The spec description.
+      attr_reader :description
+
+      # @return [ Hash ] pool_options The options for the created pools.
+      attr_reader :pool_options
+
+      # @return [ Array<Operation> ] spec_ops The spec operations.
+      attr_reader :spec_ops
+
+      # @return [ Array<Operation> ] processed_ops The processed operations.
+      attr_reader :processed_ops
+
+      # @return [ Error | nil ] error The expected error.
+      attr_reader :expected_error
+
+      # @return [ Array<Event::Base> ] events The events expected to occur.
+      attr_reader :expected_events
+
+      # @return [ Array<String> ] events The names of events to ignore.
+      attr_reader :ignore_events
+
+      # @return [ Mongo::ConnectionPool ] pool The connection pool to use for operations.
+      attr_reader :pool
+
+      # @return [ EventSubscriber ] subscriber The subscriber receiving the CMAP events.
+      attr_reader :subscriber
+
+      # Instantiate the new spec.
+      #
+      # @example Create the spec.
+      #   Spec.new(file)
+      #
+      # @param [ String ] file The name of the file.
+      def initialize(file)
+        @test = YAML.load(ERB.new(File::read(file)).result)
+
+        @description = @test['description']
+        @pool_options = Utils.snakeize_hash(process_options(@test['poolOptions']))
+        @spec_ops = @test['operations'].map { |o| Operation.new(self, o) }
+        @processed_ops = []
+        @expected_error = @test['error']
+        @expected_events = @test['events']
+        @ignore_events = @test['ignore'] || []
+
+        preprocess
+      end
+
+      def setup(cluster)
+        @subscriber = EventSubscriber.new
+
+        monitoring = Mongo::Monitoring.new(monitoring: false)
+        monitoring.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
+
+        server = Mongo::Server.new(
+            Address.new(SpecConfig.instance.addresses.first),
+            cluster,
+            monitoring,
+            Mongo::Event::Listeners.new,
+            pool_options.merge(monitoring_io: false))
+
+        @pool = server.pool
+        @pool.populate
+      end
+
+      def run
+        state = {}
+
+        {}.tap do |result|
+          processed_ops.each do |op|
+            err = op.run(pool, state)
+
+            if err
+              result['error'] = err
+              break
+            end
+          end
+
+          result['error'] ||= nil
+          result['events'] = subscriber.published_events.reduce([]) do |events, event|
+            next events unless event.is_a?(Mongo::Monitoring::Event::Cmap::Base)
+
+            event = case event
+                    when Mongo::Monitoring::Event::Cmap::PoolCreated
+                      {
+                        'type' => 'ConnectionPoolCreated',
+                        'address' => event.address,
+                        'options' => normalize_options(event.options),
+                      }
+                    when Mongo::Monitoring::Event::Cmap::PoolClosed
+                      {
+                        'type' => 'ConnectionPoolClosed',
+                        'address' => event.address,
+                      }
+                    when Mongo::Monitoring::Event::Cmap::ConnectionCreated
+                      {
+                        'type' => 'ConnectionCreated',
+                        'connectionId' => event.connection_id,
+                      }
+                    when Mongo::Monitoring::Event::Cmap::ConnectionReady
+                      {
+                        'type' => 'ConnectionReady',
+                        'connectionId' => event.connection_id,
+                      }
+                    when Mongo::Monitoring::Event::Cmap::ConnectionClosed
+                      {
+                        'type' => 'ConnectionClosed',
+                        'connectionId' => event.connection_id,
+                        'reason' => event.reason,
+                      }
+                    when Mongo::Monitoring::Event::Cmap::ConnectionCheckOutStarted
+                      {
+                        'type' => 'ConnectionCheckOutStarted',
+                    }
+                    when Mongo::Monitoring::Event::Cmap::ConnectionCheckOutFailed
+                      {
+                        'type' => 'ConnectionCheckOutFailed',
+                        'reason' => event.reason,
+                      }
+                   when Mongo::Monitoring::Event::Cmap::ConnectionCheckedOut
+                      {
+                        'type' => 'ConnectionCheckedOut',
+                        'connectionId' => event.connection_id,
+                      }
+                    when Mongo::Monitoring::Event::Cmap::ConnectionCheckedIn
+                      {
+                        'type' => 'ConnectionCheckedIn',
+                        'connectionId' => event.connection_id,
+                      }
+                    when Mongo::Monitoring::Event::Cmap::PoolCleared
+                      {
+                        'type' => 'ConnectionPoolCleared',
+                        'address' => event.address,
+                      }
+                    end
+
+            events << event unless @ignore_events.include?(event['type'])
+            events
+          end
+        end
+      end
+
+      private
+
+      # Converts the options used by the Ruby driver to the spec test format.
+      def normalize_options(options)
+        (options || {}).reduce({}) do |opts, kv|
+         case kv.first
+          when :max_idle_time
+            opts['maxIdleTimeMS'] = (kv.last * 1000.0).to_i
+          when :max_size
+            opts['maxPoolSize'] = kv.last
+          when :min_size
+            opts['minPoolSize'] = kv.last
+          when :wait_queue_size
+            opts['waitQueueSize'] = kv.last
+          when :wait_timeout
+            opts['waitQueueTimeoutMS'] = (kv.last * 1000.0).to_i
+          end
+
+          opts
+        end
+      end
+
+      # Converts the options given by the spec to the Ruby driver format.
+      def process_options(options)
+        (options || {}).reduce({}) do |opts, kv|
+          case kv.first
+          when 'maxIdleTimeMS'
+            opts[:max_idle_time] = kv.last / 1000.0
+          when 'maxPoolSize'
+            opts[:max_pool_size] = kv.last
+          when 'minPoolSize'
+            opts[:min_pool_size] = kv.last
+          when 'waitQueueSize'
+            opts[:wait_queue_size] = kv.last
+          when 'waitQueueTimeoutMS'
+            opts[:wait_queue_timeout] = kv.last / 1000.0
+          else
+            raise "Unknown option #{kv.first}"
+          end
+
+          opts
+        end
+      end
+
+      # Places operations run by the non-main thread in the `thread_ops` field of the corresponding
+      # `start` operation.
+      def preprocess
+        until spec_ops.empty?
+          processed_ops << spec_ops.shift
+
+          if processed_ops.last.name == "start"
+            spec_ops.delete_if do |op|
+              if op.thread == processed_ops.last.target
+                processed_ops.last.thread_ops << op
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Represents an operation in the spec. Operations are sequential.
+    class Operation
+
+      # @return [ String ] command The name of the operation to run.
+      attr_reader :name
+
+      # @return [ String | nil ] thread The identifier of the thread to run the operation on (`nil`
+      #   signifying the default thread.)
+      attr_reader :thread
+
+      # @return [ String | nil ] target The name of the started thread.
+      attr_reader :target
+
+      # @return [ Array<Operation> ] thread_ops The operations to run on the thread.
+      attr_reader :thread_ops
+
+      # @return [ Integer | nil ] ms The number of milliseconds to sleep.
+      attr_reader :ms
+
+      # @return [ String | nil ] label The label for the returned connection.
+      attr_reader :label
+
+      # @return [ String | nil ] The binding for the connection which should run the operation.
+      attr_reader :connection
+
+      # @return [ Mongo::ConnectionPool ] pool The connection pool to use for the operation.
+      attr_reader :pool
+
+      # Create the new Operation.
+      #
+      # @param [ Spec ] spec The Spec object.
+      # @param [ Hash ] operation The operation hash.
+      def initialize(spec, operation)
+        @spec = spec
+        @name = operation['name']
+        @thread = operation['thread']
+        @thread_ops = []
+        @target = operation['target']
+        @ms = operation['ms']
+        @label = operation['label']
+        @connection = operation['connection']
+        @event = operation['event']
+        @count = operation['count']
+      end
+
+      def run(pool, state, main_thread = true)
+        @pool = pool
+
+        case name
+        when 'start'
+          run_start_op(state)
+        when 'wait'
+          run_wait_op(state)
+        when 'waitForThread'
+          run_wait_for_thread_op(state)
+        when 'waitForEvent'
+          run_wait_for_event_op(state)
+        when 'checkOut'
+          run_checkout_op(state)
+        when 'checkIn'
+          run_checkin_op(state)
+        when 'clear'
+          run_clear_op(state)
+        when 'close'
+          run_close_op(state)
+        else
+          raise "invalid operation: #{name}"
+        end
+
+        nil
+
+      # We hard-code the error messages because ours contain information like the address and the
+      # connection ID.
+      rescue Error::PoolClosedError
+        raise unless main_thread
+
+        {
+          'type' => 'PoolClosedError',
+          'message' => 'Attempted to check out a connection from closed connection pool',
+        }
+      rescue Error::ConnectionCheckOutTimeout
+        raise unless main_thread
+
+        {
+          'type' => 'WaitQueueTimeoutError',
+          'message' => 'Timed out while checking out a connection from connection pool',
+        }
+      end
+
+      private
+
+      def run_start_op(state)
+        state[target] = Thread.start do
+          Thread.current[:name] = @target
+          thread_ops.each { |op| op.run(pool, state, false) }
+        end
+
+        # Since we expect exceptions to occur in some cases, we disable the printing of error
+        # messages from the thread if the Ruby version supports it.
+        if state[target].respond_to?(:report_on_exception)
+          state[target].report_on_exception = false
+        end
+      end
+
+      def run_wait_op(_state)
+        sleep(ms / 1000.0)
+      end
+
+      def run_wait_for_thread_op(state)
+        state[target].join
+      end
+
+      def run_wait_for_event_op(state)
+        subscriber = @spec.subscriber
+        looped = 0
+        deadline = Time.now + 3
+        loop do
+          actual_events = @spec.subscriber.published_events.select do |e|
+            e.class.name.sub(/.*::/, '').sub(/^ConnectionPool/, 'Pool') == @event.sub(/^ConnectionPool/, 'Pool')
+          end
+          if actual_events.length >= @count
+            break
+          end
+          if looped == 1
+            puts("Waiting for #{@count} #{@event} events (have #{actual_events.length}): #{@spec.description}")
+          end
+          if Time.now > deadline
+            raise "Did not receive #{@count} #{@event} events in time (have #{actual_events.length}): #{@spec.description}"
+          end
+          looped += 1
+          sleep 0.1
+        end
+      end
+
+      def run_checkout_op(state)
+        conn = pool.check_out
+        state[label] = conn if label
+      end
+
+      def run_checkin_op(state)
+        until state[connection]
+          sleep(0.2)
+        end
+
+        pool.check_in(state[connection])
+      end
+
+      def run_clear_op(state)
+        pool.clear(lazy: true)
+      end
+
+      def run_close_op(state)
+        pool.close
+      end
+    end
+  end
+end

data/spec/support/cmap/verifier.rb

@@ -0,0 +1,46 @@
+# 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 Cmap
+    class Verifier
+      include RSpec::Matchers
+
+      def initialize(test_instance)
+        @test_instance = test_instance
+      end
+
+      attr_reader :test_instance
+
+      def verify_hashes(actual, expected)
+        expect(expected).to be_a(Hash)
+        expect(actual).to be_a(Hash)
+
+        actual = actual.dup
+        if actual['reason']
+          actual['reason'] = actual['reason'].to_s.gsub(/_[a-z]/) { |m| m[1].upcase }
+        end
+
+        actual_modified = actual.dup
+        actual_modified.each do |k, v|
+          if expected.key?(k) && expected[k] == 42
+            actual_modified[k] = 42
+          end
+        end
+
+        expect(actual_modified).to eq(expected)
+      end
+    end
+  end
+end

data/spec/support/command_monitoring.rb

@@ -230,11 +230,9 @@ module Mongo
       # @return [ Array<Expectation> ] The expectations.
       attr_reader :expectations
 
-      # @return [ String ] The server version to ignore if greater.
-      attr_reader :ignore_if_server_version_greater_than
+      attr_reader :min_server_fcv
 
-      # @return [ String ] The server version to ignore if lower.
-      attr_reader :ignore_if_server_version_less_than
+      attr_reader :max_server_version
 
       # Create the new test.
       #
@@ -248,8 +246,8 @@ module Mongo
       def initialize(data, test)
         @data = data
         @description = test['description']
-        @ignore_if_server_version_greater_than = test['ignore_if_server_version_greater_than']
-        @ignore_if_server_version_less_than = test['ignore_if_server_version_less_than']
+        @max_server_version = test['ignore_if_server_version_greater_than']
+        @min_server_fcv = test['ignore_if_server_version_less_than']
         @operation = Mongo::CRUD::Operation.get(test['operation'])
         @expectations = test['expectations'].map{ |e| Expectation.new(e) }
       end

data/spec/support/common_shortcuts.rb

@@ -89,6 +89,12 @@ module CommonShortcuts
     end
 
     def make_node_recovering_reply
+      make_protocol_reply(
+        'ok' => 0, 'code' => 11602, 'errmsg' => 'InterruptedDueToStepDown'
+      )
+    end
+
+    def make_node_shutting_down_reply
       make_protocol_reply(
         'ok' => 0, 'code' => 91, 'errmsg' => 'shutdown in progress'
       )