mongo 2.7.0 → 2.7.1

data/lib/mongo/server_selector/selectable.rb

@@ -20,6 +20,38 @@ module Mongo
     # @since 2.0.0
     module Selectable
 
+      # Initialize the server selector.
+      #
+      # @example Initialize the selector.
+      #   Mongo::ServerSelector::Secondary.new(:tag_sets => [{'dc' => 'nyc'}])
+      #
+      # @example Initialize the preference with no options.
+      #   Mongo::ServerSelector::Secondary.new
+      #
+      # @param [ Hash ] options The server preference options.
+      #
+      # @option options [ Integer ] :local_threshold The local threshold boundary for
+      #  nearest selection in seconds.
+      # @option options [ Integer ] max_staleness The maximum replication lag,
+      #   in seconds, that a secondary can suffer and still be eligible for a read.
+      #   A value of -1 is treated identically to nil, which is to not
+      #   have a maximum staleness.
+      #
+      # @raise [ Error::InvalidServerPreference ] If tag sets are specified
+      #   but not allowed.
+      #
+      # @since 2.0.0
+      def initialize(options = nil)
+        options = options ? options.dup : {}
+        if options[:max_staleness] == -1
+          options.delete(:max_staleness)
+        end
+        @options = options.freeze
+        @tag_sets = (options[:tag_sets] || []).freeze
+        @max_staleness = options[:max_staleness]
+        validate!
+      end
+
       # @return [ Hash ] options The options.
       attr_reader :options
 
@@ -48,34 +80,6 @@ module Mongo
             max_staleness == other.max_staleness
       end
 
-      # Initialize the server selector.
-      #
-      # @example Initialize the selector.
-      #   Mongo::ServerSelector::Secondary.new(:tag_sets => [{'dc' => 'nyc'}])
-      #
-      # @example Initialize the preference with no options.
-      #   Mongo::ServerSelector::Secondary.new
-      #
-      # @param [ Hash ] options The server preference options.
-      #
-      # @option options [ Integer ] :local_threshold The local threshold boundary for
-      #  nearest selection in seconds.
-      # @option options [ Integer ] max_staleness The maximum replication lag,
-      #   in seconds, that a secondary can suffer and still be eligible for a read.
-      #   A value of -1 is treated identically to nil, which is to not
-      #   have a maximum staleness.
-      #
-      # @raise [ Error::InvalidServerPreference ] If tag sets are specified
-      #   but not allowed.
-      #
-      # @since 2.0.0
-      def initialize(options = {})
-        @options = (options || {}).freeze
-        @tag_sets = (options[:tag_sets] || []).freeze
-        @max_staleness = options[:max_staleness] unless options[:max_staleness] == -1
-        validate!
-      end
-
       # Inspect the server selector.
       #
       # @example Inspect the server selector.
@@ -99,6 +103,24 @@ module Mongo
       #
       # @since 2.0.0
       def select_server(cluster, ping = nil)
+        if cluster.replica_set?
+          validate_max_staleness_value_early!
+        end
+        if cluster.addresses.empty?
+          if Lint.enabled?
+            unless cluster.servers.empty?
+              raise Error::LintError, "Cluster has no addresses but has servers: #{cluster.servers.map(&:inspect).join(', ')}"
+            end
+          end
+          msg = "Cluster has no addresses, and therefore will never have a server"
+          raise Error::NoServerAvailable.new(self, cluster, msg)
+        end
+=begin Add this check in version 3.0.0
+        unless cluster.connected?
+          msg = 'Cluster is disconnected'
+          raise Error::NoServerAvailable.new(self, cluster, msg)
+        end
+=end
         @local_threshold = cluster.options[:local_threshold] || LOCAL_THRESHOLD
         @server_selection_timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
         deadline = Time.now + server_selection_timeout
@@ -134,7 +156,24 @@ module Mongo
           end
           cluster.scan!(false)
         end
-        raise Error::NoServerAvailable.new(self, cluster)
+
+        msg = "No #{name} server is available in cluster: #{cluster.summary} " +
+                "with timeout=#{server_selection_timeout}, " +
+                "LT=#{local_threshold}"
+        dead_monitors = []
+        cluster.servers_list.each do |server|
+          thread = server.monitor.instance_variable_get('@thread')
+          if thread.nil? || !thread.alive?
+            dead_monitors << server
+          end
+        end
+        if dead_monitors.any?
+          msg += ". The following servers have dead monitor threads: #{dead_monitors.map(&:summary).join(', ')}"
+        end
+        unless cluster.connected?
+          msg += ". The cluster is disconnected (client may have been closed)"
+        end
+        raise Error::NoServerAvailable.new(self, cluster, msg)
       end
 
       # Get the timeout for server selection.
@@ -292,12 +331,27 @@ module Mongo
         end
       end
 
+      def validate_max_staleness_value_early!
+        if @max_staleness
+          unless @max_staleness >= SMALLEST_MAX_STALENESS_SECONDS
+            msg = "`max_staleness` value (#{@max_staleness}) is too small - it must be at least " +
+              "`Mongo::ServerSelector::SMALLEST_MAX_STALENESS_SECONDS` (#{ServerSelector::SMALLEST_MAX_STALENESS_SECONDS})"
+            raise Error::InvalidServerPreference.new(msg)
+          end
+        end
+      end
+
       def validate_max_staleness_value!(cluster)
         if @max_staleness
           heartbeat_frequency_seconds = cluster.options[:heartbeat_frequency] || Server::Monitor::HEARTBEAT_FREQUENCY
-          unless @max_staleness >= [ SMALLEST_MAX_STALENESS_SECONDS,
-                                     (heartbeat_frequency_seconds  + Cluster::IDLE_WRITE_PERIOD_SECONDS) ].max
-            raise Error::InvalidServerPreference.new(Error::InvalidServerPreference::INVALID_MAX_STALENESS)
+          unless @max_staleness >= [
+            SMALLEST_MAX_STALENESS_SECONDS,
+            min_cluster_staleness = heartbeat_frequency_seconds + Cluster::IDLE_WRITE_PERIOD_SECONDS,
+          ].max
+            msg = "`max_staleness` value (#{@max_staleness}) is too small - it must be at least " +
+              "`Mongo::ServerSelector::SMALLEST_MAX_STALENESS_SECONDS` (#{ServerSelector::SMALLEST_MAX_STALENESS_SECONDS}) and (the cluster's heartbeat_frequency " +
+              "setting + `Mongo::Cluster::IDLE_WRITE_PERIOD_SECONDS`) (#{min_cluster_staleness})"
+            raise Error::InvalidServerPreference.new(msg)
           end
         end
       end

data/lib/mongo/session.rb

@@ -24,6 +24,7 @@ module Mongo
   class Session
     extend Forwardable
     include Retryable
+    include Loggable
 
     # Get the options for this session.
     #
@@ -113,6 +114,13 @@ module Mongo
     # @param [ Client ] client The client through which this session is created.
     # @param [ Hash ] options The options for this session.
     #
+    # @option options [ true|false ] :causal_consistency Whether to enable
+    #   causal consistency for this session.
+    # @option options [ Hash ] :default_transaction_options Options to pass
+    #   to start_transaction by default, can contain any of the options that
+    #   start_transaction accepts.
+    # @option options [ true|false ] :implicit For internal driver use only -
+    #   specifies whether the session is implicit.
     # @option options [ Hash ] :read_preference The read preference options hash,
     #   with the following optional keys:
     #   - *:mode* -- the read preference as a string or symbol; valid values are
@@ -264,9 +272,28 @@ module Mongo
         end
 
         # The read concern should be added to any command that starts a transaction.
-        if starting_transaction? && txn_read_concern
-          c[:readConcern] ||= {}
-          c[:readConcern].merge!(txn_read_concern)
+        if starting_transaction?
+          # https://jira.mongodb.org/browse/SPEC-1161: transaction's
+          # read concern overrides collection/database/client read concerns,
+          # even if transaction's read concern is not set.
+          # Read concern here is the one sent to the server and may
+          # include afterClusterTime.
+          if rc = c[:readConcern]
+            rc = rc.dup
+            rc.delete(:level)
+          end
+          if txn_read_concern
+            if rc
+              rc.update(txn_read_concern)
+            else
+              rc = txn_read_concern.dup
+            end
+          end
+          if rc.nil? || rc.empty?
+            c.delete(:readConcern)
+          else
+            c[:readConcern ] = rc
+          end
         end
 
         # We need to send the read concern level as a string rather than a symbol.
@@ -275,8 +302,15 @@ module Mongo
         end
 
         # The write concern should be added to any abortTransaction or commitTransaction command.
-        if (c[:abortTransaction] || c[:commitTransaction]) && txn_write_concern
-          c[:writeConcern] = txn_write_concern
+        if (c[:abortTransaction] || c[:commitTransaction])
+          if @already_committed
+            wc = BSON::Document.new(c[:writeConcern] || txn_write_concern || {})
+            wc.merge!(w: :majority)
+            wc[:wtimeout] ||= 10000
+            c[:writeConcern] = wc
+          elsif txn_write_concern
+            c[:writeConcern] ||= txn_write_concern
+          end
         end
 
         # A non-numeric write concern w value needs to be sent as a string rather than a symbol.
@@ -544,6 +578,7 @@ module Mongo
       end
 
       @state = STARTING_TRANSACTION_STATE
+      @already_committed = false
     end
 
     # Commit the currently active transaction on the session.
@@ -574,6 +609,7 @@ module Mongo
         # operation again, so we revert the session to the previous state.
         if within_states?(TRANSACTION_COMMITTED_STATE)
           @state = @last_commit_skipped ? STARTING_TRANSACTION_STATE : TRANSACTION_IN_PROGRESS_STATE
+          @already_committed = true
         end
 
         if starting_transaction?
@@ -585,7 +621,16 @@ module Mongo
           if write_concern && !write_concern.is_a?(WriteConcern::Base)
             write_concern = WriteConcern.get(write_concern)
           end
-          write_with_retry(self, write_concern, true) do |server, txn_num|
+          write_with_retry(self, write_concern, true) do |server, txn_num, is_retry|
+            if is_retry
+              if write_concern
+                wco = write_concern.options.merge(w: :majority)
+                wco[:wtimeout] ||= 10000
+                write_concern = WriteConcern.get(wco)
+              else
+                write_concern = WriteConcern.get(w: :majority, wtimeout: 10000)
+              end
+            end
             Operation::Command.new(
               selector: { commitTransaction: 1 },
               db_name: 'admin',
@@ -652,6 +697,9 @@ module Mongo
         raise
       rescue Mongo::Error
         @state = TRANSACTION_ABORTED_STATE
+      rescue Exception
+        @state = TRANSACTION_ABORTED_STATE
+        raise
       end
     end
 
@@ -687,15 +735,16 @@ module Mongo
     # with_transaction. Exceptions derived from Mongo::Error may be
     # handled by with_transaction, resulting in retries of the process.
     #
-    # The number of retries and the total time taken by with_transaction is
-    # not specified by the driver. The driver only guarantees that the number
-    # of retries attempted will be finite, i.e., that it will stop retrying
-    # at some point. The number of retries and the time allowed for the retries
-    # is subject to change in future versions of the driver. Applications that
-    # require known performance characteristics (for example, when servicing
-    # web requests in an application with a fixed number of servers/workers/threads)
-    # are encouraged to explicitly limit the time they allow for with_transaction
-    # calls.
+    # Currently, with_transaction will retry commits and block invocations
+    # until at least 120 seconds have passed since with_transaction started
+    # executing. This timeout is not configurable and may change in a future
+    # driver version.
+    #
+    # @note with_transaction contains a loop, therefore the if with_transaction
+    #   itself is placed in a loop, its block should not call next or break to
+    #   control the outer loop because this will instead affect the loop in
+    #   with_transaction. The driver will warn and abort the transaction
+    #   if it detects this situation.
     #
     # @example Execute a statement in a transaction
     #   session.with_transaction(write_concern: {w: :majority}) do
@@ -721,17 +770,27 @@ module Mongo
     #
     # @since 2.7.0
     def with_transaction(options=nil)
+      # Non-configurable 120 second timeout for the entire operation
+      deadline = Time.now + 120
+      transaction_in_progress = false
       loop do
         commit_options = {}
         if options
           commit_options[:write_concern] = options[:write_concern]
         end
         start_transaction(options)
+        transaction_in_progress = true
         begin
           rv = yield self
         rescue Exception => e
           if within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
             abort_transaction
+            transaction_in_progress = false
+          end
+
+          if Time.now >= deadline
+            transaction_in_progress = false
+            raise
           end
 
           if e.is_a?(Mongo::Error) && e.label?(Mongo::Error::TRANSIENT_TRANSACTION_ERROR_LABEL)
@@ -741,14 +800,24 @@ module Mongo
           raise
         else
           if within_states?(TRANSACTION_ABORTED_STATE, NO_TRANSACTION_STATE, TRANSACTION_COMMITTED_STATE)
+            transaction_in_progress = false
             return rv
           end
 
           begin
             commit_transaction(commit_options)
+            transaction_in_progress = false
             return rv
           rescue Mongo::Error => e
             if e.label?(Mongo::Error::UNKNOWN_TRANSACTION_COMMIT_RESULT_LABEL)
+              # WriteConcernFailed
+              if e.is_a?(Mongo::Error::OperationFailure) && e.code == 64 && e.wtimeout?
+                raise
+              end
+              if Time.now >= deadline
+                transaction_in_progress = false
+                raise
+              end
               wc_options = case v = commit_options[:write_concern]
                 when WriteConcern::Base
                   v.options
@@ -760,13 +829,26 @@ module Mongo
               commit_options[:write_concern] = wc_options.merge(w: :majority)
               retry
             elsif e.label?(Mongo::Error::TRANSIENT_TRANSACTION_ERROR_LABEL)
+              if Time.now >= deadline
+                transaction_in_progress = false
+                raise
+              end
               next
             else
+              transaction_in_progress = false
               raise
             end
           end
         end
       end
+    ensure
+      if transaction_in_progress
+        log_warn('with_transaction callback altered with_transaction loop, aborting transaction')
+        begin
+          abort_transaction
+        rescue Error::OperationFailure, Error::InvalidTransactionOperation
+        end
+      end
     end
 
     # Get the read preference the session will use in the currently
@@ -809,6 +891,7 @@ module Mongo
     end
 
     def txn_read_concern
+      # Read concern is inherited from client but not db or collection.
       txn_options && txn_options[:read_concern] || @client.read_concern
     end
 

data/lib/mongo/version.rb

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

data/spec/README.md

@@ -0,0 +1,85 @@
+The tests run against a MongoDB cluster which is
+configured and started externally to the test suite. This allows
+running the entire test suite against, for example, a standalone
+mongod as well as a replica set. The flip side to this is the
+test suite will not work without a running mongo cluster, and
+tests which are not applicable to or cannot be performed on the
+running mongo cluster are skipped.
+
+Not only does the test suite require an externally launched cluster,
+the test suite must also be told how the cluster is configured
+via MONGODB_URI, TOPOLOGY, MONGODB_ADDRESSES, RS_ENABLED, RS_NAME and/or
+SHARDED_ENABLED environment variables.
+
+The test suite attempts to provide diagnostics when it is not able to
+connect to the cluster it is configured to use.
+
+Additionally some of the tests assume that the seed list (given in
+MONGODB_URI or MONGODB_ADDRESSES) encompasses all servers in the cluster,
+and will fail when MONGODB_URI includes only one host of a replica set.
+It is best to include all hosts of the cluster in MONGODB_URI and
+MONGODB_ADDRESSES.
+
+It is best to have the test suite configured to connect to exactly
+the hostnames configured in the cluster. If, for example, the test suite
+is configured to use IP addresses but the cluster is configured with
+hostnames, the tests should still work (by using SDAM to discover correct
+cluster configuration) but will spend a significant amount of extra time
+on server discovery.
+
+In order to run spec tests, the mongo cluster needs to have fail points
+enabled. This is accomplished by starting mongod with the following option:
+  --setParameter enableTestCommands=1
+
+Use the following environment variables to configure the tests:
+
+CLIENT_DEBUG: Show debug messages from the client.
+
+    CLIENT_DEBUG=1
+
+MONGODB_URI: Connection string to use. This must be a valid MongoDB URI;
+mongodb:// and mongodb+srv:// are both supported.
+RS_ENABLED and SHARDED_ENABLED are NOT honored if using MONGODB_URI -
+specify replica set name in the URI and to specify a sharded topology
+set TOPOLOGY=sharded_cluster environment variable.
+
+    MONGODB_URI=mongodb://127.0.0.1:27001/?replicaSet=test
+    MONGODB_URI=mongodb://127.0.0.1:27001,127.0.0.1:27002/ TOPOLOGY=sharded_cluster
+
+MONGODB_ADDRESSES: Specify addresses to connect to. Use RS_ENABLED,
+RS_NAME and SHARDED_ENABLED to configure the topology.
+
+    MONGODB_ADDRESSES=127.0.0.1:27017,127.0.0.1:27018
+    MONGODB_ADDRESSES=127.0.0.1:27017,127.0.0.1:27018 RS_ENABLED=1
+    MONGODB_ADDRESSES=127.0.0.1:27017,127.0.0.1:27018 RS_ENABLED=1 RS_NAME=test
+    MONGODB_ADDRESSES=127.0.0.1:27017,127.0.0.1:27018 SHARDED_ENABLED=1
+
+RS_ENABLED: Instruct the test suite to connect to a replica set.
+RS_ENABLED is only honored when not using MONGODB_URI; to connect to a
+replica set with MONGODB_URI, specify the replica set name in the URI
+(despite the Ruby driver performing topology discovery by default, it
+doesn't do so in the test suite).
+RS_NAME can be given to specify the replica set name; the default is
+ruby-driver-rs.
+
+    RS_ENABLED=1
+    RS_ENABLED=1 RS_NAME=test
+
+SHARDED_ENABLED: Instruct the test suite to connect to the sharded cluster.
+Set MONGODB_URI appropriately as well.
+
+    SHARDED_ENABLED=1
+
+SSL_ENABLED: Instruct the test suite to connect to the cluster via SSL.
+
+    SSL_ENABLED=1
+    # Also acceptable:
+    SSL=ssl
+
+Note: SSL can also be enabled by giving ssl=true in the MONGODB_URI options.
+
+EXTERNAL_DISABLED: Run the tests without making any external connections
+(for example, external connections are required to test DNS seedlists and SRV
+URIs).
+
+    EXTERNAL_DISABLED=true