Class: LittleMonster::Core::Job

Inherits:
Object
  • Object
show all
Includes:
Loggable
Defined in:
lib/little_monster/core/job.rb

Defined Under Namespace

Classes: Data, Factory, Orchrestator

Constant Summary collapse

ENDED_STATUS = 
%i(success error cancelled).freeze
CALLBACKS = 
%i(on_success on_error on_cancel).freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Loggable

#logger

Constructor Details

#initialize(options = {}) ⇒ Job

Returns a new instance of Job.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/little_monster/core/job.rb', line 59

def initialize(options = {})
  @id = options.fetch(:id, nil)
  @tags = (options[:tags] || {}).freeze

  @retries = options[:retries] || 0

  @current_action = options.fetch(:current_action, self.class.tasks.first)

  @data = if options[:data]
            Data.new(self, options[:data])
          else
            Data.new(self)
          end

  @status = options.fetch(:status, :pending)
  @error= options.fetch(:error, {})

  @orchrestator = Job::Orchrestator.new(self)

  if mock?
    @runned_tasks = {}
    self.class.send :attr_reader, :runned_tasks
  end

  logger.default_tags = tags.merge(
    id: @id,
    job: self.class.to_s,
    retry: @retries
  )

  logger.info "[type:start_job] Starting job with data: #{data.to_h[:outputs]}"
end

Instance Attribute Details

#current_action ⇒ Object

Returns the value of attribute current_action.



53
54
55
 
# File 'lib/little_monster/core/job.rb', line 53

def current_action
  @current_action
end

#data ⇒ Object

Returns the value of attribute data.



54
55
56
 
# File 'lib/little_monster/core/job.rb', line 54

def data
  @data
end

#error ⇒ Object

Returns the value of attribute error.



55
56
57
 
# File 'lib/little_monster/core/job.rb', line 55

def error
  @error
end

#id ⇒ Object

Returns the value of attribute id.



48
49
50
 
# File 'lib/little_monster/core/job.rb', line 48

def id
  @id
end

#orchrestator ⇒ Object (readonly)

Returns the value of attribute orchrestator.



57
58
59
 
# File 'lib/little_monster/core/job.rb', line 57

def orchrestator
  @orchrestator
end

#retries ⇒ Object

Returns the value of attribute retries.



52
53
54
 
# File 'lib/little_monster/core/job.rb', line 52

def retries
  @retries
end

#status ⇒ Object

Returns the value of attribute status.



50
51
52
 
# File 'lib/little_monster/core/job.rb', line 50

def status
  @status
end

#tags ⇒ Object

Returns the value of attribute tags.



49
50
51
 
# File 'lib/little_monster/core/job.rb', line 49

def tags
  @tags
end

Class Method Details

.callback_max_retries ⇒ Object 



31
32
33
 
# File 'lib/little_monster/core/job.rb', line 31

def callback_max_retries
  @callback_max_retries ||= max_retries
end

.callback_retries(value) ⇒ Object 



17
18
19
 
# File 'lib/little_monster/core/job.rb', line 17

def callback_retries(value)
  @callback_max_retries = value
end

.max_retries ⇒ Object 



27
28
29
 
# File 'lib/little_monster/core/job.rb', line 27

def max_retries
  @max_retries ||= LittleMonster.default_job_retries
end

.mock! ⇒ Object 



35
36
37
 
# File 'lib/little_monster/core/job.rb', line 35

def mock!
  @mock = true
end

.mock? ⇒ Boolean

Returns:

  • (Boolean) 


43
44
45
 
# File 'lib/little_monster/core/job.rb', line 43

def mock?
  @mock ||= false
end

.retries(value) ⇒ Object 



13
14
15
 
# File 'lib/little_monster/core/job.rb', line 13

def retries(value)
  @max_retries = value
end

.task_class_for(task_name) ⇒ Object 



21
22
23
24
25
 
# File 'lib/little_monster/core/job.rb', line 21

def task_class_for(task_name)
  "#{to_s.underscore}/#{task_name}".camelcase.constantize
rescue NameError
  task_name.to_s.camelcase.constantize
end

.task_list(*tasks) ⇒ Object 



9
10
11
 
# File 'lib/little_monster/core/job.rb', line 9

def task_list(*tasks)
  @tasks = *tasks
end

.tasks ⇒ Object 



39
40
41
 
# File 'lib/little_monster/core/job.rb', line 39

def tasks
  @tasks ||= []
end

Instance Method Details

#callback_running? ⇒ Boolean

Returns:

  • (Boolean) 


183
184
185
186
 
# File 'lib/little_monster/core/job.rb', line 183

def callback_running?
  return false if @current_action.nil? || self.class.tasks.include?(@current_action)
  CALLBACKS.include? @current_action
end

#callback_to_run ⇒ Object 



163
164
165
166
167
168
169
170
171
172
 
# File 'lib/little_monster/core/job.rb', line 163

def callback_to_run
  case @status
  when :success
    :on_success
  when :error
    :on_error
  when :cancelled
    :on_cancel
  end
end

#ended_status? ⇒ Boolean

Returns:

  • (Boolean) 


188
189
190
 
# File 'lib/little_monster/core/job.rb', line 188

def ended_status?
  Job::ENDED_STATUS.include? @status
end

#is_cancelled? ⇒ Boolean

Returns:

  • (Boolean) 


140
141
142
143
144
145
146
147
148
149
 
# File 'lib/little_monster/core/job.rb', line 140

def is_cancelled?
  return false unless should_request?
  resp = LittleMonster::API.get "/jobs/#{id}"

  if resp.success?
    resp.body[:cancel]
  else
    false
  end
end

#max_retries ⇒ Object 



155
156
157
 
# File 'lib/little_monster/core/job.rb', line 155

def max_retries
  callback_running? ? self.class.callback_max_retries : self.class.max_retries
end

#mock? ⇒ Boolean

Returns:

  • (Boolean) 


192
193
194
 
# File 'lib/little_monster/core/job.rb', line 192

def mock?
  self.class.mock?
end

#notify_callback(status, options = {}) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/little_monster/core/job.rb', line 116

def notify_callback(status, options = {})
  return true unless should_request?
  params = { body: { name: @current_action, status: status } }

  params[:body][:exception] = serialize_error(options[:exception]) if options[:exception]

  params[:body].merge!(options.except(:exception))

  resp = LittleMonster::API.put "/jobs/#{id}/callbacks/#{@current_action}", params,
                                retries: LittleMonster.task_requests_retries,
                                retry_wait: LittleMonster.task_requests_retry_wait
  resp.success?
end

#notify_job(params = {}, options = {}) ⇒ Object 



130
131
132
133
134
135
136
137
138
 
# File 'lib/little_monster/core/job.rb', line 130

def notify_job(params = {}, options = {})
  return true unless should_request?
  options[:critical] = true

  params[:body][:data] = params[:body][:data].to_h if params[:body][:data]

  resp = LittleMonster::API.put "/jobs/#{id}", params, options
  resp.success?
end

#notify_status(options = {}) ⇒ Object 



96
97
98
99
100
101
102
 
# File 'lib/little_monster/core/job.rb', line 96

def notify_status(options = {})
  params = { body: { status: @status } }
  params[:body].merge!(options)

  notify_job params, retries: LittleMonster.job_requests_retries,
                     retry_wait: LittleMonster.job_requests_retry_wait
end

#notify_task(status, options = {}) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/little_monster/core/job.rb', line 104

def notify_task(status, options = {})
  params = { body: { tasks: [{ name: @current_action, status: status }] } }

  params[:body][:data] = options[:data] if options[:data]
  params[:body][:tasks].first[:exception] = serialize_error(options[:exception]) if options[:exception]

  params[:body][:tasks].first.merge!(options.except(:data, :exception))

  notify_job params, retries: LittleMonster.task_requests_retries,
                     retry_wait: LittleMonster.task_requests_retry_wait
end

#on_cancel ⇒ Object 



211
 
# File 'lib/little_monster/core/job.rb', line 211

def on_cancel ; end

#on_error ⇒ Object

callbacks definition



209
 
# File 'lib/little_monster/core/job.rb', line 209

def on_error ; end

#on_success ⇒ Object 



210
 
# File 'lib/little_monster/core/job.rb', line 210

def on_success ; end

#retry? ⇒ Boolean

Returns:

  • (Boolean) 


159
160
161
 
# File 'lib/little_monster/core/job.rb', line 159

def retry?
  !mock? && (max_retries == -1 || max_retries > @retries)
end

#run ⇒ Object 



92
93
94
 
# File 'lib/little_monster/core/job.rb', line 92

def run
  @orchrestator.run
end

#serialize_error(error) ⇒ Object 



200
201
202
203
204
205
206
 
# File 'lib/little_monster/core/job.rb', line 200

def serialize_error(error)
  {
    message: error.message,
    type: error.class.to_s,
    retry: @retries
  }
end

#should_request? ⇒ Boolean

Returns:

  • (Boolean) 


196
197
198
 
# File 'lib/little_monster/core/job.rb', line 196

def should_request?
  !(mock? || LittleMonster.disable_requests?)
end

#task_class_for(task_name) ⇒ Object 



151
152
153
 
# File 'lib/little_monster/core/job.rb', line 151

def task_class_for(task_name)
  self.class.task_class_for task_name
end

#tasks_to_run ⇒ Object

returns the tasks that will be runned for this instance



175
176
177
178
179
180
181
 
# File 'lib/little_monster/core/job.rb', line 175

def tasks_to_run
  return [] if callback_running?
  task_index = self.class.tasks.find_index(@current_action)

  return [] if task_index.nil?
  self.class.tasks.slice(task_index..-1)
end