mongo 2.13.0.beta1 → 2.14.0

data/lib/mongo/protocol/serializers.rb

@@ -440,12 +440,15 @@ module Mongo
         # Deserializes bytes from the byte buffer.
         #
         # @param [ BSON::ByteBuffer ] buffer Buffer containing the value to read.
-        # @param [ Integer ] num_bytes Number of bytes to read.
+        # @param [ Hash ] options The method options.
+        #
+        # @option options [ Integer ] num_bytes Number of bytes to read.
         #
         # @return [ String ] The bytes.
         #
         # @since 2.5.0
-        def self.deserialize(buffer, num_bytes = nil)
+        def self.deserialize(buffer, options = {})
+          num_bytes = options[:num_bytes]
           buffer.get_bytes(num_bytes || buffer.length)
         end
       end

data/lib/mongo/query_cache.rb

@@ -0,0 +1,242 @@
+# 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
+  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
 

data/lib/mongo/server.rb

@@ -64,7 +64,7 @@ module Mongo
       @connection_id_gen = Class.new do
         include Id
       end
-      @scan_semaphore = Semaphore.new
+      @scan_semaphore = DistinguishingSemaphore.new
       @round_trip_time_averager = RoundTripTimeAverager.new
       @description = Description.new(address, {})
       @last_scan = nil
@@ -311,7 +311,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 +352,10 @@ module Mongo
         status += " replica_set=#{replica_set_name}"
       end
 
+      unless monitor&.running?
+        status += " NO-MONITORING"
+      end
+
       if @pool
         status += " pool=#{@pool.summary}"
       end
@@ -432,7 +436,7 @@ module Mongo
     def handle_handshake_failure!
       yield
     rescue Mongo::Error::SocketError, Mongo::Error::SocketTimeoutError => e
-      unknown!(generation: e.generation)
+      unknown!(generation: e.generation, stop_push_monitor: true)
       raise
     end
 
@@ -455,7 +459,7 @@ module Mongo
       raise
     rescue Mongo::Error::SocketError => e
       # non-timeout network error
-      unknown!(generation: e.generation)
+      unknown!(generation: e.generation, stop_push_monitor: true)
       raise
     rescue Auth::Unauthorized
       # auth error, keep server description and topology as they are
@@ -503,6 +507,8 @@ module Mongo
     #   on 4.2+ servers).
     # @option options [ TopologyVersion ] :topology_version Topology version
     #   of the error response that is causing the server to be marked unknown.
+    # @option options [ true | false ] :stop_push_monitor Whether to stop
+    #   the PushMonitor associated with the server, if any.
     #
     # @since 2.4.0, SDAM events are sent as of version 2.7.0
     def unknown!(options = {})
@@ -516,6 +522,10 @@ module Mongo
         return
       end
 
+      if options[:stop_push_monitor]
+        monitor&.stop_push_monitor!
+      end
+
       # SDAM flow will update description on the server without in-place
       # mutations and invoke SDAM transitions as needed.
       config = {}
@@ -562,3 +572,4 @@ require 'mongo/server/context'
 require 'mongo/server/description'
 require 'mongo/server/monitor'
 require 'mongo/server/round_trip_time_averager'
+require 'mongo/server/push_monitor'

data/lib/mongo/server/app_metadata.rb

@@ -65,12 +65,17 @@ module Mongo
       #   the metadata printed to the mongod logs upon establishing a connection
       #   in server versions >= 3.4.
       # @option options [ String ] :user The user name.
+      # @option options [ Array<Hash> ] :wrapping_libraries Information about
+      #   libraries such as ODMs that are wrapping the driver. Specify the
+      #   lower level libraries first. Allowed hash keys: :name, :version,
+      #   :platform.
       #
       # @since 2.4.0
       def initialize(options)
         @app_name = options[:app_name].to_s if options[:app_name]
         @platform = options[:platform]
         @compressors = options[:compressors] || []
+        @wrapping_libraries = options[:wrapping_libraries]
 
         if options[:user] && !options[:auth_mech]
           auth_db = options[:auth_source] || 'admin'
@@ -78,6 +83,10 @@ module Mongo
         end
       end
 
+      # @return [ Array<Hash> | nil ] Information about libraries wrapping
+      #   the driver.
+      attr_reader :wrapping_libraries
+
       # Get the bytes of the ismaster message including this metadata.
       #
       # @api private
@@ -140,9 +149,17 @@ module Mongo
       end
 
       def driver_doc
+        names = [DRIVER_NAME]
+        versions = [Mongo::VERSION]
+        if wrapping_libraries
+          wrapping_libraries.each do |library|
+            names << library[:name] || ''
+            versions << library[:version] || ''
+          end
+        end
         {
-          name: DRIVER_NAME,
-          version: Mongo::VERSION
+          name: names.join('|'),
+          version: versions.join('|'),
         }
       end
 
@@ -175,12 +192,19 @@ module Mongo
           ruby_versions = ["Ruby #{RUBY_VERSION}"]
           platforms = [RUBY_PLATFORM]
         end
-        [
+        platform = [
           @platform,
           *ruby_versions,
           *platforms,
           RbConfig::CONFIG['build'],
         ].compact.join(', ')
+        platforms = [platform]
+        if wrapping_libraries
+          wrapping_libraries.each do |library|
+            platforms << library[:platform] || ''
+          end
+        end
+        platforms.join('|')
       end
     end
   end

data/lib/mongo/server/connection.rb

@@ -163,7 +163,7 @@ module Mongo
         unless @socket
           # When @socket is assigned, the socket should have handshaken and
           # authenticated and be usable.
-          @socket, @description = do_connect
+          @socket, @description, @compressor = do_connect
 
           publish_cmap_event(
             Monitoring::Event::Cmap::ConnectionReady.new(address, id)
@@ -194,7 +194,7 @@ module Mongo
           raise
         end
 
-        [socket, pending_connection.description]
+        [socket, pending_connection.description, pending_connection.compressor]
       end
 
       # Disconnect the connection.
@@ -220,7 +220,7 @@ module Mongo
         @auth_mechanism = nil
         @last_checkin = nil
         if socket
-          socket.close
+          socket.close rescue nil
           @socket = nil
         end
         @closed = true
@@ -306,7 +306,7 @@ module Mongo
           yield
         rescue Error::SocketError => e
           @error = e
-          @server.unknown!(generation: e.generation)
+          @server.unknown!(generation: e.generation, stop_push_monitor: true)
           raise
         rescue Error::SocketTimeoutError => e
           @error = e