mongo 2.13.0 → 2.15.0.alpha

data/lib/mongo/protocol/msg.rb

@@ -146,7 +146,7 @@ module Mongo
       # @return [ BSON::ByteBuffer ] buffer containing the serialized message.
       #
       # @since 2.5.0
-      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil)
+      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil)
         validate_document_size!(max_bson_size)
 
         super
@@ -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

data/lib/mongo/protocol/query.rb

@@ -115,12 +115,48 @@ module Mongo
         compress_if_possible(selector.keys.first, compressor, zlib_compression_level)
       end
 
+      # Serializes message into bytes that can be sent on the wire.
+      #
+      # @param [ BSON::ByteBuffer ] buffer where the message should be inserted.
+      # @param [ Integer ] max_bson_size The maximum bson object size.
+      #
+      # @return [ BSON::ByteBuffer ] buffer containing the serialized message.
+      def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil)
+        validate_document_size!(max_bson_size)
+
+        super
+      end
+
       protected
 
       attr_reader :upconverter
 
       private
 
+      # Validate that the documents in this message are all smaller than the
+      # maxBsonObjectSize. If not, raise an exception.
+      def validate_document_size!(max_bson_size)
+        max_bson_size ||= Mongo::Server::ConnectionBase::DEFAULT_MAX_BSON_OBJECT_SIZE
+
+        documents = if @selector.key?(:documents)
+                      @selector[:documents]
+                    elsif @selector.key?(:deletes)
+                      @selector[:deletes]
+                    elsif @selector.key?(:updates)
+                      @selector[:updates]
+                    else
+                      []
+                    end
+
+        contains_too_large_document = documents.any? do |doc|
+          doc.to_bson.length > max_bson_size
+        end
+
+        if contains_too_large_document
+          raise Error::MaxBSONSize.new('The document exceeds maximum allowed BSON object size after serialization')
+        end
+      end
+
       # The operation code required to specify a Query message.
       # @return [Fixnum] the operation code.
       #

data/lib/mongo/query_cache.rb

@@ -0,0 +1,272 @@
+# Copyright (C) 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.
+# 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 QueryCache
+    class << self
+
+      # Set whether the cache is enabled.
+      #
+      # @example Set if the cache is enabled.
+      #   QueryCache.enabled = true
+      #
+      # @param [ true, false ] value The enabled value.
+      def enabled=(value)
+        Thread.current["[mongo]:query_cache:enabled"] = value
+      end
+
+      # Is the query cache enabled on the current thread?
+      #
+      # @example Is the query cache enabled?
+      #   QueryCache.enabled?
+      #
+      # @return [ true, false ] If the cache is enabled.
+      def enabled?
+        !!Thread.current["[mongo]:query_cache:enabled"]
+      end
+
+      # Execute the block while using the query cache.
+      #
+      # @example Execute with the cache.
+      #   QueryCache.cache { collection.find }
+      #
+      # @return [ Object ] The result of the block.
+      def cache
+        enabled = enabled?
+        self.enabled = true
+        begin
+          yield
+        ensure
+          self.enabled = enabled
+        end
+      end
+
+      # Execute the block with the query cache disabled.
+      #
+      # @example Execute without the cache.
+      #   QueryCache.uncached { collection.find }
+      #
+      # @return [ Object ] The result of the block.
+      def uncached
+        enabled = enabled?
+        self.enabled = false
+        begin
+          yield
+        ensure
+          self.enabled = enabled
+        end
+      end
+
+      # Get the cached queries.
+      #
+      # @example Get the cached queries from the current thread.
+      #   QueryCache.cache_table
+      #
+      # @return [ Hash ] The hash of cached queries.
+      private def cache_table
+        Thread.current["[mongo]:query_cache"] ||= {}
+      end
+
+      # Clear the query cache.
+      #
+      # @example Clear the cache.
+      #   QueryCache.clear
+      #
+      # @return [ nil ] Always nil.
+      def clear
+        Thread.current["[mongo]:query_cache"] = nil
+      end
+
+      # Clear the section of the query cache storing cursors with results
+      # from this namespace.
+      #
+      # @param [ String ] namespace The namespace to be cleared, in the format
+      #   "database.collection".
+      #
+      # @return [ nil ] Always nil.
+      #
+      # @api private
+      def clear_namespace(namespace)
+        cache_table.delete(namespace)
+        # The nil key is where cursors are stored that could potentially read from
+        # multiple collections. This key should be cleared on every write operation
+        # to prevent returning stale data.
+        cache_table.delete(nil)
+        nil
+      end
+
+      # Store a CachingCursor instance in the query cache associated with the
+      # specified query options.
+      #
+      # @param [ Mongo::CachingCursor ] cursor The CachingCursor instance to store.
+      #
+      # @option opts [ String | nil ] namespace The namespace of the query,
+      #   in the format "database_name.collection_name".
+      # @option opts [ Array, Hash ] selector The selector passed to the query.
+      #   For most queries, this will be a Hash, but for aggregations, this
+      #   will be an Array representing the aggregation pipeline. May not be nil.
+      # @option opts [ Integer | nil ] skip The skip value of the query.
+      # @option opts [ Hash | nil ] sort The order of the query results
+      #   (e.g. { name: -1 }).
+      # @option opts [ Integer | nil ] limit The limit value of the query.
+      # @option opts [ Hash | nil ] projection The projection of the query
+      #   results (e.g. { name: 1 }).
+      # @option opts [ Hash | nil ] collation The collation of the query
+      #   (e.g. { "locale" => "fr_CA" }).
+      # @option opts [ Hash | nil ] read_concern The read concern of the query
+      #   (e.g. { level: :majority }).
+      # @option opts [ Hash | nil ] read_preference The read preference of
+      #   the query (e.g. { mode: :secondary }).
+      # @option opts [ Boolean | nil ] multi_collection Whether the query
+      #   results could potentially come from multiple collections. When true,
+      #   these results will be stored under the nil namespace key and cleared
+      #   on every write command.
+      #
+      # @return [ true ] Always true.
+      #
+      # @api private
+      def set(cursor, **opts)
+        _cache_key = cache_key(**opts)
+        _namespace_key = namespace_key(**opts)
+
+        cache_table[_namespace_key] ||= {}
+        cache_table[_namespace_key][_cache_key] = cursor
+
+        true
+      end
+
+      # For the given query options, retrieve a cached cursor that can be used
+      # to obtain the correct query results, if one exists in the cache.
+      #
+      # @option opts [ String | nil ] namespace The namespace of the query,
+      #   in the format "database_name.collection_name".
+      # @option opts [ Array, Hash ] selector The selector passed to the query.
+      #   For most queries, this will be a Hash, but for aggregations, this
+      #   will be an Array representing the aggregation pipeline. May not be nil.
+      # @option opts [ Integer | nil ] skip The skip value of the query.
+      # @option opts [ Hash | nil ] sort The order of the query results
+      #   (e.g. { name: -1 }).
+      # @option opts [ Integer | nil ] limit The limit value of the query.
+      # @option opts [ Hash | nil ] projection The projection of the query
+      #   results (e.g. { name: 1 }).
+      # @option opts [ Hash | nil ] collation The collation of the query
+      #   (e.g. { "locale" => "fr_CA" }).
+      # @option opts [ Hash | nil ] read_concern The read concern of the query
+      #   (e.g. { level: :majority }).
+      # @option opts [ Hash | nil ] read_preference The read preference of
+      #   the query (e.g. { mode: :secondary }).
+      # @option opts [ Boolean | nil ] multi_collection Whether the query
+      #   results could potentially come from multiple collections. When true,
+      #   these results will be stored under the nil namespace key and cleared
+      #   on every write command.
+      #
+      # @return [ Mongo::CachingCursor | nil ] Returns a CachingCursor if one
+      #   exists in the query cache, otherwise returns nil.
+      #
+      # @api private
+      def get(**opts)
+        limit = opts[:limit]
+        _namespace_key = namespace_key(**opts)
+        _cache_key = cache_key(**opts)
+
+        namespace_hash = cache_table[_namespace_key]
+        return nil unless namespace_hash
+
+        caching_cursor = namespace_hash[_cache_key]
+        return nil unless caching_cursor
+
+        caching_cursor_limit = caching_cursor.view.limit
+
+        # There are two scenarios in which a caching cursor could fulfill the
+        # query:
+        # 1. The query has a limit, and the stored cursor has no limit or
+        #    a larger limit.
+        # 2. The query has no limit and the stored cursor has no limit.
+        #
+        # Otherwise, return nil because the stored cursor will not satisfy
+        # the query.
+        if limit && (caching_cursor_limit.nil? || caching_cursor_limit >= limit)
+          caching_cursor
+        elsif limit.nil? && caching_cursor_limit.nil?
+          caching_cursor
+        else
+          nil
+        end
+      end
+
+      private
+
+      def cache_key(**opts)
+        unless opts[:namespace]
+          raise ArgumentError.new("Cannot generate cache key without namespace")
+        end
+        unless opts[:selector]
+          raise ArgumentError.new("Cannot generate cache key without selector")
+        end
+
+        [
+          opts[:namespace],
+          opts[:selector],
+          opts[:skip],
+          opts[:sort],
+          opts[:projection],
+          opts[:collation],
+          opts[:read_concern],
+          opts[:read_preference]
+        ]
+      end
+
+      # If the cached results can come from multiple collections, store this
+      # cursor under the nil namespace to be cleared on every write operation.
+      # Otherwise, store it under the specified namespace.
+      def namespace_key(**opts)
+        if opts[:multi_collection]
+          nil
+        else
+          opts[:namespace]
+        end
+      end
+    end
+
+    # Rack middleware that activates the query cache for each request.
+    class Middleware
+
+      # Instantiate the middleware.
+      #
+      # @example Create the new middleware.
+      #   Middleware.new(app)
+      #
+      # @param [ Object ] app The rack application stack.
+      def initialize(app)
+        @app = app
+      end
+
+      # Enable query cache and execute the request.
+      #
+      # @example Execute the request.
+      #   middleware.call(env)
+      #
+      # @param [ Object ] env The environment.
+      #
+      # @return [ Object ] The result of the call.
+      def call(env)
+        QueryCache.cache do
+          @app.call(env)
+        end
+      ensure
+        QueryCache.clear
+      end
+    end
+  end
+end

data/lib/mongo/retryable.rb

@@ -59,7 +59,14 @@ module Mongo
     def read_with_retry_cursor(session, server_selector, view, &block)
       read_with_retry(session, server_selector) do |server|
         result = yield server
-        Cursor.new(view, result, server, session: session)
+
+        # RUBY-2367: This will be updated to allow the query cache to
+        # cache cursors with multi-batch results.
+        if QueryCache.enabled? && !view.collection.system_collection?
+          CachingCursor.new(view, result, server, session: session)
+        else
+          Cursor.new(view, result, server, session: session)
+        end
       end
     end
 
@@ -470,7 +477,7 @@ module Mongo
       else
         "Retry"
       end
-      Logger.logger.warn "#{message} due to: #{e.class.name} #{e.message}"
+      Logger.logger.warn "#{message} due to: #{e.class.name}: #{e.message}"
     end
 
     # Retry writes on MMAPv1 should raise an actionable error; append actionable

data/lib/mongo/server.rb

@@ -71,7 +71,8 @@ module Mongo
       unless options[:monitoring_io] == false
         @monitor = Monitor.new(self, event_listeners, monitoring,
           options.merge(
-            app_metadata: Monitor::AppMetadata.new(cluster.options),
+            app_metadata: cluster.monitor_app_metadata,
+            push_monitor_app_metadata: cluster.push_monitor_app_metadata,
             heartbeat_interval: cluster.heartbeat_interval,
         ))
         unless _monitor == false
@@ -172,6 +173,11 @@ module Mongo
                    :cluster_time,
                    :update_cluster_time
 
+    # @api private
+    def_delegators :cluster,
+                   :monitor_app_metadata,
+                   :push_monitor_app_metadata
+
     def_delegators :features,
                    :check_driver_support!
 
@@ -272,19 +278,6 @@ module Mongo
       @connected
     end
 
-    # When the server is flagged for garbage collection, stop the monitor
-    # thread.
-    #
-    # @example Finalize the object.
-    #   Server.finalize(monitor)
-    #
-    # @param [ Server::Monitor ] monitor The server monitor.
-    #
-    # @since 2.2.0
-    def self.finalize(monitor)
-      proc { monitor.stop! }
-    end
-
     # Start monitoring the server.
     #
     # Used internally by the driver to add a server to a cluster
@@ -297,7 +290,6 @@ module Mongo
         Monitoring::Event::ServerOpening.new(address, cluster.topology)
       )
       if options[:monitoring_io] != false
-        ObjectSpace.define_finalizer(self, self.class.finalize(monitor))
         monitor.run!
       end
     end
@@ -311,7 +303,7 @@ module Mongo
     #
     # @since 2.0.0
     def inspect
-      "#<Mongo::Server:0x#{object_id} address=#{address.host}:#{address.port}>"
+      "#<Mongo::Server:0x#{object_id} address=#{address.host}:#{address.port} #{status}>"
     end
 
     # @return [ String ] String representing server status (e.g. PRIMARY).
@@ -352,6 +344,10 @@ module Mongo
         status += " replica_set=#{replica_set_name}"
       end
 
+      unless monitor&.running?
+        status += " NO-MONITORING"
+      end
+
       if @pool
         status += " pool=#{@pool.summary}"
       end