Module: Mongoid::Clients::Sessions::ClassMethods

Included in:
Mongoid
Defined in:
lib/mongoid/clients/sessions.rb

Constant Summary collapse

CALLBACK_ACTIONS =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future.

Actions that can be used to trigger transactional callbacks.

[:create, :destroy, :update]

Instance Method Summary collapse

Instance Method Details

#after_commit(*args, &block) ⇒ Object

Sets up a callback is called after a commit of a transaction. The callback is called only if the document is created, updated, or destroyed in the transaction.

See ActiveSupport::Callbacks::ClassMethods::set_callback for more information about method parameters and possible options.



114
115
116
117
 
# File 'lib/mongoid/clients/sessions.rb', line 114

def after_commit(*args, &block)
  set_options_for_callbacks!(args)
  set_callback(:commit, :after, *args, &block)
end

#after_create_commit(*args, &block) ⇒ Object

Shortcut for after_commit :hook, on: :create.



126
127
128
129
 
# File 'lib/mongoid/clients/sessions.rb', line 126

def after_create_commit(*args, &block)
  set_options_for_callbacks!(args, on: :create)
  set_callback(:commit, :after, *args, &block)
end

#after_destroy_commit(*args, &block) ⇒ Object

Shortcut for after_commit :hook, on: :destroy.



138
139
140
141
 
# File 'lib/mongoid/clients/sessions.rb', line 138

def after_destroy_commit(*args, &block)
  set_options_for_callbacks!(args, on: :destroy)
  set_callback(:commit, :after, *args, &block)
end

#after_rollback(*args, &block) ⇒ Object

This callback is called after a create, update, or destroy are rolled back.

Please check the documentation of after_commit for options.



146
147
148
149
 
# File 'lib/mongoid/clients/sessions.rb', line 146

def after_rollback(*args, &block)
  set_options_for_callbacks!(args)
  set_callback(:rollback, :after, *args, &block)
end

#after_save_commit(*args, &block) ⇒ Object

Shortcut for after_commit :hook, on: [ :create, :update ]



120
121
122
123
 
# File 'lib/mongoid/clients/sessions.rb', line 120

def after_save_commit(*args, &block)
  set_options_for_callbacks!(args, on: [ :create, :update ])
  set_callback(:commit, :after, *args, &block)
end

#after_update_commit(*args, &block) ⇒ Object

Shortcut for after_commit :hook, on: :update.



132
133
134
135
 
# File 'lib/mongoid/clients/sessions.rb', line 132

def after_update_commit(*args, &block)
  set_options_for_callbacks!(args, on: :update)
  set_callback(:commit, :after, *args, &block)
end

#transaction(options = {}, session_options: {}) { ... } ⇒ Object

Executes a block within the context of a transaction.

If the block does not raise an error, the transaction is committed. If an error is raised, the transaction is aborted. The error is passed on except for the ‘Mongoid::Errors::Rollback`. This error is not passed on, so you can raise is if you want to deliberately rollback the transaction.

Parameters:

  • options (Hash) (defaults to: {}) —

    The transaction options. Please see the driver documentation for the available session options.

  • session_options (Hash) (defaults to: {}) —

    The session options. A MongoDB transaction must be started inside a session, therefore a session will be started. Please see the driver documentation for the available session options.

Yields:

  • Provided block will be executed inside a transaction.

Raises:



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/mongoid/clients/sessions.rb', line 87

def transaction(options = {}, session_options: {})
  with_session(session_options) do |session|
    begin
      session.start_transaction(options)
      yield
      commit_transaction(session)
    rescue Mongoid::Errors::Rollback
      abort_transaction(session)
    rescue Mongoid::Errors::InvalidSessionNesting
      # Session should be ended here.
      raise Mongoid::Errors::InvalidTransactionNesting.new
    rescue Mongo::Error::InvalidSession, Mongo::Error::InvalidTransactionOperation => e
      abort_transaction(session)
      raise Mongoid::Errors::TransactionError(e)
    rescue StandardError => e
      abort_transaction(session)
      raise e
    end
  end
end

#with_session(options = {}) {|The| ... } ⇒ Object

Execute a block within the context of a session.

Examples:

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

Parameters:

  • options (Hash) (defaults to: {}) —

    The session options. Please see the driver documentation for the available session options.

Yield Parameters:

  • The (Mongo::Session) —

    session being used for the block.

Returns:

  • (Object) —

    The result of calling the block.

Raises:

  • (Errors::InvalidSessionUse) —

    If an operation is attempted on a model using another client from which the session was started or if sessions are nested.



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/mongoid/clients/sessions.rb', line 42

def with_session(options = {})
  if Threaded.get_session(client: persistence_context.client)
    raise Mongoid::Errors::InvalidSessionNesting.new
  end
  session = persistence_context.client.start_session(options)
  Threaded.set_session(session, client: persistence_context.client)
  yield(session)
rescue Mongo::Error::InvalidSession => ex
  if Mongo::Error::SessionsNotSupported === ex
    raise Mongoid::Errors::SessionsNotSupported.new
  else
    raise ex
  end
rescue Mongo::Error::OperationFailure => ex
  if (ex.code == 40415 && ex.server_message =~ /startTransaction/) ||
     (ex.code == 20 && ex.server_message =~ /Transaction/)
    raise Mongoid::Errors::TransactionsNotSupported.new
  else
    raise ex
  end
ensure
  Threaded.clear_session(client: persistence_context.client)
end