Class: MaintenanceTasks::Run Private

Inherits:
ApplicationRecord show all
Defined in:
app/models/maintenance_tasks/run.rb

Overview

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

Model that persists information related to a task being run from the UI.

Constant Summary collapse

STATUSES =

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.

Various statuses a run can be in.

[
  :enqueued,    # The task has been enqueued by the user.
  :running,     # The task is being performed by a job worker.
  :succeeded,   # The task finished without error.
  :cancelling,  # The task has been told to cancel but is finishing work.
  :cancelled,   # The user explicitly halted the task's execution.
  :interrupted, # The task was interrupted by the job infrastructure.
  :pausing,     # The task has been told to pause but is finishing work.
  :paused,      # The task was paused in the middle of the run by the user.
  :errored,     # The task code produced an unhandled exception.
]
ACTIVE_STATUSES =

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. 

[
  :enqueued,
  :running,
  :paused,
  :pausing,
  :cancelling,
  :interrupted,
]
STOPPING_STATUSES =

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. 

[
  :pausing,
  :cancelling,
  :cancelled,
]
COMPLETED_STATUSES =

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. 

[:succeeded, :errored, :cancelled]
COMPLETED_RUNS_LIMIT =

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. 

10
STUCK_TASK_TIMEOUT =

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. 

5.minutes

Instance Method Summary collapse

Instance Method Details

#active? ⇒ Boolean

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

Returns whether the Run is active, which is defined as having a status of enqueued, running, pausing, cancelling, paused or interrupted.

Returns:

  • (Boolean) —

    whether the Run is active.



211
212
213
 
# File 'app/models/maintenance_tasks/run.rb', line 211

def active?
  ACTIVE_STATUSES.include?(status.to_sym)
end

#cancel ⇒ Object

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

Cancels a Run.

If the Run is paused, it will transition directly to cancelled, since the Task is not being performed. In this case, the ended_at timestamp will be updated.

If the Run is not paused, the Run will transition to cancelling.

If the Run is already cancelling, and has last been updated more than 5 minutes ago, it will transition to cancelled, and the ended_at timestamp will be updated.



302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'app/models/maintenance_tasks/run.rb', line 302

def cancel
  if paused? || stuck?
    self.status = :cancelled
    self.ended_at = Time.now
    persist_transition
  else
    cancelling!
  end
rescue ActiveRecord::StaleObjectError
  reload_status
  retry
end

#complete ⇒ Object

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

Handles the completion of a Run, setting a status of succeeded and the ended_at timestamp.



286
287
288
289
 
# File 'app/models/maintenance_tasks/run.rb', line 286

def complete
  self.status = :succeeded
  self.ended_at = Time.now
end

#completed? ⇒ Boolean

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

Returns whether the Run is completed, which is defined as having a status of succeeded, cancelled, or errored.

Returns:

  • (Boolean) —

    whether the Run is completed.



202
203
204
 
# File 'app/models/maintenance_tasks/run.rb', line 202

def completed?
  COMPLETED_STATUSES.include?(status.to_sym)
end

#csv_attachment_presence ⇒ Object

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

Performs validation on the presence of a :csv_file attachment. A Run for a Task that uses CsvCollection must have an attached :csv_file to be valid. Conversely, a Run for a Task that doesn’t use CsvCollection should not have an attachment to be valid. The appropriate error is added if the Run does not meet the above criteria.



339
340
341
342
343
344
345
346
347
 
# File 'app/models/maintenance_tasks/run.rb', line 339

def csv_attachment_presence
  if Task.named(task_name).has_csv_content? && !csv_file.attached?
    errors.add(:csv_file, "must be attached to CSV Task.")
  elsif !Task.named(task_name).has_csv_content? && csv_file.present?
    errors.add(:csv_file, "should not be attached to non-CSV Task.")
  end
rescue Task::NotFoundError
  nil
end

#csv_file ⇒ ActiveStorage::Attached::One

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

Fetches the attached ActiveStorage CSV file for the run. Checks first whether the ActiveStorage::Attachment table exists so that we are compatible with apps that are not using ActiveStorage.

Returns:

  • (ActiveStorage::Attached::One) —

    the attached CSV file



390
391
392
393
394
395
 
# File 'app/models/maintenance_tasks/run.rb', line 390

def csv_file
  return unless defined?(ActiveStorage)
  return unless ActiveStorage::Attachment.table_exists?

  super
end

#enqueued! ⇒ Object

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

Sets the run status to enqueued, making sure the transition is validated in case it’s already enqueued.

Rescues and retries status transition if an ActiveRecord::StaleObjectError is encountered.



74
75
76
77
78
79
80
 
# File 'app/models/maintenance_tasks/run.rb', line 74

def enqueued!
  status_will_change!
  super
rescue ActiveRecord::StaleObjectError
  reload_status
  retry
end

#job_shutdown ⇒ Object

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

Handles transitioning the status on a Run when the job shuts down.



272
273
274
275
276
277
278
279
280
281
282
 
# File 'app/models/maintenance_tasks/run.rb', line 272

def job_shutdown
  if cancelling?
    self.status = :cancelled
    self.ended_at = Time.now
  elsif pausing?
    self.status = :paused
  elsif cancelled?
  else
    self.status = :interrupted
  end
end

#pausing! ⇒ Object

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

Marks a Run as pausing.

Rescues and retries status transition if an ActiveRecord::StaleObjectError is encountered.



319
320
321
322
323
324
 
# File 'app/models/maintenance_tasks/run.rb', line 319

def pausing!
  super
rescue ActiveRecord::StaleObjectError
  reload_status
  retry
end

#persist_error(error) ⇒ Object

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

Marks the run as errored and persists the error data.

Parameters:

  • error (StandardError) —

    the Error being persisted.



132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'app/models/maintenance_tasks/run.rb', line 132

def persist_error(error)
  self.started_at ||= Time.now
  update!(
    status: :errored,
    error_class: truncate(:error_class, error.class.name),
    error_message: truncate(:error_message, error.message),
    backtrace: MaintenanceTasks.backtrace_cleaner.clean(error.backtrace),
    ended_at: Time.now,
  )
  run_error_callback
rescue ActiveRecord::StaleObjectError
  reload_status
  retry
end

#persist_progress(number_of_ticks, duration) ⇒ Object

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

Increments tick_count by number_of_ticks and time_running by duration, both directly in the DB. The attribute values are not set in the current instance, you need to reload the record.

Parameters:

  • number_of_ticks (Integer) —

    number of ticks to add to tick_count.

  • duration (Float) —

    the time in seconds that elapsed since the last increment of ticks.



115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'app/models/maintenance_tasks/run.rb', line 115

def persist_progress(number_of_ticks, duration)
  self.class.update_counters(
    id,
    tick_count: number_of_ticks,
    time_running: duration,
    touch: true
  )
  if locking_enabled?
    locking_column = self.class.locking_column
    self[locking_column] += 1
    clear_attribute_change(locking_column)
  end
end

#persist_transition ⇒ Object

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

Saves the run, persisting the transition of its status, and all other changes to the object.



92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'app/models/maintenance_tasks/run.rb', line 92

def persist_transition
  save!
  callback = CALLBACKS_TRANSITION[status]
  run_task_callbacks(callback) if callback
rescue ActiveRecord::StaleObjectError
  success = succeeded?
  reload_status
  if success
    self.status = :succeeded
  else
    job_shutdown
  end
  retry
end

#reload_status ⇒ MaintenanceTasks::Run

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

Refreshes the status and lock version attributes on the Active Record object, and ensures ActiveModel::Dirty doesn’t mark the object as changed.

This allows us to get the Run’s most up-to-date status without needing to reload the entire record.

Returns:



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'app/models/maintenance_tasks/run.rb', line 154

def reload_status
  columns_to_reload = if locking_enabled?
    [:status, self.class.locking_column]
  else
    [:status]
  end
  updated_status, updated_lock_version = self.class.uncached do
    self.class.where(id: id).pluck(*columns_to_reload).first
  end

  self.status = updated_status
  if updated_lock_version
    self[self.class.locking_column] = updated_lock_version
  end
  clear_attribute_changes(columns_to_reload)
  self
end

#running ⇒ Object

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

Marks a Run as running.

If the run is stopping already, it will not transition to running. Rescues and retries status transition if an ActiveRecord::StaleObjectError is encountered.



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'app/models/maintenance_tasks/run.rb', line 235

def running
  if locking_enabled?
    begin
      running! unless stopping?
    rescue ActiveRecord::StaleObjectError
      reload_status
      retry
    end
  else
    # Preserve swap-and-replace solution for data races until users
    # run migration to upgrade to optimistic locking solution
    return if stopping?

    updated = self.class.where(id: id).where.not(status: STOPPING_STATUSES)
      .update_all(status: :running, updated_at: Time.now) > 0
    if updated
      self.status = :running
      clear_attribute_changes([:status])
    else
      reload_status
    end
  end
end

#start(count) ⇒ Object

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

Starts a Run, setting its started_at timestamp and tick_total.

Parameters:

  • count (Integer) —

    the total iterations to be performed, as specified by the Task.



263
264
265
266
267
268
269
 
# File 'app/models/maintenance_tasks/run.rb', line 263

def start(count)
  update!(started_at: Time.now, tick_total: count)
  task.run_callbacks(:start)
rescue ActiveRecord::StaleObjectError
  reload_status
  retry
end

#started? ⇒ Boolean

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

Returns whether the Run has been started, which is indicated by the started_at timestamp being present.

Returns:

  • (Boolean) —

    whether the Run was started.



194
195
196
 
# File 'app/models/maintenance_tasks/run.rb', line 194

def started?
  started_at.present?
end

#stopped? ⇒ Boolean

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

Returns whether the Run is stopped, which is defined as having a status of paused, succeeded, cancelled, or errored.

Returns:

  • (Boolean) —

    whether the Run is stopped.



186
187
188
 
# File 'app/models/maintenance_tasks/run.rb', line 186

def stopped?
  completed? || paused?
end

#stopping? ⇒ Boolean

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

Returns whether the Run is stopping, which is defined as having a status of pausing or cancelling. The status of cancelled is also considered stopping since a Run can be cancelled while its job still exists in the queue, and we want to handle it the same way as a cancelling run.

Returns:

  • (Boolean) —

    whether the Run is stopping.



178
179
180
 
# File 'app/models/maintenance_tasks/run.rb', line 178

def stopping?
  STOPPING_STATUSES.include?(status.to_sym)
end

#stuck? ⇒ Boolean

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

Returns whether a Run is stuck, which is defined as having a status of cancelling, and not having been updated in the last 5 minutes.

Returns:

  • (Boolean) —

    whether the Run is stuck.



330
331
332
 
# File 'app/models/maintenance_tasks/run.rb', line 330

def stuck?
  cancelling? && updated_at <= STUCK_TASK_TIMEOUT.ago
end

#task ⇒ Task

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

Returns a Task instance for this Run. Assigns any attributes to the Task based on the Run’s parameters. Note that the Task instance is not supplied with :csv_content yet if it’s a CSV Task. This is done in the job, since downloading the CSV file can take some time.

Returns:

  • (Task) —

    a Task instance.



403
404
405
406
407
408
409
410
411
412
413
 
# File 'app/models/maintenance_tasks/run.rb', line 403

def task
  @task ||= begin
    task = Task.named(task_name).new
    if task.attribute_names.any? && arguments.present?
      task.assign_attributes(arguments)
    end
    task
  rescue ActiveModel::UnknownAttributeError
    task
  end
end

#time_to_completion ⇒ ActiveSupport::Duration

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

Returns the duration left for the Run to finish based on the number of ticks left and the average time needed to process a tick. Returns nil if the Run is completed, or if tick_count or tick_total is zero.

Returns:

  • (ActiveSupport::Duration) —

    the estimated duration left for the Run to finish.



221
222
223
224
225
226
227
228
 
# File 'app/models/maintenance_tasks/run.rb', line 221

def time_to_completion
  return if completed? || tick_count == 0 || tick_total.to_i == 0

  processed_per_second = (tick_count.to_f / time_running)
  ticks_left = (tick_total - tick_count)
  seconds_to_finished = ticks_left / processed_per_second
  seconds_to_finished.seconds
end

#validate_task_arguments ⇒ Object

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

Performs validation on the arguments to use for the Task. If the Task is invalid, the errors are added to the Run.



354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'app/models/maintenance_tasks/run.rb', line 354

def validate_task_arguments
  arguments_match_task_attributes if arguments.present?
  if task.invalid?
    error_messages = task.errors
      .map { |attribute, message| "#{attribute.inspect} #{message}" }
    errors.add(
      :arguments,
      "are invalid: #{error_messages.join("; ")}"
    )
  end
rescue Task::NotFoundError
  nil
end