mongoid 5.4.1 → 7.4.0

data/lib/mongoid/clients/factory.rb

@@ -1,9 +1,10 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Mongoid
   module Clients
     module Factory
       extend self
+      extend Loggable
 
       # Create a new client given the named configuration. If no name is
       # provided, return a new client with the default configuration. If a
@@ -11,15 +12,13 @@ module Mongoid
       # raised.
       #
       # @example Create the client.
-      #   Factory.create(:secondary)
+      #   Factory.create(:analytics)
       #
-      # @param [ String, Symbol ] name The named client configuration.
+      # @param [ String | Symbol ] name The named client configuration.
       #
       # @raise [ Errors::NoClientConfig ] If no config could be found.
       #
       # @return [ Mongo::Client ] The new client.
-      #
-      # @since 3.0.0
       def create(name = nil)
         return default unless name
         config = Mongoid.clients[name]
@@ -36,8 +35,6 @@ module Mongoid
       #   found.
       #
       # @return [ Mongo::Client ] The default client.
-      #
-      # @since 3.0.0
       def default
         create_client(Mongoid.clients[:default])
       end
@@ -54,26 +51,54 @@ module Mongoid
       # @param [ Hash ] configuration The client config.
       #
       # @return [ Mongo::Client ] The client.
-      #
-      # @since 3.0.0
       def create_client(configuration)
         raise Errors::NoClientsConfig.new unless configuration
-        if configuration[:uri]
-          Mongo::Client.new(configuration[:uri], options(configuration))
+        config = configuration.dup
+        uri = config.delete(:uri)
+        database = config.delete(:database)
+        hosts = config.delete(:hosts)
+        opts = config.delete(:options) || {}
+        unless config.empty?
+          default_logger.warn("Unknown config options detected: #{config}.")
+        end
+        if uri
+          Mongo::Client.new(uri, options(opts))
         else
           Mongo::Client.new(
-            configuration[:hosts],
-            options(configuration).merge(database: configuration[:database])
+            hosts,
+            options(opts).merge(database: database)
           )
         end
       end
 
-      def options(configuration)
-        config = configuration.dup
-        options = config.delete(:options) || {}
+      MONGOID_WRAPPING_LIBRARY = {
+        name: 'Mongoid',
+        version: VERSION,
+      }.freeze
+
+      def driver_version
+        Mongo::VERSION.split('.')[0...2].map(&:to_i)
+      end
+
+      # Prepare options for Mongo::Client based on Mongoid client configuration.
+      #
+      # @param [ Hash ] opts Parameters from options section of Mongoid client configuration.
+      # @return [ Hash ] Options that should be passed to Mongo::Client constructor.
+      #
+      # @api private
+      def options(opts)
+        options = opts.dup
         options[:platform] = PLATFORM_DETAILS
         options[:app_name] = Mongoid::Config.app_name if Mongoid::Config.app_name
-        options.reject{ |k, v| k == :hosts }.to_hash.symbolize_keys!
+        if (driver_version <=> [2, 13]) >= 0
+          wrap_lib = if options[:wrapping_libraries]
+            [MONGOID_WRAPPING_LIBRARY] + options[:wrapping_libraries]
+          else
+            [MONGOID_WRAPPING_LIBRARY]
+          end
+          options[:wrapping_libraries] = wrap_lib
+        end
+        options.reject{ |k, _v| k == :hosts }.to_hash.symbolize_keys!
       end
     end
   end

data/lib/mongoid/clients/options.rb

@@ -1,301 +1,105 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Clients
     module Options
       extend ActiveSupport::Concern
 
-      # Tell the next persistence operation to store in a specific collection,
-      # database or client.
+      # Change the persistence context for this object during the block.
       #
       # @example Save the current document to a different collection.
-      #   model.with(collection: "secondary").save
-      #
-      # @example Save the current document to a different database.
-      #   model.with(database: "secondary").save
-      #
-      # @example Save the current document to a different client.
-      #   model.with(client: "replica_set").save
-      #
-      # @example Save with a combination of options.
-      #   model.with(client: "sharded", database: "secondary").save
-      #
-      # @note This method will instantiate a new client under the covers and
-      #   can be expensive. It is also recommended that the user manually
-      #   closes the extra client after using it, otherwise an excessive amount
-      #   of connections to the server will be eventually opened.
-      #
-      # @param [ Hash ] options The storage options.
+      #   model.with(collection: "bands") do |m|
+      #     m.save
+      #   end
       #
-      # @option options [ String, Symbol ] :collection The collection name.
-      # @option options [ String, Symbol ] :database The database name.
-      # @option options [ String, Symbol ] :client The client name.
+      # @param [ Hash, Mongoid::PersistenceContext ] options_or_context
+      #   The storage options or a persistence context.
       #
-      # @return [ Document ] The current document.
-      #
-      # @since 3.0.0
-      def with(options)
-        @persistence_options = options
-        self
-      end
-
-      def persistence_options
-        @persistence_options
+      # @option options [ String | Symbol ] :collection The collection name.
+      # @option options [ String | Symbol ] :database The database name.
+      # @option options [ String | Symbol ] :client The client name.
+      def with(options_or_context, &block)
+        original_context = PersistenceContext.get(self)
+        original_cluster = persistence_context.cluster
+        set_persistence_context(options_or_context)
+        yield self
+      ensure
+        clear_persistence_context(original_cluster, original_context)
       end
 
-      def mongo_client
-        tmp = persistence_options
-        if (opts = tmp && !tmp.empty? && tmp.dup)
-          if opts[:client]
-            client = Clients.with_name(opts[:client])
-          else
-            client = Clients.with_name(self.class.client_name)
-            client = client.use(self.class.database_name)
-          end
-          client.with(opts.reject{ |k, v| k == :collection || k == :client })
-        end
+      def collection(parent = nil)
+        persistence_context.collection(parent)
       end
 
       def collection_name
-        if persistence_options && v = persistence_options[:collection]
-          return v.to_sym
-        end
+        persistence_context.collection_name
       end
 
-      module Threaded
-
-        # Get the persistence options for the current thread.
-        #
-        # @example Get the persistence options.
-        #   Threaded.persistence_options(Band)
-        #
-        # @param [ Class ] klass The model class.
-        #
-        # @return [ Hash ] The current persistence options.
-        #
-        # @since 4.0.0
-        def persistence_options(klass = self)
-          Thread.current["[mongoid][#{klass}]:persistence-options"]
-        end
-
-        # Get the client with special options for the current thread.
-        #
-        # @example Get the client with options.
-        #   Threaded.client_with_options(Band)
-        #
-        # @param [ Class ] klass The model class.
-        #
-        # @return [ Mongo::Client ] The client.
-        #
-        # @since 5.1.0
-        def client_with_options(klass = self)
-          Thread.current["[mongoid][#{klass}]:mongo-client"]
-        end
-
-        private
-        # Set the persistence options on the current thread.
-        #
-        # @api private
-        #
-        # @example Set the persistence options.
-        #   Threaded.set_persistence_options(Band, { write: { w: 3 }})
-        #
-        # @param [ Class ] klass The model class.
-        # @param [ Hash ] options The persistence options.
-        #
-        # @return [ Hash ] The persistence options.
-        #
-        # @since 4.0.0
-        def set_persistence_options(klass, options)
-          Thread.current["[mongoid][#{klass}]:persistence-options"] = options
-        end
-
-        # Unset the persistence options on the current thread.
-        #
-        # @api private
-        #
-        # @example Unset the persistence options.
-        #   Threaded.unset_persistence_options(Band)
-        #
-        # @param [ Class ] klass The model class.
-        #
-        # @return [ nil ] nil.
-        #
-        # @since 5.1.0
-        def unset_persistence_options(klass)
-          Thread.current["[mongoid][#{klass}]:persistence-options"] = nil
-        end
+      def mongo_client
+        persistence_context.client
+      end
 
-        # Set the persistence options and client with those options on the current thread.
-        # Note that a client will only be set if its cluster differs from the cluster of the
-        # original client.
-        #
-        # @api private
-        #
-        # @example Set the persistence options and client with those options on the current thread.
-        #   Threaded.set_options(Band, { write: { w: 3 }})
-        #
-        # @param [ Class ] klass The model class.
-        # @param [ Mongo::Client ] options The options.
-        #
-        # @return [ Mongo::Client, nil ] The client or nil if the cluster does not change.
-        #
-        # @since 5.1.0
-        def set_options(klass, options)
-          original_cluster = mongo_client.cluster
-          set_persistence_options(klass, options)
-          m = mongo_client
-          set_client_with_options(klass, m) unless m.cluster.equal?(original_cluster)
-        end
+      def persistence_context
+        PersistenceContext.get(self) ||
+            PersistenceContext.get(self.class) ||
+            PersistenceContext.new(self.class)
+      end
 
-        # Set the client with special options on the current thread.
-        #
-        # @api private
-        #
-        # @example Set the client with options.
-        #   Threaded.set_client_with_options(Band, client)
-        #
-        # @param [ Class ] klass The model class.
-        # @param [ Mongo::Client ] client The client with options.
-        #
-        # @return [ Mongo::Client ] The client.
-        #
-        # @since 5.1.0
-        def set_client_with_options(klass, client)
-          Thread.current["[mongoid][#{klass}]:mongo-client"] = client
-        end
+      private
 
-        # Unset the client with special options on the current thread.
-        #
-        # @api private
-        #
-        # @example Unset the client with options.
-        #   Threaded.unset_client_with_options(Band)
-        #
-        # @param [ Class ] klass The model class.
-        #
-        # @return [ nil ] nil.
-        #
-        # @since 5.1.0
-        def unset_client_with_options(klass)
-          if client = Thread.current["[mongoid][#{klass}]:mongo-client"]
-            client.close
-            Thread.current["[mongoid][#{klass}]:mongo-client"] = nil
-          end
-        end
+      def set_persistence_context(options_or_context)
+        PersistenceContext.set(self, options_or_context)
+      end
 
-        # Unset the persistence options and client with special options on the current thread.
-        #
-        # @api private
-        #
-        # @example Unset the persistence options and client with options.
-        #   Threaded.unset_options(Band)
-        #
-        # @param [ Class ] klass The model class.
-        #
-        # @return [ nil ] nil.
-        #
-        # @since 5.1.0
-        def unset_options(klass)
-          unset_persistence_options(klass)
-          unset_client_with_options(klass)
-        end
+      def clear_persistence_context(original_cluster = nil, context = nil)
+        PersistenceContext.clear(self, original_cluster, context)
       end
 
       module ClassMethods
-        include Threaded
 
         def client_name
-          if persistence_options && v = persistence_options[:client]
-            return v.to_sym
-          end
-          super
+          persistence_context.client_name
         end
 
         def collection_name
-          if persistence_options && v = persistence_options[:collection]
-            return v.to_sym
-          end
-          super
+          persistence_context.collection_name
         end
 
         def database_name
-          if persistence_options && v = persistence_options[:database]
-            return v.to_sym
-          end
-          super
+          persistence_context.database_name
         end
 
-        # Tell the next persistence operation to store in a specific collection,
-        # database or client.
-        #
-        # @example Create a document in a different collection.
-        #   Model.with(collection: "secondary").create(name: "test")
-        #
-        # @example Create a document in a different database.
-        #   Model.with(database: "secondary").create(name: "test")
-        #
-        # @example Create a document in a different client.
-        #   Model.with(client: "secondary").create(name: "test")
-        #
-        # @example Create with a combination of options.
-        #   Model.with(client: "sharded", database: "secondary").create
-        #
-        # @param [ Hash ] options The storage options.
-        #
-        # @option options [ String, Symbol ] :collection The collection name.
-        # @option options [ String, Symbol ] :database The database name.
-        # @option options [ String, Symbol ] :client The client name.
-        #
-        # @return [ Class ] The model class.
-        #
-        # @since 3.0.0
-        def with(options)
-          if block_given?
-            set_options(self, options)
-            result = yield self
-            unset_options(self)
-            result
-          else
-            Proxy.new(self, (persistence_options || {}).merge(options))
-          end
-        end
-      end
-
-      class Proxy < BasicObject
-        include Threaded
-
-        undef_method :==
-
-        def initialize(target, options)
-          @target = target
-          @options = options
+        def collection
+          persistence_context.collection
         end
 
-        def persistence_options
-          @options
+        def mongo_client
+          persistence_context.client
         end
 
-        def respond_to?(*args)
-          @target.respond_to?(*args)
-        end
-
-        def method_missing(name, *args, &block)
-          set_persistence_options(@target, @options)
-          ret = @target.send(name, *args, &block)
-          if Mongoid::Criteria == ret.class
-            ret.with @options
-          end
-          ret
+        # Change the persistence context for this class during the block.
+        #
+        # @example Save the current document to a different collection.
+        #   Model.with(collection: "bands") do |m|
+        #     m.create
+        #   end
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String | Symbol ] :collection The collection name.
+        # @option options [ String | Symbol ] :database The database name.
+        # @option options [ String | Symbol ] :client The client name.
+        def with(options, &block)
+          original_context = PersistenceContext.get(self)
+          original_cluster = persistence_context.cluster
+          PersistenceContext.set(self, options)
+          yield self
         ensure
-          unset_persistence_options(@target)
-        end
-
-        def send(symbol, *args)
-          __send__(symbol, *args)
+          PersistenceContext.clear(self, original_cluster, original_context)
         end
 
-        def self.const_missing(name)
-          ::Object.const_get(name)
+        def persistence_context
+          PersistenceContext.get(self) || PersistenceContext.new(self)
         end
       end
     end

data/lib/mongoid/clients/sessions.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+
+    # Encapsulates behavior for getting a session from the client of a model class or instance,
+    # setting the session on the current thread, and yielding to a block.
+    # The session will be closed after the block completes or raises an error.
+    module Sessions
+
+      # Execute a block within the context of a session.
+      #
+      # @example Execute some operations in the context of a session.
+      #   band.with_session(causal_consistency: true) do
+      #     band.records << Record.create
+      #     band.name = 'FKA Twigs'
+      #     band.save
+      #     band.reload
+      #   end
+      #
+      # @param [ Hash ] options The session options. Please see the driver
+      #   documentation for the available session options.
+      #
+      # @note You cannot do any operations in the block using models or objects
+      #   that use a different client; the block will execute all operations
+      #   in the context of the implicit session and operations on any models using
+      #   another client will fail. For example, if you set a client using store_in on a
+      #   particular model and execute an operation on it in the session context block,
+      #   that operation can't use the block's session and an error will be raised.
+      #   An error will also be raised if sessions are nested.
+      #
+      # @raise [ Errors::InvalidSessionUse ] If an operation is attempted on a model using another
+      #   client from which the session was started or if sessions are nested.
+      #
+      # @return [ Object ] The result of calling the block.
+      #
+      # @yieldparam [ Mongo::Session ] The session being used for the block.
+      def with_session(options = {})
+        if Threaded.get_session
+          raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting)
+        end
+        session = persistence_context.client.start_session(options)
+        Threaded.set_session(session)
+        yield(session)
+      rescue Mongo::Error::InvalidSession => ex
+        if
+          # Driver 2.13.0+
+          defined?(Mongo::Error::SessionsNotSupported) &&
+            Mongo::Error::SessionsNotSupported === ex ||
+          # Legacy drivers
+          ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
+        then
+          raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
+        end
+        raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
+      ensure
+        Threaded.clear_session
+      end
+
+      private
+
+      def _session
+        Threaded.get_session
+      end
+
+      module ClassMethods
+
+        # Execute a block within the context of a session.
+        #
+        # @example Execute some operations in the context of a session.
+        #   Band.with_session(causal_consistency: true) do
+        #     band = Band.create
+        #     band.records << Record.new
+        #     band.save
+        #     band.reload.records
+        #   end
+        #
+        # @param [ Hash ] options The session options. Please see the driver
+        #   documentation for the available session options.
+        #
+        # @note You cannot do any operations in the block using models or objects
+        #   that use a different client; the block will execute all operations
+        #   in the context of the implicit session and operations on any models using
+        #   another client will fail. For example, if you set a client using store_in on a
+        #   particular model and execute an operation on it in the session context block,
+        #   that operation can't use the block's session and an error will be raised.
+        #   You also cannot nest sessions.
+        #
+        # @raise [ Errors::InvalidSessionUse ] If an operation is attempted on a model using another
+        #   client from which the session was started or if sessions are nested.
+        #
+        # @return [ Object ] The result of calling the block.
+        #
+        # @yieldparam [ Mongo::Session ] The session being used for the block.
+        def with_session(options = {})
+          if Threaded.get_session
+            raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting)
+          end
+          session = persistence_context.client.start_session(options)
+          Threaded.set_session(session)
+          yield(session)
+        rescue Mongo::Error::InvalidSession => ex
+          if
+            # Driver 2.13.0+
+            defined?(Mongo::Error::SessionsNotSupported) &&
+              Mongo::Error::SessionsNotSupported === ex ||
+            # Legacy drivers
+            ex.message == Mongo::Session::SESSIONS_NOT_SUPPORTED
+          then
+            raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
+          end
+          raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
+        ensure
+          Threaded.clear_session
+        end
+
+        private
+
+        def _session
+          Threaded.get_session
+        end
+      end
+    end
+  end
+end