mongoid 6.3.0 → 6.4.0

data/lib/mongoid/persistable/upsertable.rb

@@ -21,7 +21,8 @@ module Mongoid
       # @since 3.0.0
       def upsert(options = {})
         prepare_upsert(options) do
-          collection.find(atomic_selector).update_one(as_attributes, upsert: true)
+          collection.find(atomic_selector).update_one(
+              as_attributes, upsert: true, session: session)
         end
       end
 

data/lib/mongoid/relations/embedded/batchable.rb

@@ -38,7 +38,8 @@ module Mongoid
           pre_process_batch_remove(docs, :delete)
           unless docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$unset" => { path => true })
+              positionally(selector, "$unset" => { path => true }),
+              session: session
             )
             post_process_batch_remove(docs, :delete)
           end
@@ -58,7 +59,8 @@ module Mongoid
           removals = pre_process_batch_remove(docs, method)
           if !docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$pullAll" => { path => removals })
+              positionally(selector, "$pullAll" => { path => removals }),
+              session: session
             )
             post_process_batch_remove(docs, method)
           end
@@ -133,7 +135,9 @@ module Mongoid
           inserts = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$set' => { path => inserts }))
+                positionally(selector, '$set' => { path => inserts }),
+                session: session
+            )
             post_process_batch_insert(docs)
           end
           inserts
@@ -156,7 +160,9 @@ module Mongoid
           pushes = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$push' => { path => { '$each' => pushes } }))
+                positionally(selector, '$push' => { path => { '$each' => pushes } }),
+                session: session
+            )
             post_process_batch_insert(docs)
           end
           pushes

data/lib/mongoid/relations/many.rb

@@ -213,6 +213,10 @@ module Mongoid
 
       private
 
+      def session
+        base.send(:session)
+      end
+
       # Find the first object given the supplied attributes or create/initialize it.
       #
       # @example Find or create|initialize.

data/lib/mongoid/relations/referenced/many.rb

@@ -477,7 +477,7 @@ module Mongoid
         # @since 3.0.0
         def persist_delayed(docs, inserts)
           unless docs.empty?
-            collection.insert_many(inserts)
+            collection.insert_many(inserts, session: session)
             docs.each do |doc|
               doc.new_record = false
               doc.run_after_callbacks(:create, :save)

data/lib/mongoid/relations/touchable.rb

@@ -31,7 +31,7 @@ module Mongoid
         touches = touch_atomic_updates(field)
         unless touches["$set"].blank?
           selector = atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, touches))
+          _root.collection.find(selector).update_one(positionally(selector, touches), session: session)
         end
         run_callbacks(:touch)
         true

data/lib/mongoid/reloadable.rb

@@ -58,7 +58,7 @@ module Mongoid
     #
     # @since 2.3.2
     def reload_root_document
-      {}.merge(collection.find(_id: _id).read(mode: :primary).first || {})
+      {}.merge(collection.find({ _id: _id }, session: session).read(mode: :primary).first || {})
     end
 
     # Reload the embedded document.

data/lib/mongoid/tasks/database.rb

@@ -44,7 +44,7 @@ module Mongoid
         models.each do |model|
           unless model.embedded?
             begin
-              model.collection.indexes.each do |index|
+              model.collection.indexes(session: model.send(:session)).each do |index|
                 # ignore default index
                 unless index['name'] == '_id_'
                   key = index['key'].symbolize_keys
@@ -77,7 +77,7 @@ module Mongoid
           indexes.each do |index|
             key = index['key'].symbolize_keys
             collection = model.collection
-            collection.indexes.drop_one(key)
+            collection.indexes(session: model.send(:session)).drop_one(key)
             logger.info(
               "MONGOID: Removed index '#{index['name']}' on collection " +
               "'#{collection.name}' in database '#{collection.database.name}'."
@@ -107,6 +107,7 @@ module Mongoid
       end
 
       private
+
       def logger
         Mongoid.logger
       end

data/lib/mongoid/threaded.rb

@@ -325,5 +325,43 @@ module Mongoid
     def validations_for(klass)
       validations[klass] ||= []
     end
+
+    # Cache a session for this thread.
+    #
+    # @example Save a session for this thread.
+    #   Threaded.set_session(session)
+    #
+    # @param [ Mongo::Session ] session The session to save.
+    #
+    # @since 6.4.0
+    def set_session(session)
+      Thread.current[:session] = session
+    end
+
+    # Get the cached session for this thread.
+    #
+    # @example Get the session for this thread.
+    #   Threaded.get_session
+    #
+    # @return [ Mongo::Session, nil ] The session cached on this thread or nil.
+    #
+    # @since 6.4.0
+    def get_session
+      Thread.current[:session]
+    end
+
+    # Clear the cached session for this thread.
+    #
+    # @example Clear this thread's session.
+    #   Threaded.clear_session
+    #
+    # @return [ nil ]
+    #
+    # @since 6.4.0
+    def clear_session
+      session = get_session
+      session.end_session if session
+      Thread.current[:session] = nil
+    end
   end
 end

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "6.3.0"
+  VERSION = "6.4.0"
 end

data/spec/mongoid/attributes/nested_spec.rb

@@ -205,6 +205,10 @@ describe Mongoid::Attributes::Nested do
         Post.accepts_nested_attributes_for :person
       end
 
+      after do
+        Post.reset_callbacks(:save)
+      end
+
       let(:post) do
         Post.new(person_attributes: { title: "Sir" })
       end

data/spec/mongoid/clients/sessions_spec.rb

@@ -0,0 +1,325 @@
+require "spec_helper"
+
+describe Mongoid::Clients::Sessions do
+
+  before(:all) do
+    CONFIG[:clients][:other] = CONFIG[:clients][:default].dup
+    CONFIG[:clients][:other][:database] = 'other'
+    Mongoid::Clients.clients.values.each(&:close)
+    Mongoid::Config.send(:clients=, CONFIG[:clients])
+    Mongoid::Clients.with_name(:other).subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.new)
+  end
+
+  after(:all) do
+    Mongoid::Clients.with_name(:other).close
+    Mongoid::Clients.clients.delete(:other)
+  end
+
+  let(:subscriber) do
+    Mongoid::Clients.with_name(:other).instance_variable_get(:@monitoring).subscribers['Command'].find do |s|
+      s.is_a?(EventSubscriber)
+    end
+  end
+
+  let(:insert_events) do
+    subscriber.started_events.select { |event| event.command_name == :insert }
+  end
+
+  let(:update_events) do
+    subscriber.started_events.select { |event| event.command_name == :update }
+  end
+
+  context 'when a session is used on a model class' do
+
+    context 'when sessions are supported', if: sessions_supported? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        subscriber.clear_events!
+        Person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      context 'when another thread is started' do
+
+        let!(:last_use_diff) do
+          Person.with_session do |session|
+            Person.create
+            Person.create
+            last_use = session.instance_variable_get(:@server_session).last_use
+            Thread.new { Person.create }.value
+            session.instance_variable_get(:@server_session).last_use - last_use
+          end
+        end
+
+        it 'does not use the session for that thread' do
+          expect(Person.count).to be(2)
+          expect(Person.with(client: :default) { Person.count }).to be(1)
+          lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+          expect(last_use_diff).to eq(0)
+        end
+      end
+
+      context 'when the operations in the session block are all on the class' do
+
+        before do
+          Person.with_session do
+            Person.create
+            Person.create
+          end
+        end
+
+        it 'uses a single session id for all operations on the class' do
+          expect(Person.count).to be(2)
+          lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the session block are also on another class' do
+
+        context 'when the other class uses the same client' do
+
+          before do
+            Post.with(client: :other) do
+              Person.with_session do
+                Person.create
+                Person.create
+                Post.create
+              end
+            end
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(Post.with(client: :other) { |klass| klass.count }).to be(1)
+            lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(lsids_sent.size).to eq(3)
+            expect(lsids_sent.uniq.size).to eq(1)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do
+                Person.create
+                Person.create
+                Post.create
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(Person.count).to be(2)
+            lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(lsids_sent.size).to eq(2)
+            expect(lsids_sent.uniq.size).to eq(1)
+          end
+        end
+
+        context 'when sessions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              Person.with_session do
+                Person.with_session do
+                  Person.create
+                  Post.create
+                end
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'does not execute any operations' do
+            expect(Person.count).to be(0)
+            expect(insert_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_supported? do
+
+      let!(:error) do
+        e = nil
+        begin
+          Person.with_session {}
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+        expect(error.message).to include('not supported')
+      end
+    end
+  end
+
+  context 'when a session is used on a model instance' do
+
+    let!(:person) do
+      Person.with(client: :other) do |klass|
+        klass.create
+      end
+    end
+
+    context 'when sessions are supported', if: sessions_supported? do
+
+      around do |example|
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+        subscriber.clear_events!
+        person.with(client: :other) do
+          example.run
+        end
+        Mongoid::Clients.with_name(:other).database.collections.each(&:drop)
+      end
+
+      context 'when the operations in the session block are all on the instance' do
+
+        before do
+          person.with_session do
+            person.username = 'Emily'
+            person.save
+            person.age = 80
+            person.save
+          end
+        end
+
+        it 'uses a single session id for all operations on the class' do
+          expect(person.reload.username).to eq('Emily')
+          expect(person.reload.age).to eq(80)
+          lsids_sent = update_events.collect { |event| event.command['lsid'] }
+          expect(lsids_sent.size).to eq(2)
+          expect(lsids_sent.uniq.size).to eq(1)
+        end
+      end
+
+      context 'when the operations in the session block are also on another class' do
+
+        context 'when the other class uses the same client' do
+
+          before do
+            Post.with(client: :other) do
+              person.with_session do
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+              end
+            end
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.with(client: :other) { Post.count }).to be(1)
+            update_lsids_sent = update_events.collect { |event| event.command['lsid'] }
+            expect(update_lsids_sent.size).to eq(3) # person update, counter cache, post assignment
+            expect(update_lsids_sent.uniq.size).to eq(1) # person update, counter cache, post assignment
+            insert_lsids_sent = insert_events.collect { |event| event.command['lsid'] }
+            expect(insert_lsids_sent.size).to eq(2)
+            expect(insert_lsids_sent.uniq.size).to eq(1)
+            expect(update_lsids_sent.uniq).to eq(insert_lsids_sent.uniq)
+          end
+        end
+
+        context 'when the other class uses a different client' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do
+                person.username = 'Emily'
+                person.save
+                person.posts << Post.create
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'uses a single session id for all operations on the class' do
+            expect(person.reload.username).to eq('Emily')
+            expect(Post.count).to be(0)
+            update_lsids_sent = update_events.collect { |event| event.command['lsid'] }
+            expect(update_lsids_sent.size).to eq(1)
+          end
+        end
+
+        context 'when sessions are nested' do
+
+          let!(:error) do
+            e = nil
+            begin
+              person.with_session do
+                person.with_session do
+                  person.username = 'Emily'
+                  person.save
+                  person.posts << Post.create
+                end
+              end
+            rescue => ex
+              e = ex
+            end
+            e
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+          end
+
+          it 'does not execute any operations' do
+            expect(person.reload.username).not_to eq('Emily')
+            expect(Post.count).to be(0)
+            expect(update_events).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_supported? do
+
+      let!(:error) do
+        e = nil
+        begin
+          person.with_session {}
+        rescue => ex
+          e = ex
+        end
+        e
+      end
+
+      it 'raises a sessions not supported error' do
+        expect(error).to be_a(Mongoid::Errors::InvalidSessionUse)
+        expect(error.message).to include('not supported')
+      end
+    end
+  end
+end