Module: Abid::RakeExtensions::Task

Defined in:
lib/abid/rake_extensions/task.rb

Instance Method Summary collapse

Instance Method Details

#async_execute(task_args) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/abid/rake_extensions/task.rb', line 90

def async_execute(task_args)
  failed_task = prerequisite_tasks.find do |t|
    t.session.failed? || t.session.canceled?
  end
  if failed_task
    session.cancel(failed_task.session.error)
    return
  end

  async_post(worker) do
    if !needed?
      session.skip
    elsif session.lock
      call_hooks(:before_execute)

      execute(task_args)

      session.success
    else
      async_wait_external
    end
  end
end

#async_execute_after_prerequisites(task_args) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/abid/rake_extensions/task.rb', line 77

def async_execute_after_prerequisites(task_args)
  if prerequisite_tasks.empty?
    async_execute(task_args)
  else
    counter = Concurrent::DependencyCounter.new(prerequisite_tasks.size) do
      session.capture_exception do
        async_execute(task_args)
      end
    end
    prerequisite_tasks.each { |t| t.session.add_observer counter }
  end
end

#async_invoke(*args) ⇒ Object 



46
47
48
49
 
# File 'lib/abid/rake_extensions/task.rb', line 46

def async_invoke(*args)
  task_args = Rake::TaskArguments.new(arg_names, args)
  async_invoke_with_call_chain(task_args, Rake::InvocationChain::EMPTY)
end

#async_invoke_prerequisites(task_args, invocation_chain) ⇒ Object 



70
71
72
73
74
75
 
# File 'lib/abid/rake_extensions/task.rb', line 70

def async_invoke_prerequisites(task_args, invocation_chain)
  prerequisite_tasks.each do |t|
    args = task_args.new_scope(t.arg_names)
    t.async_invoke_with_call_chain(args, invocation_chain)
  end
end

#async_invoke_with_call_chain(task_args, invocation_chain) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/abid/rake_extensions/task.rb', line 51

def async_invoke_with_call_chain(task_args, invocation_chain)
  session.enter do
    session.capture_exception do
      new_chain = Rake::InvocationChain.append(self, invocation_chain)

      unless concerned?
        session.skip
        break
      end

      call_hooks(:before_invoke)

      async_invoke_prerequisites(task_args, new_chain)

      async_execute_after_prerequisites(task_args)
    end
  end
end

#async_post(worker_name, &block) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/abid/rake_extensions/task.rb', line 140

def async_post(worker_name, &block)
  application.worker[worker_name].post do
    session.capture_exception do
      begin
        block.call
        finished = true
      ensure
        fail 'thread killed' if $ERROR_INFO.nil? && !finished
      end
    end
  end
end

#async_wait_external ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/abid/rake_extensions/task.rb', line 114

def async_wait_external
  unless application.options.wait_external_task
    fail "task #{name_with_params} already running"
  end

  application.trace "** Wait #{name_with_params}" if application.options.trace

  async_post(:waiter) do
    interval = application.options.wait_external_task_interval || 10
    timeout = application.options.wait_external_task_timeout || 3600
    timeout_tm = Time.now.to_f + timeout

    loop do
      state.reload
      if !state.running?
        session.success
        break
      elsif Time.now.to_f >= timeout_tm
        fail "#{name} -- timeout exceeded"
      else
        sleep interval
      end
    end
  end
end

#call_hooks(tag, *args) ⇒ Object 



42
43
44
 
# File 'lib/abid/rake_extensions/task.rb', line 42

def call_hooks(tag, *args)
  hooks[tag].each { |h| h.call(*args) }
end

#concerned? ⇒ Boolean

Returns:

  • (Boolean) 


30
31
32
 
# File 'lib/abid/rake_extensions/task.rb', line 30

def concerned?
  true
end

#hooks ⇒ Object 



38
39
40
 
# File 'lib/abid/rake_extensions/task.rb', line 38

def hooks
  @hooks ||= Hash.new { |h, k| h[k] = [] }
end

#name_with_params ⇒ Object 



26
27
28
 
# File 'lib/abid/rake_extensions/task.rb', line 26

def name_with_params
  name
end

#session ⇒ Object 



12
13
14
15
16
17
18
19
20
 
# File 'lib/abid/rake_extensions/task.rb', line 12

def session
  @session ||= Session.new(self).tap do |session|
    session.add_observer do |_, _, reason|
      if session.successed? || session.failed?
        call_hooks(:after_invoke, reason)
      end
    end
  end
end

#state ⇒ Object 



22
23
24
 
# File 'lib/abid/rake_extensions/task.rb', line 22

def state
  State.find(self)
end

#top_level? ⇒ Boolean

Returns:

  • (Boolean) 


34
35
36
 
# File 'lib/abid/rake_extensions/task.rb', line 34

def top_level?
  application.top_level_tasks.any? { |t| application[t] == self }
end

#volatile? ⇒ Boolean

Returns:

  • (Boolean) 


4
5
6
 
# File 'lib/abid/rake_extensions/task.rb', line 4

def volatile?
  true
end

#worker ⇒ Object 



8
9
10
 
# File 'lib/abid/rake_extensions/task.rb', line 8

def worker
  :default
end