mongo 2.11.2 → 2.13.0.beta1

data/lib/mongo/operation/shared/response_handling.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 MongoDB, Inc.
+# Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,10 +22,10 @@ module Mongo
 
       private
 
-      def validate_result(result, server)
+      def validate_result(result, client, connection)
         unpin_maybe(session) do
-          add_error_labels do
-            add_server_diagnostics(server) do
+          add_error_labels(client, connection, session) do
+            add_server_diagnostics(connection) do
               result.validate!
             end
           end
@@ -38,7 +38,7 @@ module Mongo
       # and server-side errors (Error::OperationFailure); it does not
       # handle server selection errors (Error::NoServerAvailable), for which
       # labels are added in the server selection code.
-      def add_error_labels
+      def add_error_labels(client, connection, session)
         begin
           yield
         rescue Mongo::Error::SocketError => e
@@ -48,6 +48,12 @@ module Mongo
           if session && session.committing_transaction?
             e.add_label('UnknownTransactionCommitResult')
           end
+
+          maybe_add_retryable_write_error_label!(e, connection, client, session)
+
+          raise e
+        rescue Mongo::Error::SocketTimeoutError => e
+          maybe_add_retryable_write_error_label!(e, connection, client, session)
           raise e
         rescue Mongo::Error::OperationFailure => e
           if session && session.committing_transaction?
@@ -57,6 +63,9 @@ module Mongo
               e.add_label('UnknownTransactionCommitResult')
             end
           end
+
+          maybe_add_retryable_write_error_label!(e, connection, client, session)
+
           raise e
         end
       end
@@ -68,7 +77,7 @@ module Mongo
       #   is included in BulkWrite which does not store the session in the
       #   receiver (despite Specifiable doing so).
       #
-      # @param [ Session | nil ] Session to consider.
+      # @param [ Session | nil ] session Session to consider.
       def unpin_maybe(session)
         yield
       rescue Mongo::Error => e
@@ -83,12 +92,78 @@ module Mongo
       #
       # This method is intended to add server address information to exceptions
       # raised during execution of operations on servers.
-      def add_server_diagnostics(server)
+      def add_server_diagnostics(connection)
         yield
-      rescue Mongo::Error, Mongo::Error::AuthError => e
-        e.add_note("on #{server.address.seed}")
+      rescue Error::SocketError, Error::SocketTimeoutError
+        # Diagnostics should have already been added by the connection code,
+        # do not add them again.
+        raise
+      rescue Error, Error::AuthError => e
+        e.add_note("on #{connection.address.seed}")
+        e.generation = connection.generation
         raise e
       end
+
+      private
+
+      # A method that will add the RetryableWriteError label to an error if
+      # any of the following conditions are true:
+      #
+      # The error meets the criteria for a retryable error (i.e. has one
+      #   of the retryable error codes or error messages)
+      #
+      # AND the server does not support adding the RetryableWriteError label OR
+      #   the error is a network error (i.e. the driver must add the label)
+      #
+      # AND the error occured during a commitTransaction or abortTransaction
+      #   OR the error occured during a write outside of a transaction on a
+      #   client that has retry writes enabled.
+      #
+      # If these conditions are met, the original error will be mutated.
+      # If they're not met, the error will not be changed.
+      #
+      # @param [ Mongo::Error ] error The error to which to add the label.
+      # @param [ Mongo::Server::Connection ] connection The connection on which
+      #   the operation is performed.
+      # @param [ Mongo::Client | nil ] client The client that is performing
+      #   the operation.
+      # @param [ Mongo::Session ] session The operation's session.
+      #
+      # @note The client argument is optional because some operations, such as
+      #   end_session, do not pass the client as an argument to the execute
+      #   method.
+      def maybe_add_retryable_write_error_label!(error, connection, client, session)
+        in_transaction = session && session.in_transaction?
+        committing_transaction = in_transaction && session.committing_transaction?
+        aborting_transaction = in_transaction && session.aborting_transaction?
+        modern_retry_writes = client && client.options[:retry_writes]
+        legacy_retry_writes = client && !client.options[:retry_writes] &&
+          client.max_write_retries > 0
+
+        # An operation is retryable if it meets one of the following criteria:
+        # - It is a commitTransaction or abortTransaction
+        # - It does not occur during a transaction and the client has enabled
+        #   modern or legacy writes
+        #
+        # Note: any write operation within a transaction (excepting commit and
+        # abort is NOT a retryable operation)
+        retryable_operation = committing_transaction || aborting_transaction ||
+          (!in_transaction && (modern_retry_writes || legacy_retry_writes))
+
+        # An operation should add the RetryableWriteError label if one of the
+        # following conditions is met:
+        # - The server does not support adding the RetryableWriteError label
+        # - The error is a network error
+        should_add_error_label =
+          !connection.description.features.retryable_write_error_label_enabled? ||
+          error.write_concern_error_label?('RetryableWriteError') ||
+          error.is_a?(Mongo::Error::SocketError) ||
+          error.is_a?(Mongo::Error::SocketTimeoutError)
+
+        if retryable_operation && should_add_error_label && error.write_retryable?
+          error.add_label('RetryableWriteError')
+        end
+      end
     end
   end
 end

data/lib/mongo/operation/shared/result/aggregatable.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/mongo/operation/shared/result/use_legacy_error_parser.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 MongoDB, Inc.
+# Copyright (C) 2019-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/mongo/operation/shared/sessions_supported.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2015-2019 MongoDB, Inc.
+# Copyright (C) 2015-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -45,10 +45,10 @@ module Mongo
       # operation (the one which starts the transaction via startTransaction)
       # is allowed to have a read concern, and with it the causal consistency
       # document, specified.
-      def apply_causal_consistency!(selector, server)
+      def apply_causal_consistency!(selector, connection)
         return unless selector[:startTransaction]
 
-        apply_causal_consistency_if_possible(selector, server)
+        apply_causal_consistency_if_possible(selector, connection)
       end
 
       # Adds causal consistency document to the selector, if one can be
@@ -58,8 +58,8 @@ module Mongo
       # causal consistency must be enabled for the session and the session
       # must have the current operation time. Also, topology must be
       # replica set or sharded cluster.
-      def apply_causal_consistency_if_possible(selector, server)
-        if !server.standalone?
+      def apply_causal_consistency_if_possible(selector, connection)
+        if !connection.description.standalone?
           cc_doc = session.send(:causal_consistency_doc)
           if cc_doc
             rc_doc = (selector[:readConcern] || read_concern || {}).merge(cc_doc)
@@ -73,9 +73,12 @@ module Mongo
         acknowledged_write? ? [] : [:more_to_come]
       end
 
-      def apply_cluster_time!(selector, server)
-        if !server.standalone?
-          cluster_time = [server.cluster_time, session && session.cluster_time].compact.max
+      def apply_cluster_time!(selector, connection)
+        if !connection.description.standalone?
+          cluster_time = [
+            connection.cluster_time,
+            session&.cluster_time,
+          ].compact.max
 
           if cluster_time
             selector['$clusterTime'] = cluster_time
@@ -119,32 +122,93 @@ module Mongo
         session.validate_read_preference!(selector) if read_command?(selector)
       end
 
-      def command(server)
-        sel = selector(server).dup
+      def command(connection)
+        if Lint.enabled?
+          unless connection.is_a?(Server::Connection)
+            raise Error::LintError, "Connection is not a Connection instance: #{connection}"
+          end
+        end
+
+        sel = selector(connection).dup
         add_write_concern!(sel)
         sel[Protocol::Msg::DATABASE_IDENTIFIER] = db_name
-        unless server.standalone?
-          sel['$readPreference'] = read.to_doc if read
-        end
 
-        if server.features.sessions_enabled?
-          apply_cluster_time!(sel, server)
+        add_read_preference(sel, connection)
+
+        if connection.features.sessions_enabled?
+          apply_cluster_time!(sel, connection)
           if session && (acknowledged_write? || session.in_transaction?)
-            apply_session_options(sel, server)
+            apply_session_options(sel, connection)
           end
         elsif session && session.explicit?
-          apply_session_options(sel, server)
+          apply_session_options(sel, connection)
         end
 
         sel
       end
 
-      def apply_session_options(sel, server)
-        apply_cluster_time!(sel, server)
+      # Adds $readPreference field to the command document.
+      #
+      # $readPreference is only sent when the server is a mongos,
+      # following the rules described in
+      # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#passing-read-preference-to-mongos.
+      # The topology does not matter for figuring out whether to send
+      # $readPreference since the decision is always made based on
+      # server type.
+      #
+      # $readPreference is sent to OP_MSG-grokking replica set members.
+      #
+      # @param [ Hash ] sel Existing command document which will be mutated.
+      # @param [ Server::Connection ] connection The connection that the
+      #   operation will be executed on.
+      def add_read_preference(sel, connection)
+        Lint.assert_type(connection, Server::Connection)
+
+        # https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst#topology-type-single
+        if connection.description.standalone?
+          # Read preference is never sent to standalones.
+        elsif connection.description.mongos?
+          # When server is a mongos:
+          # - $readPreference is never sent when mode is 'primary'
+          # - When mode is 'secondaryPreferred' $readPreference is only sent
+          #   when a non-mode field (i.e. tag_sets) is present
+          # - Otherwise $readPreference is sent
+          if read
+            doc = read.to_mongos
+            if doc
+              sel['$readPreference'] = doc
+            end
+          end
+        elsif connection.server.cluster.single?
+          # In Single topology:
+          # - If no read preference is specified by the application, the driver
+          #   adds mode: primaryPreferred.
+          # - If a read preference is specified by the application, the driver
+          #   replaces the mode with primaryPreferred.
+          read_doc = if read
+            BSON::Document.new(read.to_doc)
+          else
+            BSON::Document.new
+          end
+          if [nil, 'primary'].include?(read_doc['mode'])
+            read_doc['mode'] = 'primaryPreferred'
+          end
+          sel['$readPreference'] = read_doc
+        else
+          # In replica sets, read preference is passed to the server if one
+          # is specified by the application, and there is no default.
+          if read
+            sel['$readPreference'] = read.to_doc
+          end
+        end
+      end
+
+      def apply_session_options(sel, connection)
+        apply_cluster_time!(sel, connection)
         sel[:txnNumber] = BSON::Int64.new(txn_num) if txn_num
         sel.merge!(lsid: session.session_id)
         apply_start_transaction!(sel)
-        apply_causal_consistency!(sel, server)
+        apply_causal_consistency!(sel, connection)
         apply_autocommit!(sel)
         apply_txn_opts!(sel)
         suppress_read_write_concern!(sel)
@@ -157,12 +221,12 @@ module Mongo
         end
       end
 
-      def build_message(server)
+      def build_message(connection)
         super.tap do |message|
           if session
             # Serialize the message to detect client-side problems,
             # such as invalid BSON keys. The message will be serialized again
-            # later prior to being sent to the server.
+            # later prior to being sent to the connection.
             message.serialize(BSON::ByteBuffer.new)
 
             session.update_state!

data/lib/mongo/operation/shared/specifiable.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -325,15 +325,15 @@ module Mongo
         spec[OPERATION_ID]
       end
 
-      # Get the options for the operation.
+      # Get the options for executing the operation on a particular connection.
       #
-      # @example Get the options.
-      #   specifiable.options
+      # @param [ Server::Connection ] connection The connection that the
+      #   operation will be executed on.
       #
       # @return [ Hash ] The options.
       #
       # @since 2.0.0
-      def options(server = nil)
+      def options(connection)
         spec[OPTIONS] || {}
       end
 
@@ -387,15 +387,16 @@ module Mongo
         send(self.class::IDENTIFIER).first[COLLATION]
       end
 
-      # The selector for from the specification.
+      # The selector from the specification for execution on a particular
+      # connection.
       #
-      # @example Get a selector specification.
-      #   specifiable.selector.
+      # @param [ Server::Connection ] connection The connection that the
+      #   operation will be executed on.
       #
       # @return [ Hash ] The selector spec.
       #
       # @since 2.0.0
-      def selector(server = nil)
+      def selector(connection)
         spec[SELECTOR]
       end
 
@@ -478,7 +479,9 @@ module Mongo
       #
       # @since 2.0.0
       def read
-        @read ||= ServerSelector.get(spec[READ]) if spec[READ]
+        @read ||= begin
+          ServerSelector.get(spec[READ]) if spec[READ]
+        end
       end
 
       # Whether the operation is ordered.
@@ -529,28 +532,37 @@ module Mongo
         @spec[:txn_num]
       end
 
-      # The command.
+      # For createIndexes operations, the number of votes that a primary must
+      # wait for before commiting an index. Potential values are:
+      # - an integer from 0 to the number of members of the replica set
+      # - "majority" indicating that a majority of data bearing nodes must vote
+      # - "votingMembers" which means that all voting data bearing nodes must vote
       #
-      # @example Get the command.
-      #   specifiable.command
+      # @return [ nil | Integer | String ] The commitQuorum value of the operation.
+      def commit_quorum
+        @spec[:commit_quorum]
+      end
+
+      # The command.
       #
       # @return [ Hash ] The command.
       #
       # @since 2.5.2
-      def command(server = nil)
-        selector(server)
+      def command(connection)
+        selector(connection)
       end
 
       # The array filters.
       #
-      # @example Get the array filters.
-      #   specifiable.array_filters
+      # @param [ Server::Connection ] connection The connection that the
+      #   operation will be executed on.
       #
-      # @return [ Hash ] The array filters.
+      # @return [ Hash | nil ] The array filters.
       #
       # @since 2.5.2
-      def array_filters
-        selector[Operation::ARRAY_FILTERS] if selector
+      def array_filters(connection)
+        sel = selector(connection)
+        sel[Operation::ARRAY_FILTERS] if sel
       end
 
       # Does the operation have an acknowledged write concern.

data/lib/mongo/operation/shared/write.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 MongoDB, Inc.
+# Copyright (C) 2018-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -25,54 +25,67 @@ module Mongo
       # Execute the operation.
       #
       # @example
-      #   operation.execute(server)
+      #   operation.execute(server, client: nil)
       #
       # @param [ Mongo::Server ] server The server to send the operation to.
+      # @param [ Mongo::Client ] client The client that will be used to
+      #   perform auto-encryption if it is necessary to encrypt the command
+      #   being executed (optional).
       #
       # @return [ Mongo::Operation::Result ] The operation result.
       #
       # @since 2.5.2
-      def execute(server)
-        validate!
-        result = if server.features.op_msg_enabled?
-            self.class::OpMsg.new(spec).execute(server)
-          elsif !acknowledged_write?
-            self.class::Legacy.new(spec).execute(server)
-          else
-            self.class::Command.new(spec).execute(server)
-          end
-        validate_result(result, server)
+      def execute(server, client:)
+        server.with_connection do |connection|
+          validate!(connection)
+          op = if connection.features.op_msg_enabled?
+              self.class::OpMsg.new(spec)
+            elsif !acknowledged_write?
+              self.class::Legacy.new(spec)
+            else
+              self.class::Command.new(spec)
+            end
+
+          result = op.execute(connection, client: client)
+          validate_result(result, client, connection)
+        end
       end
 
       # Execute the bulk write operation.
       #
       # @example
-      #   operation.bulk_execute(server)
+      #   operation.bulk_execute(connection, client: nil)
       #
-      # @param [ Mongo::Server ] server The server to send the operation to.
+      # @param [ Mongo::Server::Connection ] connection The connection over
+      #   which to send the operation.
+      # @param [ Mongo::Client ] client The client that will be used to
+      #   perform auto-encryption if it is necessary to encrypt the command
+      #   being executed (optional).
       #
       # @return [ Mongo::Operation::Delete::BulkResult,
       #           Mongo::Operation::Insert::BulkResult,
       #           Mongo::Operation::Update::BulkResult ] The bulk result.
       #
       # @since 2.5.2
-      def bulk_execute(server)
-        if server.features.op_msg_enabled?
-          self.class::OpMsg.new(spec).execute(server).bulk_result
+      def bulk_execute(connection, client:)
+        Lint.assert_type(connection, Server::Connection)
+
+        if connection.features.op_msg_enabled?
+          self.class::OpMsg.new(spec).execute(connection, client: client).bulk_result
         else
-          self.class::Command.new(spec).execute(server).bulk_result
+          self.class::Command.new(spec).execute(connection, client: client).bulk_result
         end
       end
 
       private
 
-      def validate!
+      def validate!(connection)
         if !acknowledged_write?
           if collation
             raise Error::UnsupportedCollation.new(
                 Error::UnsupportedCollation::UNACKNOWLEDGED_WRITES_MESSAGE)
           end
-          if array_filters
+          if array_filters(connection)
             raise Error::UnsupportedArrayFilters.new(
                 Error::UnsupportedArrayFilters::UNACKNOWLEDGED_WRITES_MESSAGE)
           end