Class: ActiveSupport::ExecutionWrapper

Inherits:
Object
  • Object
show all
Includes:
Callbacks
Defined in:
lib/active_support/execution_wrapper.rb

Direct Known Subclasses

Executor, Reloader

Constant Summary collapse

Null =

:nodoc:

Object.new

Constants included from Callbacks

Callbacks::CALLBACK_FILTER_TYPES

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Callbacks

#run_callbacks

Methods included from Concern

#append_features, #class_methods, extended, #included

Class Attribute Details

.active ⇒ Object

Returns the value of attribute active.



83
84
85
 
# File 'lib/active_support/execution_wrapper.rb', line 83

def active
  @active
end

Class Method Details

.active? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


93
94
95
 
# File 'lib/active_support/execution_wrapper.rb', line 93

def self.active? # :nodoc:
  @active[Thread.current]
end

.inherited(other) ⇒ Object

:nodoc:



86
87
88
89
 
# File 'lib/active_support/execution_wrapper.rb', line 86

def self.inherited(other) # :nodoc:
  super
  other.active = Concurrent::Hash.new
end

.register_hook(hook, outer: false) ⇒ Object

Register an object to be invoked during both the run and complete steps.

hook.complete will be passed the value returned from hook.run, and will only be invoked if run has previously been called. (Mostly, this means it won’t be invoked if an exception occurs in a preceding to_run block; all ordinary to_complete blocks are invoked in that situation.)



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/active_support/execution_wrapper.rb', line 30

def self.register_hook(hook, outer: false)
  if outer
    run_args = [prepend: true]
    complete_args = [:after]
  else
    run_args = complete_args = []
  end

  to_run(*run_args) do
    hook_state[hook] = hook.run
  end
  to_complete(*complete_args) do
    if hook_state.key?(hook)
      hook.complete hook_state[hook]
    end
  end
end

.run! ⇒ Object

Run this execution.

Returns an instance, whose complete! method must be invoked after the work has been performed.

Where possible, prefer wrap.



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/active_support/execution_wrapper.rb', line 54

def self.run!
  if active?
    Null
  else
    new.tap do |instance|
      success = nil
      begin
        instance.run!
        success = true
      ensure
        instance.complete! unless success
      end
    end
  end
end

.to_complete(*args, &block) ⇒ Object 



18
19
20
 
# File 'lib/active_support/execution_wrapper.rb', line 18

def self.to_complete(*args, &block)
  set_callback(:complete, *args, &block)
end

.to_run(*args, &block) ⇒ Object 



14
15
16
 
# File 'lib/active_support/execution_wrapper.rb', line 14

def self.to_run(*args, &block)
  set_callback(:run, *args, &block)
end

.wrap ⇒ Object

Perform the work in the supplied block as an execution.



71
72
73
74
75
76
77
78
79
80
 
# File 'lib/active_support/execution_wrapper.rb', line 71

def self.wrap
  return yield if active?

  instance = run!
  begin
    yield
  ensure
    instance.complete!
  end
end

Instance Method Details

#complete! ⇒ Object

Complete this in-flight execution. This method must be called exactly once on the result of any call to run!.

Where possible, prefer wrap.



106
107
108
109
110
 
# File 'lib/active_support/execution_wrapper.rb', line 106

def complete!
  run_callbacks(:complete)
ensure
  self.class.active.delete Thread.current
end

#run! ⇒ Object

:nodoc:



97
98
99
100
 
# File 'lib/active_support/execution_wrapper.rb', line 97

def run! # :nodoc:
  self.class.active[Thread.current] = true
  run_callbacks(:run)
end