good_pipeline 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9df8b5fbd57895f53adf1d3c5804ca9bd64ca792e880c2d4941957e4b8ca368
-  data.tar.gz: c4e2a7c4edbe27a0e40e7ff62a061f5ade53c44a74c0b824ce21bdf019cb8781
+  metadata.gz: e8d45ee63fb102b327e2e847cd277c911c625711562117c172119b3384d08447
+  data.tar.gz: 888ac688b1e600a74fbc70b36c4ab0aa1d7747d4f986bd8cc9d688a6ab8c8dbc
 SHA512:
-  metadata.gz: e3c6e6940034efbc8679ede33b352022deb64a36b7a16a9dd3f02fd6dc32a837caf545407541bd0ca629f690d38cfa60342e6aa756e53ea321fb754eebbd772c
-  data.tar.gz: 878566f6d9ddc7b9ce6b4201f5bd241b21f2758f5475e3fa60e6c3fd629651bff06ff973af9f3f29ac4624bee58e78dc0f9628e8a1cdb503836e923a09e3944e
+  metadata.gz: 642f603b2991bb82256510cf3ea1a13f511f7009a7ba82f10d9fb8c264acdc27d213629842414293a6728c13d055ecf808ba71c555fc9bf4705f3b3b8a23ab5f
+  data.tar.gz: 7941dcef31ca4d86f5fb796803a61d3c3d9af3ed8442aaace983c5a6c5d62360c16a4458ab7130f34764d14e37d53cc79167e4296a52b31bc0381300a3bc74b6

data/Appraisals

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+appraise "rails-7-2" do
+  gem "minitest", "~> 5.25"
+  gem "railties", "~> 7.2.0"
+  gem "activerecord", "~> 7.2.0"
+  gem "activejob", "~> 7.2.0"
+  gem "activesupport", "~> 7.2.0"
+end
+
+appraise "rails-8-0" do
+  gem "minitest", "~> 6.0", ">= 6.0.2"
+  gem "railties", "~> 8.0.0"
+  gem "activerecord", "~> 8.0.0"
+  gem "activejob", "~> 8.0.0"
+  gem "activesupport", "~> 8.0.0"
+end
+
+appraise "rails-8-1" do
+  gem "minitest", "~> 6.0", ">= 6.0.2"
+  gem "railties", "~> 8.1.0"
+  gem "activerecord", "~> 8.1.0"
+  gem "activejob", "~> 8.1.0"
+  gem "activesupport", "~> 8.1.0"
+end

data/CHANGELOG.md

@@ -1,5 +1,72 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-09-01
+
+### Added
+
+- **Pipeline phase barriers** — the new zero-argument `barrier` DSL verb inserts a persisted structural synchronization step between declaration phases. Every prior phase step converges on one barrier and following phase entries fan out from it, avoiding all-to-all dependency expansion. Barriers resolve synchronously without enqueuing an ActiveJob and appear as structural nodes in the dashboard.
+- **Graceful dashboard cancellation** — administrators can stop future DAG scheduling without terminating already-enqueued, scheduled, or retrying GoodJob work; pipelines remain `canceling` until that work drains, then become terminal `canceled`.
+- **Standalone dashboard re-runs** — administrators can start a fresh execution of a terminal pipeline from its stored parameters and current class definition. The original execution remains unchanged, and historical pipeline-chain relationships are not copied.
+- **Read-only dashboard default** — pipeline mutation controls are hidden and rejected with `403 Forbidden` unless `GoodPipeline.dashboard_mutations_enabled = true` is configured explicitly. This setting does not replace authentication for the dashboard mount.
+- **Redesigned dashboard** — a responsive execution shell with pipeline-type navigation, composable status/time/search filters, offset pagination, KPIs, expandable execution rows, stage timelines, and dedicated execution and definition views.
+- **Persistent light and dark themes** — the dashboard now owns an isolated `data-gp-theme` attribute and persists the topbar toggle through a mount-aware Rails endpoint. Dark is now the default theme; existing users will see the dashboard change from light to dark after upgrading unless they select light.
+- **Scale-aware graph views** — large DAGs default to aggregated stage views, with full Mermaid rendering available up to a 1,000-edge safety limit.
+- **Dashboard upgrade generator** — `good_pipeline:upgrade` creates the three concurrent indexes used by type, status, and chronological dashboard queries, and safely no-ops when that migration already exists.
+- **Rails compatibility matrix** — CI now exercises the Rails 7.2 support floor and the Rails 8.0 and 8.1 lines through Appraisal gemfiles.
+
+### Breaking changes
+
+- **Coordinator activity hints removed** — `Coordinator.recompute_pipeline_status` no longer accepts `has_active_steps:` or `has_downstream_chains:`. Terminal status is always derived from fresh rows while the pipeline is locked; obsolete callers now fail loudly instead of having their hints ignored.
+- **Bulk enqueue contract tightened** — `Coordinator.bulk_enqueue_steps` raises `ArgumentError` when existing step IDs span multiple pipelines and now consistently returns `nil`. Both bulk and single-step enqueue refuse to schedule work unless the owning pipeline is `running`; `Coordinator.try_enqueue_step` reports that refusal as `false`.
+- **Rails 7.2 minimum** — Rails 7.1 is no longer supported. Rails 7.1 [reached upstream end-of-life in October 2025](https://rubyonrails.org/2025/10/29/new-rails-releases-and-end-of-support-announcement) and no longer receives bug fixes or security fixes.
+
+### Changed
+
+- **Universal dependency normalization** — repeated keys in every `after:` list are deduplicated before validation and persistence, keeping dependency rows consistent with `pending_upstream_count` for pipelines with or without barriers.
+- **Terminal edge-release invariant** — enqueue-time configuration failures and steps skipped by partial `:halt` propagation now release downstream dependency counters before eligible descendants are resolved. Terminalization, counter release, and downstream scheduling remain in one pipeline-locked transaction.
+- **Pipeline-first coordination** — cancellation, completion, single enqueue, bulk enqueue, and status recomputation serialize on the owning pipeline row and then lock step rows in a consistent order. User jobs still execute concurrently; only coordination for the same pipeline is serialized, including downstream resolution and transactional GoodJob insertion.
+- **Fresh terminal derivation** — completion and explicit status recomputation derive running/canceling outcomes through one locked path. A redelivered terminal step also recomputes a nonterminal pipeline, repairing stale terminal status left by older coordinator versions or manual intervention.
+- **Post-commit chain handoff** — terminal chain propagation runs after all surrounding transactions commit, avoiding cross-pipeline lock nesting and making `GoodPipeline.run` safe inside a caller-managed transaction.
+- **Step completion ownership metadata** — new step batches record their `pipeline_id`, avoiding an ownership lookup before completion locking. `StepFinishedJob` falls back to the step row for batches queued before this upgrade.
+- **Callback delivery semantics clarified** — `callbacks_dispatched_at` guarantees one transactional callback-job enqueue, not exactly-once user callback execution. Retry behavior remains application-configured, and callbacks should be idempotent.
+- **Execution pagination** — dashboard lists now use clamped offset pagination with a total page count instead of keyset cursors.
+- **Step timings** — dashboard timing data is batch-loaded from GoodJob, removing per-step lookups while preserving the same retention boundary as job records.
+- **Relative timestamps** — times under one minute now render as exact seconds such as `30s ago` instead of `just now`.
+- **Dashboard dependencies** — versioned dashboard CSS and JavaScript ship with the gem; graph rendering remains build-free and is initialized client-side in strict mode.
+
+### Fixed
+
+- **Branch-arm pruning with additional dependencies** — every non-selected arm step is reconsidered as soon as its branch resolves and becomes `skipped_by_branch` even when another incoming dependency is unresolved or failed. Branch continuation no longer depends on concurrent completion order.
+- **All-empty branch continuation** — a branch whose arms are all empty now aliases to its structural sentinel, so `after: :branch_key` remains ordered after the branch decision with or without a preceding barrier.
+- **Multiple ignored halt failures** — bulk enqueue-time failures that all override pipeline-level `:halt` with `:ignore` now protect the union of their downstream subtrees instead of allowing each halt pass to skip another ignored subtree.
+- **Skipped dependencies under inherited ignore** — ordinary `skipped` and `canceled` steps are always treated as permanently unsatisfied, preventing descendants from remaining pending when a skipped step inherits pipeline-level `:ignore`.
+- **Dropped chain fan-in wake-ups** — `ChainCoordinator` now waits on a blocking `FOR UPDATE` lock instead of silently skipping a contended downstream pipeline with `SKIP LOCKED`.
+- **Database benchmark pipeline resolution** — dynamically generated benchmark pipeline classes are now registered as constants, allowing the enqueue, completion, recomputation, halt, and full-run sections of `bench/database_bench.rb` to execute.
+
+### Upgrade notes
+
+- Barrier-aware deployments require two phases: first deploy this gem version to every web and worker process capable of running coordinator code; only after all old processes have stopped should application code using `barrier` be deployed. Older coordinators treat the new structural sentinel as an executable job class and cannot safely process barrier definitions.
+- Existing dashboard mounts remain read-only after upgrading. Protect the engine mount with administrator authentication, then set `GoodPipeline.dashboard_mutations_enabled = true` to expose dashboard mutation controls, including cancellation and re-running terminal pipelines. The theme preference remains available in read-only mode.
+- Coordinator completion and enqueue operations for one pipeline are now serialized for cancellation correctness. Wide fan-in increases coordination query volume because every upstream completion locks and recomputes pipeline state; many concurrent completions, such as leaves in a wide fan-out, can contend on the pipeline row. Recursive fan-out scheduling reuses that lock and issues fewer queries than before.
+- Run `bin/rails generate good_pipeline:upgrade` and `bin/rails db:migrate` to add the dashboard indexes. See `docs/dashboard.md` for recovery steps if a concurrent index build is interrupted.
+- GoodJob may remove timing rows for early steps of a still-running pipeline; those steps render `—` rather than raising or issuing individual lookups.
+
+## [0.4.0] - 2026-04-02
+
+### Performance
+
+- **Bulk root step enqueuing** — pipelines with multiple root steps now enqueue all of them via `GoodJob::Batch.enqueue_all` in a fixed number of queries instead of ~9 queries per step. Both `Runner#enqueue_root_steps` and `ChainCoordinator#start_pipeline` use the new `Coordinator.bulk_enqueue_steps` method.
+
+### Added
+
+- **Configurable queue names for internal jobs** — new `coordination_queue_name` and `callback_queue_name` settings control which queues `StepFinishedJob`, `PipelineReconciliationJob`, and `PipelineCallbackJob` run on. Configurable globally (`GoodPipeline.coordination_queue_name = "x"`) and per-pipeline via the class DSL. Defaults to `"good_pipeline_coordination"` and `"good_pipeline_callbacks"`.
+- **`Coordinator.bulk_enqueue_steps`** — public method that loads pending steps, partitions branch steps for individual handling, and bulk-enqueues the rest via `Batch.enqueue_all`. Invalid job classes are failed individually without blocking valid steps.
+
+### Changed
+
+- **Minimum GoodJob version** — bumped from `>= 3.10` to `>= 4.14` (required for `Batch.enqueue_all`).
+- **`run_pipeline_to_completion` test helper** — extracted from 3 integration test files into `test_helper.rb`.
+
 ## [0.3.1] - 2026-03-26
 
 ### Added

data/README.md

@@ -2,14 +2,14 @@
 
 DAG-based job pipeline orchestration for Rails, built on [GoodJob](https://github.com/bensheldon/good_job).
 
-Define multi-step workflows as directed acyclic graphs, where each step is a GoodJob job. GoodPipeline handles dependency resolution, parallel execution, failure strategies, pipeline chaining, and lifecycle callbacks. It also ships with a web dashboard.
+Define multi-step workflows as directed acyclic graphs — not linear chains. Steps run in parallel when they can and wait for dependencies when they must. GoodPipeline handles dependency resolution, parallel execution, failure strategies, conditional branching, pipeline chaining, and lifecycle callbacks. It also ships with a web dashboard.
 
 ## Requirements
 
 - Ruby >= 3.2
-- Rails >= 7.1
+- Rails >= 7.2
 - PostgreSQL
-- GoodJob >= 3.10 with `preserve_job_records = true`
+- GoodJob >= 4.14 with `preserve_job_records = true`
 
 ## Installation
 
@@ -26,6 +26,15 @@ bin/rails generate good_pipeline:install
 bin/rails db:migrate
 ```
 
+When upgrading an existing application to GoodPipeline 0.5, add the dashboard indexes before serving a large execution history:
+
+```bash
+bin/rails generate good_pipeline:upgrade
+bin/rails db:migrate
+```
+
+The upgrade generator is idempotent: if its dashboard-index migration already exists, a second invocation reports a no-op instead of creating another file.
+
 GoodPipeline requires GoodJob to preserve job records. Add this to your GoodJob configuration:
 
 ```ruby
@@ -93,6 +102,22 @@ run :step_key, JobClass,
   enqueue:    { queue: :media, priority: 10 }  # options passed to job.enqueue()
 ```
 
+### Phase barriers
+
+Use `barrier` when every entry into the next declaration phase must wait for the whole preceding phase:
+
+```ruby
+run :fetch_users,  FetchUsersJob
+run :fetch_orders, FetchOrdersJob
+
+barrier
+
+run :index_users,  IndexUsersJob
+run :index_orders, IndexOrdersJob
+```
+
+The barrier is a persisted structural step, not an ActiveJob. It is resolved synchronously after every step in the preceding phase becomes terminal, creates no GoodJob record, and appears as a Barrier node in the dashboard. Normal failure semantics apply: `:ignore` failures permit progress, while a permanently unsatisfied dependency skips the barrier and the later phase.
+
 ### Failure strategies
 
 Set at the pipeline level with `failure_strategy`:
@@ -149,7 +174,7 @@ branch :quality_check, after: :analyze, by: :needs_processing do
 end
 ```
 
-The dashboard renders branches as diamond decision nodes with labeled edges.
+The dashboard renders branches as diamond decision nodes with labeled edges and barriers as structural synchronization nodes.
 
 ### Pipeline chaining
 
@@ -176,7 +201,7 @@ GoodPipeline.run(
 ).then(MergeMediaPipeline, with: { video_id: 123, audio_id: 456 })
 ```
 
-If an upstream pipeline fails or halts, downstream pipelines are automatically skipped.
+If an upstream pipeline fails, halts, is canceled, or is skipped, downstream pipelines are automatically skipped.
 
 ### Monitoring
 
@@ -211,14 +236,45 @@ GoodPipeline includes a mountable web dashboard for inspecting pipeline executio
 
 ```ruby
 # config/routes.rb
+# Protect this mount with your application's administrator authentication.
 mount GoodPipeline::Engine => "/good_pipeline"
 ```
 
+The engine does not provide authentication. Treat the dashboard as an admin-only interface and see [Securing the dashboard](docs/dashboard.md#securing-the-dashboard) for mount examples.
+
+Pipeline mutation controls are read-only by default. After protecting the mount, enable cancellation and re-running explicitly:
+
+```ruby
+# config/initializers/good_pipeline.rb
+GoodPipeline.dashboard_mutations_enabled = true
+```
+
+This setting only enables dashboard actions; it does not authenticate or authorize visitors. The theme preference remains available while pipeline mutations are disabled.
+
 The dashboard provides:
 
-- Pipeline Executions: filterable list with status tabs and pipeline type dropdown
-- Pipeline Details: steps table, DAG visualization, chain links, error info
-- Pipeline Definitions: catalog of all pipeline types with their DAG structure
+- Pipeline executions with composable type, status, time, and text filters, offset pagination, live status counts, and expandable step timelines
+- Operational KPIs for the selected pipeline type, including current activity, fixed-window failure and duration statistics, and a 14-day sparkline
+- Pipeline details with GoodJob links, step errors, chain links, a stage timeline, and an interactive DAG
+- A definition catalog with declared dependencies and structural DAG or stage views
+
+Dark is the default theme in 0.5. The topbar toggle persists a light or dark preference in a permanent same-site cookie. Dashboard styles and JavaScript ship with the gem; Mermaid and web fonts are loaded from their CDNs, so there is no application-side asset build step.
+
+Large executions remain readable: rows with more than 12 steps use an aggregate status bar, and DAGs with more than 60 steps initially show a stage view. A full graph remains available up to Mermaid's 1,000-edge safety limit. Above that limit, the stage view stays available and full rendering is disabled explicitly.
+
+### Canceling a pipeline
+
+Dashboard cancellation is graceful: it stops future DAG scheduling, not work already handed to GoodJob. A pending pipeline becomes `canceled` immediately. A running pipeline becomes `canceling`, and its `pending` steps become `canceled`; jobs that are already enqueued, scheduled, or retrying run normally and retain their actual `succeeded`, `failed`, or `halted` outcomes. No GoodJob records are changed and no worker is force-terminated.
+
+After the last enqueued job finishes, the pipeline becomes `canceled`. Until then, `canceling` is an active, nonterminal state. A pipeline can remain `canceling` indefinitely if an enqueued job never reaches a terminal outcome.
+
+### Re-running a pipeline
+
+The dashboard can re-run a terminal pipeline (`succeeded`, `failed`, `halted`, `skipped`, or `canceled`). A re-run is a new standalone execution, not a retry or resumption of the historical one. It starts from the root steps using the source execution's stored JSON parameters and the pipeline's current Ruby definition, so code changes made since the source ran are applied.
+
+The source execution, its steps, jobs, callbacks, and status remain unchanged. Pipeline-chain relationships are not copied: upstream pipelines are not attached to the new execution, and downstream pipelines are not re-run. Normal branching and failure rules still apply, and jobs, callbacks, and external side effects may run again. Each confirmed submission intentionally creates another execution.
+
+If the pipeline class has been removed, the stored parameters are no longer compatible, or the current definition is invalid, the dashboard creates nothing and reports that the pipeline could not be re-run. Re-run controls remain disabled while an execution is `pending`, `running`, or `canceling`.
 
 ### Pipeline Executions
 
@@ -232,12 +288,12 @@ The dashboard provides:
 
 ![Pipeline Definitions](docs/screenshots/definitions.png)
 
-No build step. Uses Pico CSS and Mermaid.js from CDN.
-
 ## Cleanup
 
 GoodPipeline automatically cleans up old terminal pipelines when GoodJob runs its own cleanup cycle. No configuration needed, it uses GoodJob's retention period (default 14 days).
 
+Pending, running, and canceling pipelines are intentionally retained; canceled pipelines are terminal and follow the normal retention window. GoodJob may still remove old job rows belonging to a long-running or canceling pipeline, so timing for those steps appears as `—` in the dashboard after the retention window; the pipeline and step coordination records remain available.
+
 To configure the retention period, set GoodJob's option:
 
 ```ruby

data/app/controllers/good_pipeline/frontends_controller.rb

@@ -2,12 +2,17 @@
 
 module GoodPipeline
   class FrontendsController < ApplicationController
+    # Rails' same-origin JavaScript response check treats an engine asset served
+    # through a controller like an executable action response. These files are
+    # public, versioned static assets and never read or mutate session state.
+    skip_forgery_protection only: :static
+
     def static
       file_name = "#{sanitized_id}.#{sanitized_format}"
       file_path = assets_directory.join(file_name)
 
       if file_path.exist?
-        expires_in 1.year, public: true
+        apply_cache_headers
         send_file file_path, disposition: :inline
       else
         head :not_found
@@ -16,6 +21,18 @@ module GoodPipeline
 
     private
 
+    # The asset URL embeds GoodPipeline::VERSION, so a released build is immutable
+    # and safe to cache for a year. In development that version does not change
+    # between edits, which would otherwise pin the browser to a stale stylesheet
+    # for the life of the release.
+    def apply_cache_headers
+      if Rails.env.development?
+        response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
+      else
+        expires_in 1.year, public: true
+      end
+    end
+
     def sanitized_id
       params[:id].to_s.gsub(/[^a-zA-Z0-9_-]/, "")
     end

data/app/controllers/good_pipeline/pipelines_controller.rb

@@ -1,58 +1,276 @@
 # frozen_string_literal: true
 
 module GoodPipeline
-  class PipelinesController < ApplicationController
+  class PipelinesController < ApplicationController # rubocop:disable Metrics/ClassLength
     PAGE_SIZE = 25
 
-    def index
-      @status = params[:status].presence
-      @pipeline_type = params[:pipeline_type].presence
-      @pipeline_types = PipelineRecord.distinct.pluck(:type).sort
-      counts_scope = @pipeline_type ? PipelineRecord.where(type: @pipeline_type) : PipelineRecord
-      @status_counts = counts_scope.group(:status).count
-      @total_count = @status_counts.values.sum
-      load_pipelines
+    before_action :require_dashboard_mutations_enabled!, only: %i[cancel rerun]
+
+    SidebarEntry = Data.define(
+      :type,
+      :id,
+      :on_failure_strategy,
+      :run_count,
+      :step_count,
+      :has_branch,
+      :large
+    ) do
+      alias_method :strategy, :on_failure_strategy
+    end
+
+    def index # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @filters = Dashboard::FilterSet.from_params(params)
+      @now = Time.current
+
+      base_scope = apply_type_time_search(PipelineRecord.all)
+      @status_counts = base_scope.group(:status).count
+      @total = @filters.status == "all" ? @status_counts.values.sum : @status_counts.fetch(@filters.status, 0)
+
+      last_page = [(@total.to_f / PAGE_SIZE).ceil, 1].max
+      current_page = @filters.page.clamp(1, last_page)
+      @page = { current: current_page, last: last_page, total: @total, per_page: PAGE_SIZE }
+
+      list_scope = @filters.status == "all" ? base_scope : base_scope.where(status: @filters.status)
+      @pipelines = list_scope.order(created_at: :desc, id: :desc)
+                             .offset((current_page - 1) * PAGE_SIZE)
+                             .limit(PAGE_SIZE)
+                             .to_a
+
+      load_page_steps
+      load_expanded_row
+      @sidebar_entries = load_sidebar_entries
+      @pipeline_types = @sidebar_entries.map(&:type)
+      @retention_seconds = GoodJob.configuration.cleanup_preserved_jobs_before_seconds_ago
+      @kpis = Dashboard::KpiCalculator.new(pipeline_type: @filters.pipeline_type, now: @now).call
+      @connection_info = Dashboard::ConnectionInfo.fetch
     end
 
-    def definitions
-      pipeline_types = PipelineRecord.distinct.pluck(:type).sort
-      pipeline_ids = pipeline_types.filter_map do |type|
-        PipelineRecord.where(type: type).order(created_at: :desc).pick(:id)
+    def definitions # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @now = Time.current
+      @pipelines = PipelineRecord
+                   .select("DISTINCT ON (type) good_pipeline_pipelines.*")
+                   .order(:type, created_at: :desc, id: :desc)
+                   .to_a
+      load_graph_records(@pipelines)
+      @run_counts = PipelineRecord.group(:type).count
+      @definition_runs = @run_counts
+      @definition_stages_by_pipeline = @pipelines.to_h do |pipeline|
+        stages = Dashboard::DefinitionStages.new(
+          steps: @steps_by_pipeline.fetch(pipeline.id, []),
+          dependencies: @dependencies_by_pipeline.fetch(pipeline.id, [])
+        ).call
+        [pipeline.id, stages]
       end
-      @pipelines = PipelineRecord.includes(steps: :upstream_steps, dependencies: %i[step depends_on_step])
-                                 .where(id: pipeline_ids)
-                                 .sort_by(&:type)
+      @definition_stages = @definition_stages_by_pipeline
+      @connection_info = Dashboard::ConnectionInfo.fetch
     end
 
-    def show
-      scope = PipelineRecord.includes(
-        :upstream_pipelines, :downstream_pipelines,
-        steps: :upstream_steps,
-        dependencies: %i[step depends_on_step]
-      )
-      @pipeline = scope.find(params[:id])
+    def show # rubocop:disable Metrics/MethodLength
+      @now = Time.current
+      @pipeline = PipelineRecord.find(params[:id])
+      load_graph_records([@pipeline])
+      @steps = @steps_by_pipeline.fetch(@pipeline.id, [])
+      @dependencies = @dependencies_by_pipeline.fetch(@pipeline.id, [])
+      @step_timings = Dashboard::StepTimings.new(@steps).call
+      @stage_lanes = Dashboard::StageLanes.new(
+        pipeline: @pipeline,
+        steps: @steps,
+        dependencies: @dependencies,
+        timings: @step_timings,
+        now: @now
+      ).call
+      load_chain_records
+      @connection_info = Dashboard::ConnectionInfo.fetch
+    end
+
+    def cancel # rubocop:disable Metrics/MethodLength
+      @pipeline = Coordinator.cancel_pipeline(params[:id])
+
+      notice = if @pipeline.status.to_s == "canceled"
+                 "Pipeline canceled."
+               else
+                 "Pipeline cancellation requested."
+               end
+      redirect_back fallback_location: pipeline_path(@pipeline), allow_other_host: false,
+                    notice: notice, status: :see_other
+    rescue GoodPipeline::CancellationConflict => error
+      redirect_back fallback_location: pipeline_path(error.pipeline_id),
+                    allow_other_host: false,
+                    alert: "Pipeline is already #{error.status} and cannot be canceled.",
+                    status: :see_other
+    end
+
+    def rerun # rubocop:disable Metrics/MethodLength
+      source = PipelineRecord.find(params[:id])
+
+      unless source.terminal?
+        return redirect_back fallback_location: pipeline_path(source), allow_other_host: false,
+                             alert: "Only finished pipelines can be re-run.", status: :see_other
+      end
+
+      pipeline = build_rerun_pipeline(source)
+      unless pipeline
+        return redirect_back fallback_location: pipeline_path(source), allow_other_host: false,
+                             alert: "Pipeline could not be re-run with its stored parameters and current definition.",
+                             status: :see_other
+      end
+
+      rerun = Runner.call(pipeline)
+      redirect_to pipeline_path(rerun), notice: "Pipeline re-run started.", status: :see_other
     end
 
     private
 
-    def load_pipelines
-      scope = PipelineRecord.order(created_at: :desc, id: :desc)
-      scope = scope.where(status: @status) if @status
-      scope = scope.where(type: @pipeline_type) if @pipeline_type
-      scope = apply_keyset_pagination(scope)
-      records = scope.limit(PAGE_SIZE + 1).to_a
-      @has_next_page = records.size > PAGE_SIZE
-      @pipelines = records.first(PAGE_SIZE)
+    def build_rerun_pipeline(source)
+      pipeline_class = source.type.safe_constantize
+      unless pipeline_class.is_a?(Class) && pipeline_class < GoodPipeline::Pipeline
+        raise InvalidPipelineError, "#{source.type} is not an available GoodPipeline::Pipeline"
+      end
+      raise InvalidPipelineError, "stored pipeline parameters must be an object" unless source.params.is_a?(Hash)
+
+      pipeline_class.build(**source.params.symbolize_keys)
+    rescue ArgumentError, NameError, NotImplementedError, GoodPipeline::Error => error
+      Rails.error.report(error, handled: true, context: { good_pipeline_source_id: source.id })
+      nil
+    end
+
+    def require_dashboard_mutations_enabled!
+      head :forbidden unless GoodPipeline.dashboard_mutations_enabled?
     end
 
-    def apply_keyset_pagination(scope)
-      return scope unless params[:after_created_at].present? && params[:after_id].present?
+    def apply_type_time_search(scope)
+      scope = scope.where(type: @filters.pipeline_type) if @filters.pipeline_type
+      cutoff = @filters.time_cutoff(@now)
+      scope = scope.where("created_at >= ?", cutoff) if cutoff
+      return scope if @filters.query.blank?
 
+      escaped = ActiveRecord::Base.sanitize_sql_like(@filters.query.strip)
       scope.where(
-        "(created_at, id) < (?, ?)",
-        params[:after_created_at],
-        params[:after_id]
+        "CAST(good_pipeline_pipelines.id AS text) ILIKE ? OR good_pipeline_pipelines.type ILIKE ?",
+        "#{escaped}%",
+        "%#{escaped}%"
       )
     end
+
+    def load_page_steps
+      page_ids = @pipelines.map(&:id)
+      steps = StepRecord.where(pipeline_id: page_ids).order(:created_at, :id).to_a
+      @steps_by_pipeline = steps.group_by(&:pipeline_id)
+      attach_steps(@pipelines, @steps_by_pipeline)
+    end
+
+    def load_expanded_row # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      @expanded_pipeline = @pipelines.find { |pipeline| pipeline.id.to_s == @filters.expanded.to_s }
+      return unless @expanded_pipeline
+
+      @expanded_steps = @steps_by_pipeline.fetch(@expanded_pipeline.id, [])
+      @expanded_dependencies = DependencyRecord.where(pipeline_id: @expanded_pipeline.id).order(:id).to_a
+      hydrate_dependencies(@expanded_dependencies, @expanded_steps)
+      @step_timings = Dashboard::StepTimings.new(@expanded_steps).call
+      @stage_lanes = Dashboard::StageLanes.new(
+        pipeline: @expanded_pipeline,
+        steps: @expanded_steps,
+        dependencies: @expanded_dependencies,
+        timings: @step_timings,
+        now: @now
+      ).call
+    end
+
+    def load_sidebar_entries # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      latest = PipelineRecord
+               .select(<<~SQL.squish)
+                 DISTINCT ON (type)
+                 type, id, on_failure_strategy,
+                 COUNT(*) OVER (PARTITION BY type) AS run_count
+               SQL
+               .order(:type, created_at: :desc, id: :desc)
+               .to_a
+
+      ids = latest.map(&:id)
+      quoted_branch_class = StepRecord.connection.quote(GoodPipeline::BRANCH_JOB_CLASS)
+      metadata = StepRecord.where(pipeline_id: ids)
+                           .group(:pipeline_id)
+                           .pluck(
+                             :pipeline_id,
+                             Arel.sql("COUNT(*)"),
+                             Arel.sql("BOOL_OR(job_class = #{quoted_branch_class})")
+                           )
+                           .to_h { |pipeline_id, count, has_branch| [pipeline_id, [count.to_i, has_branch]] }
+
+      latest.map do |pipeline|
+        step_count, has_branch = metadata.fetch(pipeline.id, [0, false])
+        SidebarEntry.new(
+          type: pipeline.type,
+          id: pipeline.id,
+          on_failure_strategy: pipeline.on_failure_strategy,
+          run_count: pipeline.attributes.fetch("run_count").to_i,
+          step_count: step_count,
+          has_branch: has_branch,
+          large: step_count > 60
+        )
+      end
+    end
+
+    def load_graph_records(pipelines) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      pipeline_ids = pipelines.map(&:id)
+      steps = StepRecord.where(pipeline_id: pipeline_ids).order(:created_at, :id).to_a
+      dependencies = DependencyRecord.where(pipeline_id: pipeline_ids).order(:id).to_a
+
+      @steps_by_pipeline = steps.group_by(&:pipeline_id)
+      @dependencies_by_pipeline = dependencies.group_by(&:pipeline_id)
+      attach_steps(pipelines, @steps_by_pipeline)
+
+      pipelines.each do |pipeline|
+        pipeline_dependencies = @dependencies_by_pipeline.fetch(pipeline.id, [])
+        hydrate_dependencies(pipeline_dependencies, @steps_by_pipeline.fetch(pipeline.id, []))
+        association = pipeline.association(:dependencies)
+        association.target = pipeline_dependencies
+        association.loaded!
+      end
+    end
+
+    def attach_steps(pipelines, steps_by_pipeline)
+      pipelines.each do |pipeline|
+        association = pipeline.association(:steps)
+        association.target = steps_by_pipeline.fetch(pipeline.id, [])
+        association.loaded!
+      end
+    end
+
+    def hydrate_dependencies(dependencies, steps)
+      by_id = steps.index_by(&:id)
+      dependencies.each do |dependency|
+        step_association = dependency.association(:step)
+        step_association.target = by_id[dependency.step_id]
+        step_association.loaded!
+        upstream_association = dependency.association(:depends_on_step)
+        upstream_association.target = by_id[dependency.depends_on_step_id]
+        upstream_association.loaded!
+      end
+    end
+
+    def load_chain_records # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      chains = ChainRecord.where(upstream_pipeline_id: @pipeline.id)
+                          .or(ChainRecord.where(downstream_pipeline_id: @pipeline.id))
+                          .to_a
+      other_ids = chains.flat_map { |chain| [chain.upstream_pipeline_id, chain.downstream_pipeline_id] }
+                        .uniq
+                        .excluding(@pipeline.id)
+      related = PipelineRecord.where(id: other_ids).index_by(&:id)
+
+      @upstream_pipelines = chains.filter_map do |chain|
+        related[chain.upstream_pipeline_id] if chain.downstream_pipeline_id == @pipeline.id
+      end
+      @downstream_pipelines = chains.filter_map do |chain|
+        related[chain.downstream_pipeline_id] if chain.upstream_pipeline_id == @pipeline.id
+      end
+
+      upstream = @pipeline.association(:upstream_pipelines)
+      upstream.target = @upstream_pipelines
+      upstream.loaded!
+      downstream = @pipeline.association(:downstream_pipelines)
+      downstream.target = @downstream_pipelines
+      downstream.loaded!
+    end
   end
 end

data/app/controllers/good_pipeline/themes_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GoodPipeline
+  class ThemesController < ApplicationController
+    THEMES = %w[dark light].freeze
+
+    def update
+      theme = params[:theme].to_s
+      return head :unprocessable_entity unless THEMES.include?(theme)
+
+      cookies.permanent[:good_pipeline_theme] = { value: theme, same_site: :lax }
+      head :no_content
+    end
+  end
+end