mongo 2.14.0 → 2.15.0.alpha

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

@@ -21,8 +21,8 @@ module Mongo
     # @api private
     module ExecutableNoValidate
 
-      def execute(connection, client:)
-        do_execute(connection, client)
+      def execute(connection, context:)
+        do_execute(connection, context)
       end
     end
   end

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

@@ -20,15 +20,9 @@ module Mongo
     #
     # @api private
     module OpMsgOrCommand
+      include PolymorphicOperation
       include PolymorphicLookup
 
-      def execute(server, client:, options: {})
-        server.with_connection do |connection|
-          operation = final_operation(connection)
-          operation.execute(connection, client: client, options: options)
-        end
-      end
-
       private
 
       def final_operation(connection)

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

@@ -21,15 +21,9 @@ module Mongo
     #
     # @api private
     module OpMsgOrFindCommand
+      include PolymorphicOperation
       include PolymorphicLookup
 
-      def execute(server, client:)
-        server.with_connection do |connection|
-          operation = final_operation(connection)
-          operation.execute(connection, client: client)
-        end
-      end
-
       private
 
       def final_operation(connection)

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

@@ -0,0 +1,39 @@
+# Copyright (C) 2021 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 Operation
+
+    # Shared behavior of implementing an operation differently based on
+    # the server that will be executing the operation.
+    #
+    # @api private
+    module PolymorphicOperation
+
+      # Execute the operation.
+      #
+      # @param [ Mongo::Server ] server The server to send the operation to.
+      # @param [ Operation::Context ] context The operation context.
+      # @param [ Hash ] options Operation execution options.
+      #
+      # @return [ Mongo::Operation::Result ] The operation result.
+      def execute(server, context:, options: {})
+        server.with_connection do |connection|
+          operation = final_operation(connection)
+          operation.execute(connection, context: context, options: options)
+        end
+      end
+    end
+  end
+end

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

@@ -22,9 +22,13 @@ module Mongo
 
       private
 
-      def validate_result(result, client, connection)
-        unpin_maybe(session) do
-          add_error_labels(client, connection, session) do
+      # @param [ Mongo::Operation::Result ] result The operation result.
+      # @param [ Mongo::Server::Connection ] connection The connection on which
+      #   the operation is performed.
+      # @param [ Mongo::Operation::Context ] context The operation context.
+      def validate_result(result, connection, context)
+        unpin_maybe(context.session) do
+          add_error_labels(connection, context) do
             add_server_diagnostics(connection) do
               result.validate!
             end
@@ -38,25 +42,29 @@ 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(client, connection, session)
+      #
+      # @param [ Mongo::Server::Connection ] connection The connection on which
+      #   the operation is performed.
+      # @param [ Mongo::Operation::Context ] context The operation context.
+      def add_error_labels(connection, context)
         begin
           yield
         rescue Mongo::Error::SocketError => e
-          if session && session.in_transaction? && !session.committing_transaction?
+          if context.in_transaction? && !context.committing_transaction?
             e.add_label('TransientTransactionError')
           end
-          if session && session.committing_transaction?
+          if context.committing_transaction?
             e.add_label('UnknownTransactionCommitResult')
           end
 
-          maybe_add_retryable_write_error_label!(e, connection, client, session)
+          maybe_add_retryable_write_error_label!(e, connection, context)
 
           raise e
         rescue Mongo::Error::SocketTimeoutError => e
-          maybe_add_retryable_write_error_label!(e, connection, client, session)
+          maybe_add_retryable_write_error_label!(e, connection, context)
           raise e
         rescue Mongo::Error::OperationFailure => e
-          if session && session.committing_transaction?
+          if context.committing_transaction?
             if e.write_retryable? || e.wtimeout? || (e.write_concern_error? &&
                 !Session::UNLABELED_WRITE_CONCERN_CODES.include?(e.write_concern_error_code)
             ) || e.max_time_ms_expired?
@@ -64,7 +72,7 @@ module Mongo
             end
           end
 
-          maybe_add_retryable_write_error_label!(e, connection, client, session)
+          maybe_add_retryable_write_error_label!(e, connection, context)
 
           raise e
         end
@@ -125,21 +133,12 @@ module Mongo
       # @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.
+      # @param [ Mongo::Operation::Context ] context The operation context.
       #
       # @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
-
+      def maybe_add_retryable_write_error_label!(error, connection, context)
         # 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
@@ -147,8 +146,9 @@ module Mongo
         #
         # 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))
+        retryable_operation = context.committing_transaction? ||
+          context.aborting_transaction? ||
+          !context.in_transaction? && context.any_retry_writes?
 
         # An operation should add the RetryableWriteError label if one of the
         # following conditions is met:

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

@@ -222,9 +222,20 @@ module Mongo
         end
       end
 
-      def build_message(connection)
+      def build_message(connection, context)
+        if self.session != context.session
+          if self.session
+            raise Error::InternalDriverError, "Operation session #{self.session.inspect} does not match context session #{context.session.inspect}"
+          else
+            # Some operations are not constructed with sessions but are
+            # executed in a context where a session is available.
+            # This could be OK or a driver issue.
+            # TODO investigate.
+          end
+        end
+
         super.tap do |message|
-          if session
+          if session = context.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 connection.

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

@@ -25,18 +25,13 @@ module Mongo
 
       # Execute the operation.
       #
-      # @example
-      #   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).
+      # @param [ Operation::Context ] context The operation context.
       #
       # @return [ Mongo::Operation::Result ] The operation result.
       #
       # @since 2.5.2
-      def execute(server, client:)
+      def execute(server, context:)
         server.with_connection do |connection|
           validate!(connection)
           op = if connection.features.op_msg_enabled?
@@ -47,34 +42,29 @@ module Mongo
               self.class::Command.new(spec)
             end
 
-          result = op.execute(connection, client: client)
-          validate_result(result, client, connection)
+          result = op.execute(connection, context: context)
+          validate_result(result, connection, context)
         end
       end
 
       # Execute the bulk write operation.
       #
-      # @example
-      #   operation.bulk_execute(connection, client: nil)
-      #
       # @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).
+      # @param [ Operation::Context ] context The operation context.
       #
       # @return [ Mongo::Operation::Delete::BulkResult,
       #           Mongo::Operation::Insert::BulkResult,
       #           Mongo::Operation::Update::BulkResult ] The bulk result.
       #
       # @since 2.5.2
-      def bulk_execute(connection, client:)
+      def bulk_execute(connection, context:)
         Lint.assert_type(connection, Server::Connection)
 
         if connection.features.op_msg_enabled?
-          self.class::OpMsg.new(spec).execute(connection, client: client).bulk_result
+          self.class::OpMsg.new(spec).execute(connection, context: context).bulk_result
         else
-          self.class::Command.new(spec).execute(connection, client: client).bulk_result
+          self.class::Command.new(spec).execute(connection, context: context).bulk_result
         end
       end
 

data/lib/mongo/protocol/compressed.rb

@@ -18,12 +18,25 @@ module Mongo
     # MongoDB Wire protocol Compressed message.
     #
     # This is a bi-directional message that compresses another opcode.
+    # See https://github.com/mongodb/specifications/blob/master/source/compression/OP_COMPRESSED.rst
     #
     # @api semipublic
     #
     # @since 2.5.0
     class Compressed < Message
 
+      # The noop compressor identifier.
+      NOOP = 'noop'.freeze
+
+      # The byte signaling that the message has not been compressed (test mode).
+      NOOP_BYTE = 0.chr.force_encoding(BSON::BINARY).freeze
+
+      # The snappy compressor identifier.
+      SNAPPY = 'snappy'.freeze
+
+      # The byte signaling that the message has been compressed with snappy.
+      SNAPPY_BYTE = 1.chr.force_encoding(BSON::BINARY).freeze
+
       # The byte signaling that the message has been compressed with Zlib.
       #
       # @since 2.5.0
@@ -34,10 +47,20 @@ module Mongo
       # @since 2.5.0
       ZLIB = 'zlib'.freeze
 
+      # The zstd compressor identifier.
+      ZSTD = 'zstd'.freeze
+
+      # The byte signaling that the message has been compressed with zstd.
+      ZSTD_BYTE = 3.chr.force_encoding(BSON::BINARY).freeze
+
       # The compressor identifier to byte map.
       #
       # @since 2.5.0
-      COMPRESSOR_ID_MAP = { ZLIB => ZLIB_BYTE }.freeze
+      COMPRESSOR_ID_MAP = {
+        SNAPPY => SNAPPY_BYTE,
+        ZSTD => ZSTD_BYTE,
+        ZLIB => ZLIB_BYTE
+      }.freeze
 
       # Creates a new OP_COMPRESSED message.
       #
@@ -68,9 +91,7 @@ module Mongo
       # @api private
       def maybe_inflate
         message = Registry.get(@original_op_code).allocate
-        uncompressed_message = Zlib::Inflate.inflate(@compressed_message)
-
-        buf = BSON::ByteBuffer.new(uncompressed_message)
+        buf = decompress(@compressed_message)
 
         message.send(:fields).each do |field|
           if field[:multi]
@@ -125,10 +146,35 @@ module Mongo
         buf = BSON::ByteBuffer.new
         @original_message.send(:serialize_fields, buf, max_bson_size)
         @uncompressed_size = buf.length
-        @compressed_message = Zlib::Deflate.deflate(buf.to_s, @zlib_compression_level).force_encoding(BSON::BINARY)
+        @compressed_message = compress(buf)
         super
       end
 
+      def compress(buffer)
+        if @compressor_id == NOOP_BYTE
+          buffer.to_s.force_encoding(BSON::BINARY)
+        elsif @compressor_id == ZLIB_BYTE
+          Zlib::Deflate.deflate(buffer.to_s, @zlib_compression_level).force_encoding(BSON::BINARY)
+        elsif @compressor_id == SNAPPY_BYTE
+          Snappy.deflate(buffer.to_s).force_encoding(BSON::BINARY)
+        elsif @compressor_id == ZSTD_BYTE
+          # DRIVERS-600 will allow this to be configurable in the future
+          Zstd.compress(buffer.to_s).force_encoding(BSON::BINARY)
+        end
+      end
+
+      def decompress(compressed_message)
+        if @compressor_id == NOOP_BYTE
+          BSON::ByteBuffer.new(compressed_message)
+        elsif @compressor_id == ZLIB_BYTE
+          BSON::ByteBuffer.new(Zlib::Inflate.inflate(compressed_message))
+        elsif @compressor_id == SNAPPY_BYTE
+          BSON::ByteBuffer.new(Snappy.inflate(compressed_message))
+        elsif @compressor_id == ZSTD_BYTE
+          BSON::ByteBuffer.new(Zstd.decompress(compressed_message))
+        end
+      end
+
       Registry.register(OP_CODE, self)
     end
   end

data/lib/mongo/protocol/message.rb

@@ -140,7 +140,13 @@ module Mongo
         self
       end
 
-      def maybe_decrypt(client)
+      # Possibly decrypt this message with libmongocrypt.
+      #
+      # @param [ Mongo::Operation::Context ] context The operation context.
+      #
+      # @return [ Mongo::Protocol::Msg ] The decrypted message, or the original
+      #   message if decryption was not possible or necessary.
+      def maybe_decrypt(context)
         # TODO determine if we should be decrypting data coming from pre-4.2
         # servers, potentially using legacy wire protocols. If so we need
         # to implement decryption for those wire protocols as our current
@@ -148,11 +154,23 @@ module Mongo
         self
       end
 
-      def maybe_encrypt(server, client)
+      # Possibly encrypt this message with libmongocrypt.
+      #
+      # @param [ Mongo::Server::Connection ] connection The connection on which
+      #   the operation is performed.
+      # @param [ Mongo::Operation::Context ] context The operation context.
+      #
+      # @return [ Mongo::Protocol::Msg ] The encrypted message, or the original
+      #   message if encryption was not possible or necessary.
+      def maybe_encrypt(connection, context)
         # Do nothing if the Message subclass has not implemented this method
         self
       end
 
+      def maybe_add_server_api(server_api)
+        raise Error::ServerApiNotSupported, "Server API parameters cannot be sent to pre-3.6 MongoDB servers. Please remove the :server_api parameter from Client options or use MongoDB 3.6 or newer"
+      end
+
       private def merge_sections
         cmd = if @sections.length > 1
           cmd = @sections.detect { |section| section[:type] == 0 }[:payload]

data/lib/mongo/protocol/msg.rb

@@ -199,15 +199,16 @@ module Mongo
       # represents one of the command types whitelisted by libmongocrypt and it
       # contains data that is required to be encrypted by a local or remote json schema.
       #
-      # @param [ Mongo::Client | nil ] client The client used to make the original
-      #   command. This client may have auto-encryption options specified.
+      # @param [ Mongo::Server::Connection ] connection The connection on which
+      #   the operation is performed.
+      # @param [ Mongo::Operation::Context ] context The operation context.
       #
       # @return [ Mongo::Protocol::Msg ] The encrypted message, or the original
       #   message if encryption was not possible or necessary.
-      def maybe_encrypt(connection, client)
+      def maybe_encrypt(connection, context)
         # TODO verify compression happens later, i.e. when this method runs
         # the message is not compressed.
-        if client && client.encrypter && client.encrypter.encrypt?
+        if context.encrypt?
           if connection.description.max_wire_version < 8
             raise Error::CryptError.new(
               "Cannot perform encryption against a MongoDB server older than " +
@@ -219,7 +220,7 @@ module Mongo
 
           db_name = @main_document[DATABASE_IDENTIFIER]
           cmd = merge_sections
-          enc_cmd = client.encrypter.encrypt(db_name, cmd)
+          enc_cmd = context.encrypter.encrypt(db_name, cmd)
           if cmd.key?('$db') && !enc_cmd.key?('$db')
             enc_cmd['$db'] = cmd['$db']
           end
@@ -237,15 +238,14 @@ module Mongo
       # types whitelisted by libmongocrypt and it contains data that is required
       # to be encrypted by a local or remote json schema.
       #
-      # @param [ Mongo::Client | nil ] client The client used to make the original
-      #   command. This client may have auto-encryption options specified.
+      # @param [ Mongo::Operation::Context ] context The operation context.
       #
-      # @return [ Mongo::Protocol::Msg ] The decryption message, or the original
+      # @return [ Mongo::Protocol::Msg ] The decrypted message, or the original
       #   message if decryption was not possible or necessary.
-      def maybe_decrypt(client)
-        if client && client.encrypter
+      def maybe_decrypt(context)
+        if context.decrypt?
           cmd = merge_sections
-          enc_cmd = client.encrypter.decrypt(cmd)
+          enc_cmd = context.encrypter.decrypt(cmd)
           Msg.new(@flags, @options, enc_cmd)
         else
           self
@@ -275,6 +275,31 @@ module Mongo
         num_inserts > 1  || num_updates > 1 || num_deletes > 1
       end
 
+      def maybe_add_server_api(server_api)
+        if @main_document[:getMore]
+          # getMore does not allow API parameters.
+          return self
+        end
+
+        conflicts = {}
+        %i(apiVersion apiStrict apiDeprecationErrors).each do |key|
+          if @main_document.key?(key)
+            conflicts[key] = @main_document[key]
+          end
+          if @main_document.key?(key.to_s)
+            conflicts[key] = @main_document[key.to_s]
+          end
+        end
+        unless conflicts.empty?
+          raise Error::ServerApiConflict, "The Client is configured with :server_api option but the operation provided the following conflicting parameters: #{conflicts.inspect}"
+        end
+
+        main_document = @main_document.merge(
+          Utils.transform_server_api(server_api)
+        )
+        Msg.new(@flags, @options, main_document, *@sequences)
+      end
+
       private
 
       # Validate that the documents in this message are all smaller than the