maintenance_tasks 1.10.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de43aad0e8d7479e1f7a88d8f664e20213d42455ca85ef22e074e2321b9a183b
-  data.tar.gz: 65bae8e5b9f793e5cd4dc08dfee03611378007d571d5fc027b349faa7c358b74
+  metadata.gz: 60d043a961d97e4db5e822b86bf17a29fd409cf14e3951c581ecfb92abc7e2af
+  data.tar.gz: 5170cb9e4bb82c82fe31f07f0dba93ca28caeacffe2b68ec592a092623d6aafd
 SHA512:
-  metadata.gz: 5b088335a8ef4a0e1e92d376f4c5c2d2c05ca2dea2e07aa983f21783ce5a7bff53cf3b4f2a75607d67fea144119078f563882f6e67c6fd09adc3d20ebac285a1
-  data.tar.gz: '0128f6891b9b0328b7ba80490b4843a70eb014ddb82295d50f7d22218164ac3e9ef1e7c08bb80e8aab0a4501e932a1d374e755e7f21bd709c996f33b3344575f'
+  metadata.gz: be30600ed5e353ef1fba3bc484d5349be4567249b0cbb808503e73e0f42af76ae0befe6403fc4bdead3fb3ce0a5cd36e920f427eb013ac5215900571ddbb976a
+  data.tar.gz: 1242c76047b52eae2463ea562c0ac48d09d773f9d4b069a781a140e49c39c9175e25b1eb7d21db5dce6ee96d43844323337761575909db396ccf4bc044a8355b

data/README.md

@@ -33,8 +33,27 @@ take a look at the [Active Job documentation][active-job-docs].
 [async-adapter]: https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html
 [active-job-docs]: https://guides.rubyonrails.org/active_job_basics.html#setting-the-backend
 
+
+### Autoloading
+
+The Maintenance Tasks framework does not support autoloading in `:classic` mode.
+Please ensure your application is using [Zeitwerk](https://github.com/fxn/zeitwerk) to load your code.
+For more information, please consult the [Rails guides on autoloading and reloading constants](https://guides.rubyonrails.org/autoloading_and_reloading_constants.html).
+
 ## Usage
 
+The typical Maintenance Tasks workflow is as follows:
+
+1. [Generate a class describing the Task](#creating-a-task) and the work to be done.
+2. Run the Task
+    - either by [using the included web UI](#running-a-task-from-the-web-ui),
+    - or by [using the command line](#running-a-task-from-the-command-line),
+    - or by [using Ruby](#running-a-task-from-ruby).
+3. [Monitor the Task](#monitoring-your-tasks-status)
+    - either by using the included web UI,
+    - or by manually checking your task's run's status in your database.
+4. Optionally, delete the Task code if you no longer need it.
+
 ### Creating a Task
 
 A generator is provided to create tasks. Generate a new task by running:
@@ -50,8 +69,12 @@ The generated task is a subclass of `MaintenanceTasks::Task` that implements:
 * `collection`: return an Active Record Relation or an Array to be iterated
   over.
 * `process`: do the work of your maintenance task on a single record
-* `count`: return the number of rows that will be iterated over (optional, to be
-  able to show progress)
+
+Optionally, tasks can also implement a custom `#count` method, defining the number
+of elements that will be iterated over. Your task's `tick_total` will be calculated
+automatically based on the collection size, but this value may be overriden if desired
+using the `#count` method (this might be done, for example, to avoid the query that would
+be produced to determine the size of your collection).
 
 Example:
 
@@ -64,10 +87,6 @@ module Maintenance
       Post.all
     end
 
-    def count
-      collection.count
-    end
-
     def process(post)
       post.update!(content: "New content!")
     end
@@ -238,10 +257,6 @@ module Maintenance
       Post.all
     end
 
-    def count
-      collection.count
-    end
-
     def process(post)
       post.update!(content: "New content added on #{Time.now.utc}")
     end
@@ -290,10 +305,6 @@ module Maintenance
       Post.all
     end
 
-    def count
-      collection.count
-    end
-
     def process(post)
       post.update!(content: updated_content)
     end
@@ -394,6 +405,20 @@ depend on the queue adapter but in general, you should follow these rules:
 
 [sidekiq-idempotent]: https://github.com/mperham/sidekiq/wiki/Best-Practices#2-make-your-job-idempotent-and-transactional
 
+#### Task object life cycle and memoization
+
+When the Task runs or resumes, the Runner enqueues a job, which processes the
+Task. That job will instantiate a Task object which will live for the duration
+of the job. The first time the job runs, it will call `count`. Every time a job
+runs, it will call `collection` on the Task object, and then `process`
+for each item in the collection, until the job stops. The job stops when either the
+collection is finished processing or after the maximum job runtime has expired.
+
+This means memoization can be misleading within `process`, since the memoized
+values will be available for subsequent calls to `process` within the same job.
+Still, memoization can be used for throttling or reporting, and you can use [Task
+callbacks](#using-task-callbacks) to persist or log a report for example.
+
 ### Writing tests for a Task
 
 The task generator will also create a test file for your task in the folder
@@ -479,21 +504,31 @@ end
 
 ### Running a Task
 
+#### Running a Task from the Web UI
+
 You can run your new Task by accessing the Web UI and clicking on "Run".
 
+#### Running a Task from the command line
+
 Alternatively, you can run your Task in the command line:
 
 ```sh-session
 bundle exec maintenance_tasks perform Maintenance::UpdatePostsTask
 ```
 
-To run a Task that processes CSVs from the command line, use the --csv option:
+To run a Task that processes CSVs from the command line, use the `--csv` option:
 
 ```sh-session
 bundle exec maintenance_tasks perform Maintenance::ImportPostsTask --csv "path/to/my_csv.csv"
 ```
 
-To run a Task that takes arguments from the command line, use the --arguments
+The `--csv` option also works with CSV content coming from the standard input:
+
+```sh-session
+curl "some/remote/csv" | bundle exec maintenance_tasks perform Maintenance::ImportPostsTask --csv
+```
+
+To run a Task that takes arguments from the command line, use the `--arguments`
 option, passing arguments as a set of \<key>:\<value> pairs:
 
 ```sh-session
@@ -501,6 +536,8 @@ bundle exec maintenance_tasks perform Maintenance::ParamsTask \
   --arguments post_ids:1,2,3 content:"Hello, World!"
 ```
 
+#### Running a Task from Ruby
+
 You can also run a Task in Ruby by sending `run` with a Task name to Runner:
 
 ```ruby
@@ -566,7 +603,7 @@ By default, a running Task will be interrupted after running for more 5 minutes.
 This is [configured in the `job-iteration` gem][max-job-runtime] and can be
 tweaked in an initializer if necessary.
 
-[max-job-runtime]: https://github.com/Shopify/job-iteration/blob/master/guides/best-practices.md#max-job-runtime
+[max-job-runtime]: https://github.com/Shopify/job-iteration/blob/-/guides/best-practices.md#max-job-runtime
 
 Running tasks will also be interrupted and re-enqueued when needed. For example
 [when Sidekiq workers shuts down for a deploy][sidekiq-deploy]:
@@ -581,9 +618,9 @@ Running tasks will also be interrupted and re-enqueued when needed. For example
 
 When Sidekiq is stopping, it will give workers 25 seconds to finish before
 forcefully terminating them (this is the default but can be configured with the
-`--timeout` option).  Before the worker threads are terminated, Sidekiq will try
-to re-enqueue the job so your Task will be resumed. However, the position in the
-collection won't be persisted so at least one iteration may run again.
+`--timeout` option). Before the worker threads are terminated, Sidekiq will try
+to re-enqueue the job so your Task will be resumed. However, the position in
+the collection won't be persisted so at least one iteration may run again.
 
 #### Help! My Task is stuck
 
@@ -757,7 +794,7 @@ The install command will attempt to reinstall these old migrations and migrating
 the database will cause problems. Use `bin/rails
 maintenance_tasks:install:migrations` to copy the gem's migrations to your
 `db/migrate` folder. Check the release notes to see if any new migrations were
-added since your last gem upgrade.  Ensure that these are kept, but remove any
+added since your last gem upgrade. Ensure that these are kept, but remove any
 migrations that already ran.
 
 Run the migrations using `bin/rails db:migrate`.

data/app/controllers/maintenance_tasks/application_controller.rb

@@ -21,8 +21,7 @@ module MaintenanceTasks
     end
 
     before_action do
-      request.content_security_policy_nonce_generator ||=
-        ->(_request) { SecureRandom.base64(16) }
+      request.content_security_policy_nonce_generator ||= ->(_request) { SecureRandom.base64(16) }
       request.content_security_policy_nonce_directives = ["style-src"]
     end
 

data/app/controllers/maintenance_tasks/runs_controller.rb

@@ -6,7 +6,25 @@ module MaintenanceTasks
   #
   # @api private
   class RunsController < ApplicationController
-    before_action :set_run
+    before_action :set_run, except: :create
+
+    # Creates a Run for a given Task and redirects to the Task page.
+    def create(&block)
+      task = Runner.run(
+        name: params.fetch(:task_id),
+        csv_file: params[:csv_file],
+        arguments: params.fetch(:task_arguments, {}).permit!.to_h,
+        &block
+      )
+      redirect_to(task_path(task))
+    rescue ActiveRecord::RecordInvalid => error
+      redirect_to(task_path(error.record.task_name), alert: error.message)
+    rescue ActiveRecord::ValueTooLong => error
+      task_name = params.fetch(:id)
+      redirect_to(task_path(task_name), alert: error.message)
+    rescue Runner::EnqueuingError => error
+      redirect_to(task_path(error.run.task_name), alert: error.message)
+    end
 
     # Updates a Run status to paused.
     def pause
@@ -24,6 +42,16 @@ module MaintenanceTasks
       redirect_to(task_path(@run.task_name), alert: error.message)
     end
 
+    # Resumes a previously paused Run.
+    def resume
+      Runner.resume(@run)
+      redirect_to(task_path(@run.task_name))
+    rescue ActiveRecord::RecordInvalid => error
+      redirect_to(task_path(@run.task_name), alert: error.message)
+    rescue Runner::EnqueuingError => error
+      redirect_to(task_path(@run.task_name), alert: error.message)
+    end
+
     private
 
     def set_run

data/app/controllers/maintenance_tasks/tasks_controller.rb

@@ -12,33 +12,16 @@ module MaintenanceTasks
     # Renders the maintenance_tasks/tasks page, displaying
     # available tasks to users, grouped by category.
     def index
-      @available_tasks = TaskData.available_tasks.group_by(&:category)
+      @available_tasks = TaskDataIndex.available_tasks.group_by(&:category)
     end
 
     # Renders the page responsible for providing Task actions to users.
     # Shows running and completed instances of the Task.
     def show
-      @task = TaskData.find(params.fetch(:id))
-      set_refresh if @task.last_run&.active?
-      @runs_page = RunsPage.new(@task.previous_runs, params[:cursor])
-    end
-
-    # Runs a given Task and redirects to the Task page.
-    def run(&block)
-      task = Runner.run(
-        name: params.fetch(:id),
-        csv_file: params[:csv_file],
-        arguments: params.fetch(:task_arguments, {}).permit!.to_h,
-        &block
-      )
-      redirect_to(task_path(task))
-    rescue ActiveRecord::RecordInvalid => error
-      redirect_to(task_path(error.record.task_name), alert: error.message)
-    rescue ActiveRecord::ValueTooLong => error
-      task_name = params.fetch(:id)
-      redirect_to(task_path(task_name), alert: error.message)
-    rescue Runner::EnqueuingError => error
-      redirect_to(task_path(error.run.task_name), alert: error.message)
+      @task = TaskDataShow.find(params.fetch(:id))
+      @active_runs = @task.active_runs
+      set_refresh if @active_runs.any?
+      @runs_page = RunsPage.new(@task.completed_runs, params[:cursor])
     end
 
     private

data/app/helpers/maintenance_tasks/tasks_helper.rb

@@ -47,7 +47,7 @@ module MaintenanceTasks
       progress_bar = tag.progress(
         value: progress.value,
         max: progress.max,
-        class: ["progress"] + STATUS_COLOURS.fetch(run.status)
+        class: ["progress"] + STATUS_COLOURS.fetch(run.status),
       )
       progress_text = tag.p(tag.i(progress.text))
       tag.div(progress_bar + progress_text, class: "block")
@@ -97,7 +97,7 @@ module MaintenanceTasks
     def csv_file_download_path(run)
       Rails.application.routes.url_helpers.rails_blob_path(
         run.csv_file,
-        only_path: true
+        only_path: true,
       )
     end
 

data/app/jobs/concerns/maintenance_tasks/task_job_concern.rb

@@ -35,7 +35,7 @@ module MaintenanceTasks
       collection = @task.collection
       @enumerator = nil
 
-      collection_enum = case collection
+      @collection_enum = case collection
       when :no_collection
         enumerator_builder.build_once_enumerator(cursor: nil)
       when ActiveRecord::Relation
@@ -50,7 +50,7 @@ module MaintenanceTasks
 
         # For now, only support automatic count based on the enumerator for
         # batches
-        @enumerator = enumerator_builder.active_record_on_batch_relations(
+        enumerator_builder.active_record_on_batch_relations(
           collection.relation,
           cursor: cursor,
           batch_size: collection.batch_size,
@@ -71,7 +71,7 @@ module MaintenanceTasks
           Array, or CSV.
         MSG
       end
-      throttle_enumerator(collection_enum)
+      throttle_enumerator(@collection_enum)
     end
 
     def throttle_enumerator(collection_enum)
@@ -79,7 +79,7 @@ module MaintenanceTasks
         enumerator_builder.build_throttle_enumerator(
           enum,
           throttle_on: condition[:throttle_on],
-          backoff: condition[:backoff].call
+          backoff: condition[:backoff].call,
         )
       end
     end
@@ -123,7 +123,7 @@ module MaintenanceTasks
 
     def on_start
       count = @task.count
-      count = @enumerator&.size if count == :no_count
+      count = @collection_enum.size if count == :no_count
       @run.start(count)
     end
 

data/app/models/maintenance_tasks/batch_csv_collection_builder.rb

@@ -22,7 +22,7 @@ module MaintenanceTasks
     def collection(task)
       BatchCsv.new(
         csv: CSV.new(task.csv_content, headers: true),
-        batch_size: @batch_size
+        batch_size: @batch_size,
       )
     end
 

data/app/models/maintenance_tasks/run.rb

@@ -41,6 +41,7 @@ module MaintenanceTasks
       Task.available_tasks.map(&:to_s)
     } }
     validate :csv_attachment_presence, on: :create
+    validate :csv_content_type, on: :create
     validate :validate_task_arguments, on: :create
 
     attr_readonly :task_name
@@ -49,6 +50,7 @@ module MaintenanceTasks
     serialize :arguments, JSON
 
     scope :active, -> { where(status: ACTIVE_STATUSES) }
+    scope :completed, -> { where(status: COMPLETED_STATUSES) }
 
     # Ensure ActiveStorage is in use before preloading the attachments
     scope :with_attached_csv, -> do
@@ -117,7 +119,7 @@ module MaintenanceTasks
         id,
         tick_count: number_of_ticks,
         time_running: duration,
-        touch: true
+        touch: true,
       )
       if locking_enabled?
         locking_column = self.class.locking_column
@@ -346,6 +348,18 @@ module MaintenanceTasks
       nil
     end
 
+    # Performs validation on the content type of the :csv_file attachment.
+    # A Run for a Task that uses CsvCollection must have a present :csv_file
+    # and a content type of "text/csv" to be valid. The appropriate error is
+    # added if the Run does not meet the above criteria.
+    def csv_content_type
+      if csv_file.present? && csv_file.content_type != "text/csv"
+        errors.add(:csv_file, "must be a CSV")
+      end
+    rescue Task::NotFoundError
+      nil
+    end
+
     # Support iterating over ActiveModel::Errors in Rails 6.0 and Rails 6.1+.
     # To be removed when Rails 6.0 is no longer supported.
     if Rails::VERSION::STRING.match?(/^6.0/)
@@ -358,7 +372,7 @@ module MaintenanceTasks
             .map { |attribute, message| "#{attribute.inspect} #{message}" }
           errors.add(
             :arguments,
-            "are invalid: #{error_messages.join("; ")}"
+            "are invalid: #{error_messages.join("; ")}",
           )
         end
       rescue Task::NotFoundError
@@ -374,7 +388,7 @@ module MaintenanceTasks
             .map { |error| "#{error.attribute.inspect} #{error.message}" }
           errors.add(
             :arguments,
-            "are invalid: #{error_messages.join("; ")}"
+            "are invalid: #{error_messages.join("; ")}",
           )
         end
       rescue Task::NotFoundError

data/app/models/maintenance_tasks/runner.rb

@@ -5,14 +5,6 @@ module MaintenanceTasks
   module Runner
     extend self
 
-    # @deprecated Use {Runner} directly instead.
-    def new
-      ActiveSupport::Deprecation.warn(
-        "Use Runner.run instead of Runner.new.run"
-      )
-      self
-    end
-
     # Exception raised when a Task Job couldn't be enqueued.
     class EnqueuingError < StandardError
       # Initializes a Enqueuing Error.
@@ -48,8 +40,7 @@ module MaintenanceTasks
     # @raise [ActiveRecord::ValueTooLong] if the creation of the Run fails due
     #   to a value being too long for the column type.
     def run(name:, csv_file: nil, arguments: {}, run_model: Run)
-      run = run_model.active.find_by(task_name: name) ||
-        run_model.new(task_name: name, arguments: arguments)
+      run = run_model.new(task_name: name, arguments: arguments)
       if csv_file
         run.csv_file.attach(csv_file)
         run.csv_file.filename = filename(name)
@@ -62,6 +53,23 @@ module MaintenanceTasks
       Task.named(name)
     end
 
+    # Resumes a Task.
+    #
+    # This method re-instantiates and re-enqueues a job for a Run that was
+    # previously paused.
+    #
+    # @param run [MaintenanceTasks::Run] the Run record to be resumed.
+    #
+    # @return [TaskJob] the enqueued Task job.
+    #
+    # @raise [EnqueuingError] if an error occurs while enqueuing the Run.
+    def resume(run)
+      job = instantiate_job(run)
+      run.job_id = job.job_id
+      run.enqueued!
+      enqueue(run, job)
+    end
+
     private
 
     def enqueue(run, job)

data/app/models/maintenance_tasks/runs_page.rb

@@ -24,6 +24,8 @@ module MaintenanceTasks
     # Returns the records for a Page, taking into account the cursor if one is
     # present. Limits the number of records to 20.
     #
+    # An extra Run is loaded so that we can verify whether we're on the last Page.
+    #
     # @return [ActiveRecord::Relation<MaintenanceTasks::Run>] a limited amount
     #  of Run records.
     def records
@@ -33,7 +35,9 @@ module MaintenanceTasks
         else
           @runs
         end
-        runs_after_cursor.limit(RUNS_PER_PAGE)
+        limited_runs = runs_after_cursor.limit(RUNS_PER_PAGE + 1).load
+        @extra_run = limited_runs.length > RUNS_PER_PAGE ? limited_runs.last : nil
+        limited_runs.take(RUNS_PER_PAGE)
       end
     end
 
@@ -47,10 +51,12 @@ module MaintenanceTasks
 
     # Returns whether this Page is the last one.
     #
-    # @return [Boolean] whether this Page contains the last Run record in the
-    #   Runs dataset that is being paginated.
+    # @return [Boolean] whether this Page contains the last Run record in the Runs
+    #   dataset that is being paginated. This is done by checking whether an extra
+    #   Run was loaded by #records - if no extra Run was loaded, this is the last page.
     def last?
-      @runs.unscope(:includes).pluck(:id).last == next_cursor
+      records
+      @extra_run.nil?
     end
   end
 end

data/app/models/maintenance_tasks/task.rb

@@ -19,8 +19,7 @@ module MaintenanceTasks
     class_attribute :throttle_conditions, default: []
 
     # @api private
-    class_attribute :collection_builder_strategy,
-      default: NullCollectionBuilder.new
+    class_attribute :collection_builder_strategy, default: NullCollectionBuilder.new
 
     define_callbacks :start, :complete, :error, :cancel, :pause, :interrupt
 
@@ -64,23 +63,20 @@ module MaintenanceTasks
             "To resolve this issue run: bin/rails active_storage:install"
         end
 
-        if in_batches
-          self.collection_builder_strategy =
-            BatchCsvCollectionBuilder.new(in_batches)
+        self.collection_builder_strategy = if in_batches
+          BatchCsvCollectionBuilder.new(in_batches)
         else
-          self.collection_builder_strategy = CsvCollectionBuilder.new
+          CsvCollectionBuilder.new
         end
       end
 
       # Make this a Task that calls #process once, instead of iterating over
       # a collection.
       def no_collection
-        self.collection_builder_strategy =
-          MaintenanceTasks::NoCollectionBuilder.new
+        self.collection_builder_strategy = MaintenanceTasks::NoCollectionBuilder.new
       end
 
-      delegate :has_csv_content?, :no_collection?,
-        to: :collection_builder_strategy
+      delegate :has_csv_content?, :no_collection?, to: :collection_builder_strategy
 
       # Processes one item.
       #
@@ -122,9 +118,7 @@ module MaintenanceTasks
         backoff_as_proc = backoff
         backoff_as_proc = -> { backoff } unless backoff.respond_to?(:call)
 
-        self.throttle_conditions += [
-          { throttle_on: condition, backoff: backoff_as_proc },
-        ]
+        self.throttle_conditions += [{ throttle_on: condition, backoff: backoff_as_proc }]
       end
 
       # Initialize a callback to run after the task starts.

data/app/models/maintenance_tasks/task_data_index.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module MaintenanceTasks
+  # Class that represents the data related to a Task. Such information can be
+  # sourced from a Task or from existing Run records for a Task that was since
+  # deleted. This class contains higher-level information about the Task, such
+  # as its status and category.
+  #
+  # Instances of this class replace a Task class instance in cases where we
+  # don't need the actual Task subclass.
+  #
+  # @api private
+  class TaskDataIndex
+    class << self
+      # Returns a list of sorted Task Data objects that represent the
+      # available Tasks.
+      #
+      # Tasks are sorted by category, and within a category, by Task name.
+      # Determining a Task's category requires their latest Run records.
+      # Two queries are done to get the currently active and completed Run
+      # records, and Task Data instances are initialized with these related run
+      # values.
+      #
+      # @return [Array<TaskDataIndex>] the list of Task Data.
+      def available_tasks
+        tasks = []
+
+        task_names = Task.available_tasks.map(&:name)
+
+        active_runs = Run.with_attached_csv.active.where(task_name: task_names)
+        active_runs.each do |run|
+          tasks << TaskDataIndex.new(run.task_name, run)
+          task_names.delete(run.task_name)
+        end
+
+        completed_runs = Run.completed.where(task_name: task_names)
+        last_runs = Run.with_attached_csv.where(id: completed_runs.select("MAX(id) as id").group(:task_name))
+        task_names.map do |task_name|
+          last_run = last_runs.find { |run| run.task_name == task_name }
+          tasks << TaskDataIndex.new(task_name, last_run)
+        end
+
+        # We add an additional sorting key (status) to avoid possible
+        # inconsistencies across database adapters when a Task has
+        # multiple active Runs.
+        tasks.sort_by! { |task| [task.name, task.status] }
+      end
+    end
+
+    # Initializes a Task Data with a name and optionally a related run.
+    #
+    # @param name [String] the name of the Task subclass.
+    # @param related_run [MaintenanceTasks::Run] optionally, a Run record to
+    #   set for the Task.
+    def initialize(name, related_run = nil)
+      @name = name
+      @related_run = related_run
+    end
+
+    # @return [String] the name of the Task.
+    attr_reader :name
+    attr_reader :related_run
+
+    alias_method :to_s, :name
+
+    # Returns the status of the latest active or completed Run, if present.
+    # If the Task does not have any Runs, the Task status is `new`.
+    #
+    # @return [String] the Task status.
+    def status
+      related_run&.status || "new"
+    end
+
+    # Retrieves the Task's category, which is one of active, new, or completed.
+    #
+    # @return [Symbol] the category of the Task.
+    def category
+      if related_run.present? && related_run.active?
+        :active
+      elsif related_run.nil?
+        :new
+      else
+        :completed
+      end
+    end
+  end
+end

data/app/models/maintenance_tasks/{task_data.rb → task_data_show.rb}

@@ -3,13 +3,14 @@
 module MaintenanceTasks
   # Class that represents the data related to a Task. Such information can be
   # sourced from a Task or from existing Run records for a Task that was since
-  # deleted.
+  # deleted. This class contains detailed information such as the source code,
+  # associated runs, parameters, etc.
   #
   # Instances of this class replace a Task class instance in cases where we
   # don't need the actual Task subclass.
   #
   # @api private
-  class TaskData
+  class TaskDataShow
     class << self
       # Initializes a Task Data by name, raising if the Task does not exist.
       #
@@ -19,52 +20,26 @@ module MaintenanceTasks
       # non-existent since we don't have interesting data to show.
       #
       # @param name [String] the name of the Task subclass.
-      # @return [TaskData] a Task Data instance.
+      # @return [TaskDataShow] a Task Data instance.
       # @raise [Task::NotFoundError] if the Task does not exist and doesn't have
       #   a Run.
       def find(name)
         task_data = new(name)
-        task_data.last_run || Task.named(name)
+        task_data.active_runs.load
+        task_data.has_any_run? || Task.named(name)
         task_data
       end
-
-      # Returns a list of sorted Task Data objects that represent the
-      # available Tasks.
-      #
-      # Tasks are sorted by category, and within a category, by Task name.
-      # Determining a Task's category require its latest Run record.
-      # To optimize calls to the database, a single query is done to get the
-      # last Run for each Task, and Task Data instances are initialized with
-      # these last_run values.
-      #
-      # @return [Array<TaskData>] the list of Task Data.
-      def available_tasks
-        task_names = Task.available_tasks.map(&:name)
-        available_task_runs = Run.where(task_name: task_names)
-        last_runs = Run.with_attached_csv.where(
-          id: available_task_runs.select("MAX(id) as id").group(:task_name)
-        )
-
-        task_names.map do |task_name|
-          last_run = last_runs.find { |run| run.task_name == task_name }
-          TaskData.new(task_name, last_run)
-        end.sort_by!(&:name)
-      end
     end
 
-    # Initializes a Task Data with a name and optionally a last_run.
+    # Initializes a Task Data with a name and optionally a related run.
     #
     # @param name [String] the name of the Task subclass.
-    # @param last_run [MaintenanceTasks::Run] optionally, a Run record to
-    #   set for the Task.
-    def initialize(name, last_run = :none_passed)
+    def initialize(name)
       @name = name
-      @last_run = last_run unless last_run == :none_passed
     end
 
     # @return [String] the name of the Task.
     attr_reader :name
-
     alias_method :to_s, :name
 
     # The Task's source code.
@@ -83,27 +58,23 @@ module MaintenanceTasks
       File.read(file)
     end
 
-    # Retrieves the latest Run associated with the Task.
+    # Returns the set of currently active Run records associated with the Task.
     #
-    # @return [MaintenanceTasks::Run] the Run record.
-    # @return [nil] if there are no Runs associated with the Task.
-    def last_run
-      return @last_run if defined?(@last_run)
-
-      @last_run = runs.first
+    # @return [ActiveRecord::Relation<MaintenanceTasks::Run>] the relation of
+    #   active Run records.
+    def active_runs
+      @active_runs ||= runs.active
     end
 
-    # Returns the set of Run records associated with the Task previous to the
-    # last Run. This collection represents a historic of past Runs for
-    # information purposes, since the base for Task Data information comes
-    # primarily from the last Run.
+    # Returns the set of completed Run records associated with the Task.
+    # This collection represents a historic of past Runs for information
+    # purposes, since the base for Task Data information comes
+    # primarily from currently active runs.
     #
     # @return [ActiveRecord::Relation<MaintenanceTasks::Run>] the relation of
-    #   record previous to the last Run.
-    def previous_runs
-      return Run.none unless last_run
-
-      runs.where.not(id: last_run.id)
+    #   completed Run records.
+    def completed_runs
+      @completed_runs ||= runs.completed
     end
 
     # @return [Boolean] whether the Task has been deleted.
@@ -114,27 +85,6 @@ module MaintenanceTasks
       true
     end
 
-    # The Task status. It returns the status of the last Run, if present. If the
-    # Task does not have any Runs, the Task status is `new`.
-    #
-    # @return [String] the Task status.
-    def status
-      last_run&.status || "new"
-    end
-
-    # Retrieves the Task's category, which is one of active, new, or completed.
-    #
-    # @return [Symbol] the category of the Task.
-    def category
-      if last_run.present? && last_run.active?
-        :active
-      elsif last_run.nil?
-        :new
-      else
-        :completed
-      end
-    end
-
     # @return [Boolean] whether the Task inherits from CsvTask.
     def csv_task?
       !deleted? && Task.named(name).has_csv_content?
@@ -157,6 +107,12 @@ module MaintenanceTasks
       MaintenanceTasks::Task.named(name).new
     end
 
+    # @return [Boolean] whether the Task has any Run.
+    # @api private
+    def has_any_run?
+      active_runs.any? || completed_runs.any?
+    end
+
     private
 
     def runs

data/app/validators/maintenance_tasks/run_status_validator.rb

@@ -81,7 +81,7 @@ module MaintenanceTasks
     def add_invalid_status_error(record, previous_status, new_status)
       record.errors.add(
         :status,
-        "Cannot transition run from status #{previous_status} to #{new_status}"
+        "Cannot transition run from status #{previous_status} to #{new_status}",
       )
     end
   end

data/app/views/maintenance_tasks/runs/_run.html.erb

@@ -17,4 +17,21 @@
   <%= render "maintenance_tasks/runs/csv", run: run %>
   <%= tag.hr if run.csv_file.present? && run.arguments.present? %>
   <%= render "maintenance_tasks/runs/arguments", run: run %>
+
+  <div class="buttons">
+    <% if run.paused? %>
+      <%= button_to 'Resume', resume_task_run_path(@task, run), method: :put, class: 'button is-primary', disabled: @task.deleted? %>
+      <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger' %>
+    <% elsif run.cancelling? %>
+      <% if run.stuck? %>
+        <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger', disabled: @task.deleted? %>
+      <% end %>
+    <% elsif run.pausing? %>
+      <%= button_to 'Pausing', pause_task_run_path(@task, run), method: :put, class: 'button is-warning', disabled: true %>
+      <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger' %>
+    <% elsif run.active? %>
+      <%= button_to 'Pause', pause_task_run_path(@task, run), method: :put, class: 'button is-warning', disabled: @task.deleted? %>
+      <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger' %>
+    <% end%>
+  </div>
 </div>

data/app/views/maintenance_tasks/tasks/_task.html.erb

@@ -4,7 +4,7 @@
     <%= status_tag(task.status) %>
   </h3>
 
-  <% if (run = task.last_run) %>
+  <% if (run = task.related_run) %>
     <h5 class="title is-5">
       <%= time_tag run.created_at, title: run.created_at %>
     </h5>

data/app/views/maintenance_tasks/tasks/show.html.erb

@@ -1,81 +1,51 @@
 <% content_for :page_title, @task %>
 
 <h1 class="title is-1">
-  <%= @task %> <%= status_tag(@task.status) %>
+  <%= @task %>
 </h1>
 
-<% last_run = @task.last_run %>
-<% if last_run %>
-  <h5 class="title is-5">
-    <%= time_tag last_run.created_at, title: last_run.created_at %>
-  </h5>
-
-  <%= progress last_run %>
-
-  <div class="content">
-    <%= render "maintenance_tasks/runs/info/#{last_run.status}", run: last_run %>
-  </div>
-
-  <div class="content" id="custom-content">
-    <%= render "maintenance_tasks/runs/info/custom", run: last_run %>
-  </div>
-
-  <%= render "maintenance_tasks/runs/csv", run: last_run %>
-  <%= tag.hr if last_run.csv_file.present? %>
-  <%= render "maintenance_tasks/runs/arguments", run: last_run %>
-  <%= tag.hr if last_run.arguments.present? %>
-<% end %>
-
 <div class="buttons">
-  <% if last_run.nil? || last_run.completed? %>
-    <%= form_with url: run_task_path(@task), method: :put do |form| %>
-      <% if @task.csv_task? %>
-        <div class="block">
-          <%= form.label :csv_file %>
-          <%= form.file_field :csv_file %>
-        </div>
-      <% end %>
-      <% parameter_names = @task.parameter_names %>
-      <% if parameter_names.any? %>
-        <div class="block">
-          <%= form.fields_for :task_arguments, @task.new do |ff| %>
-            <% parameter_names.each do |parameter_name| %>
-              <div class="field">
-                <%= ff.label parameter_name, parameter_name, class: "label is-family-monospace" %>
-                <div class="control">
-                  <%= parameter_field(ff, parameter_name) %>
-                </div>
-              </div>
-            <% end %>
-          <% end %>
-        </div>
-      <% end %>
-      <%= render "maintenance_tasks/tasks/custom", form: form %>
+  <%= form_with url: task_runs_path(@task), method: :post do |form| %>
+    <% if @task.csv_task? %>
       <div class="block">
-        <%= form.submit 'Run', class: "button is-success", disabled: @task.deleted? %>
+        <%= form.label :csv_file %>
+        <%= form.file_field :csv_file, accept: "text/csv" %>
       </div>
     <% end %>
-  <% elsif last_run.cancelling? %>
-    <%= button_to 'Run', run_task_path(@task), method: :put, class: 'button is-success', disabled: true %>
-    <% if last_run.stuck? %>
-      <%= button_to 'Cancel', cancel_task_run_path(@task, last_run), method: :put, class: 'button is-danger', disabled: @task.deleted? %>
+    <% parameter_names = @task.parameter_names %>
+    <% if parameter_names.any? %>
+      <div class="block">
+        <%= form.fields_for :task_arguments, @task.new do |ff| %>
+          <% parameter_names.each do |parameter_name| %>
+            <div class="field">
+              <%= ff.label parameter_name, parameter_name, class: "label is-family-monospace" %>
+              <div class="control">
+                <%= parameter_field(ff, parameter_name) %>
+              </div>
+            </div>
+          <% end %>
+        <% end %>
+      </div>
     <% end %>
-  <% elsif last_run.pausing? %>
-    <%= button_to 'Pausing', pause_task_run_path(@task, last_run), method: :put, class: 'button is-warning', disabled: true %>
-    <%= button_to 'Cancel', cancel_task_run_path(@task, last_run), method: :put, class: 'button is-danger' %>
-  <% elsif last_run.paused? %>
-    <%= button_to 'Resume', run_task_path(@task), method: :put, class: 'button is-primary', disabled: @task.deleted? %>
-    <%= button_to 'Cancel', cancel_task_run_path(@task, last_run), method: :put, class: 'button is-danger' %>
-  <% else %>
-    <%= button_to 'Pause', pause_task_run_path(@task, last_run), method: :put, class: 'button is-warning', disabled: @task.deleted? %>
-    <%= button_to 'Cancel', cancel_task_run_path(@task, last_run), method: :put, class: 'button is-danger' %>
-  <% end%>
+    <%= render "maintenance_tasks/tasks/custom", form: form %>
+    <div class="block">
+      <%= form.submit 'Run', class: "button is-success", disabled: @task.deleted? %>
+    </div>
+  <% end %>
 </div>
 
 <% if (code = @task.code) %>
   <pre><code><%= highlight_code(code) %></code></pre>
 <% end %>
 
+<% if @active_runs.any? %>
+  <hr/>
+
+  <h4 class="title is-4">Active Runs</h4>
+
+  <%= render @active_runs %>
+<% end %>
+
 <% if @runs_page.records.present? %>
   <hr/>
 

data/config/routes.rb

@@ -2,14 +2,11 @@
 
 MaintenanceTasks::Engine.routes.draw do
   resources :tasks, only: [:index, :show], format: false do
-    member do
-      put "run"
-    end
-
-    resources :runs, only: [], format: false do
+    resources :runs, only: [:create], format: false do
       member do
         put "pause"
         put "cancel"
+        put "resume"
       end
     end
   end

data/db/migrate/20220713131925_add_index_on_task_name_and_status_to_runs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AddIndexOnTaskNameAndStatusToRuns < ActiveRecord::Migration[6.0]
+  def change
+    remove_index(:maintenance_tasks_runs,
+      column: [:task_name, :created_at], order: { created_at: :desc },
+      name: :index_maintenance_tasks_runs_on_task_name_and_created_at)
+
+    add_index(:maintenance_tasks_runs, [:task_name, :status, :created_at],
+      name: :index_maintenance_tasks_runs,
+      order: { created_at: :desc })
+  end
+end

data/lib/generators/maintenance_tasks/task_generator.rb

@@ -26,7 +26,7 @@ module MaintenanceTasks
       template_file = File.join(
         "app/tasks/#{tasks_module_file_path}",
         class_path,
-        "#{file_name}_task.rb"
+        "#{file_name}_task.rb",
       )
       if options[:csv]
         template("csv_task.rb", template_file)
@@ -56,7 +56,7 @@ module MaintenanceTasks
       template_file = File.join(
         "test/tasks/#{tasks_module_file_path}",
         class_path,
-        "#{file_name}_task_test.rb"
+        "#{file_name}_task_test.rb",
       )
       template("task_test.rb", template_file)
     end
@@ -65,7 +65,7 @@ module MaintenanceTasks
       template_file = File.join(
         "spec/tasks/#{tasks_module_file_path}",
         class_path,
-        "#{file_name}_task_spec.rb"
+        "#{file_name}_task_spec.rb",
       )
       template("task_spec.rb", template_file)
     end

data/lib/generators/maintenance_tasks/templates/no_collection_task_test.rb.tt

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "test_helper"
 
 module <%= tasks_module %>

data/lib/generators/maintenance_tasks/templates/task_spec.rb.tt

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "rails_helper"
 
 module <%= tasks_module %>

data/lib/generators/maintenance_tasks/templates/task_test.rb.tt

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "test_helper"
 
 module <%= tasks_module %>

data/lib/maintenance_tasks/cli.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "stringio"
 require "thor"
 
 module MaintenanceTasks
@@ -27,7 +28,7 @@ module MaintenanceTasks
     # Specify the CSV file to process for CSV Tasks
     desc = "Supply a CSV file to be processed by a CSV Task, "\
       "--csv path/to/csv/file.csv"
-    option :csv, desc: desc
+    option :csv, lazy_default: :stdin, desc: desc
     # Specify arguments to supply to a Task supporting parameters
     desc = "Supply arguments for a Task that accepts parameters as a set of "\
       "<key>:<value> pairs."
@@ -52,10 +53,25 @@ module MaintenanceTasks
     private
 
     def csv_file
+      return unless options.key?(:csv)
+
       csv_option = options[:csv]
-      if csv_option
-        { io: File.open(csv_option), filename: File.basename(csv_option) }
+
+      if csv_option == :stdin
+        {
+          io: StringIO.new($stdin.read),
+          filename: "stdin.csv",
+          content_type: "text/csv",
+        }
+      else
+        {
+          io: File.open(csv_option),
+          filename: File.basename(csv_option),
+          content_type: "text/csv",
+        }
       end
+    rescue Errno::ENOENT
+      raise ArgumentError, "CSV file not found: #{csv_option}"
     end
   end
 end

data/lib/maintenance_tasks/engine.rb

@@ -10,29 +10,19 @@ module MaintenanceTasks
 
     initializer "maintenance_tasks.warn_classic_autoloader" do
       unless Rails.autoloaders.zeitwerk_enabled?
-        ActiveSupport::Deprecation.warn(<<~MSG.squish)
-          Autoloading in classic mode is deprecated and support will be removed in the next
-          release of Maintenance Tasks. Please use Zeitwerk to autoload your application.
+        raise <<~MSG.squish
+          Autoloading in classic mode is not supported.
+          Please use Zeitwerk to autoload your application.
         MSG
       end
     end
 
-    initializer "maintenance_tasks.eager_load_for_classic_autoloader" do
-      eager_load! unless Rails.autoloaders.zeitwerk_enabled?
-    end
-
     initializer "maintenance_tasks.configs" do
       MaintenanceTasks.backtrace_cleaner = Rails.backtrace_cleaner
     end
 
     config.to_prepare do
       _ = TaskJobConcern # load this for JobIteration compatibility check
-      unless Rails.autoloaders.zeitwerk_enabled?
-        tasks_module = MaintenanceTasks.tasks_module.underscore
-        Dir["#{Rails.root}/app/tasks/#{tasks_module}/*.rb"].each do |file|
-          require_dependency(file)
-        end
-      end
     end
 
     config.after_initialize do

data/lib/maintenance_tasks.rb

@@ -63,27 +63,6 @@ module MaintenanceTasks
   #     use when cleaning a Run's backtrace.
   mattr_accessor :backtrace_cleaner
 
-  # @private
-  def self.error_handler
-    return @error_handler if defined?(@error_handler)
-
-    @error_handler = ->(_error, _task_context, _errored_element) {}
-  end
-
-  # @private
-  def self.error_handler=(error_handler)
-    unless error_handler.arity == 3
-      ActiveSupport::Deprecation.warn(
-        "MaintenanceTasks.error_handler should be a lambda that takes three "\
-          "arguments: error, task_context, and errored_element."
-      )
-      @error_handler = ->(error, _task_context, _errored_element) do
-        error_handler.call(error)
-      end
-    end
-    @error_handler = error_handler
-  end
-
   # @!attribute error_handler
   #   @scope class
   #
@@ -91,4 +70,6 @@ module MaintenanceTasks
   #   {file:README#label-Customizing+the+error+handler} for details.
   #
   #   @return [Proc] the callback to perform when an error occurs in the Task.
+  mattr_accessor :error_handler, default:
+    ->(_error, _task_context, _errored_element) {}
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maintenance_tasks
 version: !ruby/object:Gem::Version
-  version: 1.10.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Shopify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-02 00:00:00.000000000 Z
+date: 2022-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -106,7 +106,8 @@ files:
 - app/models/maintenance_tasks/runner.rb
 - app/models/maintenance_tasks/runs_page.rb
 - app/models/maintenance_tasks/task.rb
-- app/models/maintenance_tasks/task_data.rb
+- app/models/maintenance_tasks/task_data_index.rb
+- app/models/maintenance_tasks/task_data_show.rb
 - app/models/maintenance_tasks/ticker.rb
 - app/validators/maintenance_tasks/run_status_validator.rb
 - app/views/layouts/maintenance_tasks/_navbar.html.erb
@@ -134,6 +135,7 @@ files:
 - db/migrate/20210517131953_add_arguments_to_maintenance_tasks_runs.rb
 - db/migrate/20211210152329_add_lock_version_to_maintenance_tasks_runs.rb
 - db/migrate/20220706101937_change_runs_tick_columns_to_bigints.rb
+- db/migrate/20220713131925_add_index_on_task_name_and_status_to_runs.rb
 - exe/maintenance_tasks
 - lib/generators/maintenance_tasks/install_generator.rb
 - lib/generators/maintenance_tasks/task_generator.rb
@@ -152,7 +154,7 @@ homepage: https://github.com/Shopify/maintenance_tasks
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v1.10.3
+  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.0.0
   allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []