good_pipeline 0.4.0 → 0.6.0

data/app/helpers/good_pipeline/mermaid_diagram_builder.rb

@@ -1,106 +1,265 @@
 # frozen_string_literal: true
 
 module GoodPipeline
-  class MermaidDiagramBuilder
-    DEFINITION_CLASSES = [
-      "  classDef step fill:#4a90d9,color:#fff,stroke:#3a7bc8",
-      "  classDef branch fill:#ff9800,color:#fff,stroke:#f57c00",
-      "  classDef terminal fill:#1a1a2e,color:#fff,stroke:#1a1a2e"
-    ].freeze
-
-    STATUS_CLASSES = [
-      "  classDef pending fill:#9e9e9e,color:#fff",
-      "  classDef enqueued fill:#2196f3,color:#fff",
-      "  classDef succeeded fill:#4caf50,color:#fff",
-      "  classDef failed fill:#f44336,color:#fff",
-      "  classDef skipped fill:#bdbdbd,color:#333",
-      "  classDef skipped_by_branch fill:#bdbdbd,color:#333",
-      "  classDef halted fill:#8bc34a,color:#fff",
-      "  classDef branch fill:#ff9800,color:#fff,stroke:#f57c00",
-      "  classDef terminal fill:#1a1a2e,color:#fff,stroke:#1a1a2e"
-    ].freeze
-
-    def initialize(pipeline)
+  # Produces only the Mermaid graph body. Theme-dependent class definitions are
+  # appended by dashboard.js so changing theme can never reuse stale colours.
+  # User-controlled step keys are labels only; generated n0..nN identifiers are
+  # used everywhere in the graph syntax.
+  class MermaidDiagramBuilder # rubocop:disable Metrics/ClassLength
+    MAX_EDGES = 1_000
+    MAX_LABEL_LENGTH = 64
+    STATUSES = %w[pending running enqueued succeeded failed halted canceled skipped skipped_by_branch].freeze
+    Edge = Struct.new(:upstream, :downstream, keyword_init: true)
+    private_constant :Edge
+
+    def initialize(pipeline) # rubocop:disable Metrics/AbcSize
       @pipeline = pipeline
+      @steps = ordered_steps(pipeline.steps)
+      @dependencies = Array(pipeline.dependencies)
+      @step_by_token = @steps.to_h { |step| [step_token(step), step] }
+      @node_id_by_token = @steps.each_with_index.to_h { |step, index| [step_token(step), "n#{index}"] }
+      @node_id_by_key = @steps.to_h { |step| [step.key.to_s, @node_id_by_token.fetch(step_token(step))] }
+      @terminal_node_id = "n#{@steps.length}"
+      @edges = dependency_edges
+      @edge_count = @dependencies.length
     end
 
     def definition_diagram
-      lines = ["graph TD"]
-      append_step_nodes(lines) { |step| step.branch_step? ? "branch" : "step" }
-      append_edges(lines)
-      append_terminal_node(lines)
-      lines.concat(DEFINITION_CLASSES)
-      lines.join("\n")
+      build_diagram do |step|
+        next "branch" if branch_step?(step)
+        next "barrier" if barrier_step?(step)
+
+        "step"
+      end
     end
 
     def status_diagram
-      lines = ["graph TD"]
-      append_step_nodes(lines) { |step| step.branch_step? ? "branch" : step.coordination_status }
-      append_edges(lines)
-      append_terminal_node(lines)
-      lines.concat(STATUS_CLASSES)
-      lines.join("\n")
+      build_diagram do |step|
+        branch_step?(step) ? "branch" : safe_status(step)
+      end
+    end
+
+    def diagram(mode: :status)
+      mode.to_sym == :definition ? definition_diagram : status_diagram
+    end
+
+    def overflow? = edge_count > MAX_EDGES
+    alias edge_overflow? overflow?
+    def renderable? = !overflow?
+
+    # The number of actual Mermaid arrows includes synthetic terminal and
+    # empty-branch-arm edges. `edge_count` intentionally remains the persisted
+    # DAG dependency count used by the product's >1000-edge contract.
+    def rendered_edge_count
+      @rendered_edge_count ||= begin
+        terminal_edges = visible_terminal_steps.length
+        empty_arm_edges = empty_arm_edge_lines.length
+        visible_dependency_edges.length + terminal_edges + empty_arm_edges
+      end
+    end
+
+    def node_ids
+      @node_id_by_key.dup.freeze
+    end
+
+    attr_reader :edge_count, :terminal_node_id
+
+    def payload(mode: :status)
+      {
+        graph: diagram(mode: mode),
+        edge_count: edge_count,
+        overflow: overflow?
+      }.freeze
     end
 
     private
 
-    def append_step_nodes(lines)
-      @pipeline.steps.each do |step|
+    def build_diagram # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      lines = ["graph TD"]
+      @steps.each do |step|
+        node_id = node_id_for(step)
+        label = escape_label(Dashboard::Topology.label_for(step))
         css_class = yield(step)
-        lines << if step.branch_step?
-                   "  #{step.key}{\"#{step.key}\"}:::#{css_class}"
+        lines << if barrier_step?(step)
+                   %(  #{node_id}[["#{label}"]]:::#{css_class})
+                 elsif branch_step?(step)
+                   %(  #{node_id}{"#{label}"}:::#{css_class})
                  else
-                   "  #{step.key}(\"#{step.key}\"):::#{css_class}"
+                   %(  #{node_id}("#{label}"):::#{css_class})
                  end
       end
+
+      visible_dependency_edges.each { |edge| lines << dependency_edge_line(edge) }
+      lines << %(  #{@terminal_node_id}((" ")):::terminal)
+      visible_terminal_steps.each { |step| lines << "  #{node_id_for(step)} --> #{@terminal_node_id}" }
+      lines.concat(empty_arm_edge_lines)
+      lines.join("\n")
     end
 
-    def append_edges(lines)
-      @pipeline.dependencies.each do |dependency|
-        upstream = dependency.depends_on_step
-        downstream = dependency.step
-        lines << if upstream.branch_step? && downstream.branch_arm_step?
-                   "  #{upstream.key} -->|#{downstream.branch_arm}| #{downstream.key}"
-                 else
-                   "  #{upstream.key} --> #{downstream.key}"
-                 end
+    def dependency_edges
+      @dependencies.filter_map do |dependency|
+        upstream_ref, downstream_ref = dependency_endpoints(dependency)
+        upstream = resolve_step(upstream_ref)
+        downstream = resolve_step(downstream_ref)
+        Edge.new(upstream: upstream, downstream: downstream).freeze if upstream && downstream
       end
     end
 
-    def append_terminal_node(lines)
-      has_downstream_ids = @pipeline.dependencies.to_set { |dependency| dependency.depends_on_step.id }
-      terminal_steps = @pipeline.steps.reject { |step| has_downstream_ids.include?(step.id) }
+    def dependency_edge_line(edge)
+      from = node_id_for(edge.upstream)
+      to = node_id_for(edge.downstream)
+      if branch_step?(edge.upstream) && branch_arm_step?(edge.downstream)
+        label = escape_edge_label(edge.downstream.branch_arm)
+        label.empty? ? "  #{from} --> #{to}" : "  #{from} -->|#{label}| #{to}"
+      else
+        "  #{from} --> #{to}"
+      end
+    end
 
-      lines << "  end_node((\" \")):::terminal"
-      terminal_steps.each { |step| lines << "  #{step.key} --> end_node" }
+    def terminal_steps
+      @terminal_steps ||= begin
+        has_downstream = @edges.to_set { |edge| step_token(edge.upstream) }
+        @steps.reject { |step| has_downstream.include?(step_token(step)) }
+      end
+    end
 
-      append_empty_arm_edges(lines)
+    def visible_dependency_edges
+      @visible_dependency_edges ||= @edges.reject { |edge| hidden_dependency_edge?(edge) }
     end
 
-    def append_empty_arm_edges(lines) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-      arm_step_keys_by_branch = @pipeline.steps.select(&:branch_arm_step?).group_by(&:branch_key)
+    def hidden_dependency_edge?(edge)
+      all_empty_branch?(edge.upstream) ||
+        (branch_step?(edge.upstream) && barrier_step?(edge.downstream))
+    end
 
-      @pipeline.steps.select(&:branch_step?).each do |branch_step|
-        next if branch_step.empty_arms.blank?
+    def visible_terminal_steps
+      @visible_terminal_steps ||= terminal_steps.reject { |step| all_empty_branch?(step) }
+    end
 
-        targets = find_post_branch_targets(branch_step, arm_step_keys_by_branch)
+    def empty_arm_edge_lines # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      @empty_arm_edge_lines ||= begin
+        branch_arm_steps = @steps.select { |step| branch_arm_step?(step) }.group_by do |step|
+          step.branch_key.to_s
+        end
 
-        branch_step.empty_arms.each do |arm_name|
-          if targets.any?
-            targets.each { |target| lines << "  #{branch_step.key} -->|#{arm_name}| #{target.key}" }
-          else
-            lines << "  #{branch_step.key} -->|#{arm_name}| end_node"
+        @steps.select { |step| branch_step?(step) }.flat_map do |branch_step|
+          Array(branch_step.empty_arms).flat_map do |arm_name|
+            targets = post_branch_targets(branch_step, branch_arm_steps)
+            label = escape_edge_label(arm_name)
+            if targets.empty?
+              [labelled_edge(node_id_for(branch_step), @terminal_node_id, label)]
+            else
+              targets.map { |target| labelled_edge(node_id_for(branch_step), node_id_for(target), label) }
+            end
           end
         end
       end
     end
 
-    def find_post_branch_targets(branch_step, arm_step_keys_by_branch)
-      arm_keys = (arm_step_keys_by_branch[branch_step.key] || []).to_set(&:key)
+    def post_branch_targets(branch_step, branch_arm_steps) # rubocop:disable Metrics/AbcSize
+      arm_tokens = Array(branch_arm_steps[branch_step.key.to_s]).to_set { |step| step_token(step) }
+      return direct_branch_targets(branch_step) if arm_tokens.empty?
+
+      target_tokens = @edges.filter_map do |edge|
+        upstream_token = step_token(edge.upstream)
+        downstream_token = step_token(edge.downstream)
+        downstream_token if arm_tokens.include?(upstream_token) && !arm_tokens.include?(downstream_token)
+      end.to_set
+      @steps.select { |step| target_tokens.include?(step_token(step)) }
+    end
+
+    def direct_branch_targets(branch_step)
+      target_tokens = @edges.filter_map do |edge|
+        step_token(edge.downstream) if step_token(edge.upstream) == step_token(branch_step)
+      end.to_set
+      @steps.select { |step| target_tokens.include?(step_token(step)) }
+    end
+
+    def labelled_edge(from, to, label)
+      label.empty? ? "  #{from} --> #{to}" : "  #{from} -->|#{label}| #{to}"
+    end
+
+    def dependency_endpoints(dependency) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      if dependency.is_a?(Hash)
+        upstream = dependency[:depends_on_step_id] || dependency["depends_on_step_id"] ||
+                   dependency[:from] || dependency["from"]
+        downstream = dependency[:step_id] || dependency["step_id"] ||
+                     dependency[:to] || dependency["to"]
+        return [upstream, downstream]
+      end
+      return [dependency[0], dependency[1]] if dependency.is_a?(Array)
+
+      upstream = dependency.depends_on_step_id if dependency.respond_to?(:depends_on_step_id)
+      downstream = dependency.step_id if dependency.respond_to?(:step_id)
+      upstream ||= dependency.depends_on_step if dependency.respond_to?(:depends_on_step)
+      downstream ||= dependency.step if dependency.respond_to?(:step)
+      [upstream, downstream]
+    end
+
+    def resolve_step(reference)
+      return if reference.nil?
+
+      token = step_token(reference)
+      @step_by_token[token] || @steps.find { |step| step.key.to_s == reference.to_s }
+    end
+
+    def ordered_steps(steps)
+      records = Array(steps)
+      return records unless records.all? do |step|
+        step.respond_to?(:created_at) && step.respond_to?(:id) && step.created_at && step.id
+      end
+
+      records.sort_by { |step| [step.created_at, step.id.to_s] }
+    end
+
+    def step_token(step)
+      return unless step
+      return step.to_s unless step.respond_to?(:key)
+
+      id = step.id if step.respond_to?(:id)
+      (id.nil? || id.to_s.empty? ? step.key : id).to_s
+    end
+
+    def node_id_for(step)
+      @node_id_by_token.fetch(step_token(step))
+    end
+
+    def branch_step?(step)
+      return step.branch_step? if step.respond_to?(:branch_step?)
+
+      step.respond_to?(:job_class) && step.job_class.to_s == GoodPipeline::BRANCH_JOB_CLASS
+    end
 
-      @pipeline.steps.select do |step|
-        !arm_keys.include?(step.key) && step.upstream_steps.any? { |upstream| arm_keys.include?(upstream.key) }
+    def branch_arm_step?(step)
+      return step.branch_arm_step? if step.respond_to?(:branch_arm_step?)
+
+      step.respond_to?(:branch_arm) && !step.branch_arm.to_s.empty?
+    end
+
+    def barrier_step?(step)
+      Dashboard::Topology.barrier_step?(step)
+    end
+
+    def all_empty_branch?(step)
+      return false unless branch_step?(step) && Array(step.empty_arms).any?
+
+      @steps.none? do |candidate|
+        branch_arm_step?(candidate) && candidate.branch_key.to_s == step.key.to_s
       end
     end
+
+    def safe_status(step)
+      status = step.respond_to?(:coordination_status) ? step.coordination_status.to_s : "pending"
+      STATUSES.include?(status) ? status : "pending"
+    end
+
+    def escape_label(value)
+      clean = value.to_s.gsub(/[\u0000-\u001f\u007f]/, "").gsub('"', "#quot;")
+      clean.each_char.first(MAX_LABEL_LENGTH).join
+    end
+
+    def escape_edge_label(value)
+      escape_label(value).gsub(/[^\w .:-]/, "").each_char.first(MAX_LABEL_LENGTH).join
+    end
   end
 end

data/app/helpers/good_pipeline/pipelines_helper.rb

@@ -1,11 +1,32 @@
 # frozen_string_literal: true
 
 module GoodPipeline
-  module PipelinesHelper
+  module PipelinesHelper # rubocop:disable Metrics/ModuleLength
+    STATUS_META = {
+      "pending" => { label: "pending", glyph: "\u25CB", var: "--st-pending", variable: "--st-pending" },
+      "running" => { label: "running", glyph: "\u25CF", var: "--st-running", variable: "--st-running" },
+      "enqueued" => { label: "enqueued", glyph: "\u25CF", var: "--st-running", variable: "--st-running" },
+      "canceling" => { label: "canceling", glyph: "\u25D0", var: "--st-canceling", variable: "--st-canceling" },
+      "canceled" => { label: "canceled", glyph: "\u2298", var: "--st-canceled", variable: "--st-canceled" },
+      "succeeded" => { label: "succeeded", glyph: "\u2713", var: "--st-succeeded", variable: "--st-succeeded" },
+      "failed" => { label: "failed", glyph: "\u2717", var: "--st-failed", variable: "--st-failed" },
+      "halted" => { label: "halted", glyph: "\u2298", var: "--st-halted", variable: "--st-halted" },
+      "skipped" => { label: "skipped", glyph: "\u2298", var: "--st-skipped", variable: "--st-skipped" },
+      "skipped_by_branch" => {
+        label: "skipped\u00B7br", glyph: "\u2298", var: "--st-skipped", variable: "--st-skipped"
+      }
+    }.transform_values(&:freeze).freeze
+
+    STATUS_STACK_ORDER = %w[
+      succeeded failed halted enqueued running pending canceled skipped skipped_by_branch
+    ].freeze
+
     STATUS_BADGES = {
       "pending" => "\u25CB Pending",
       "running" => "\u25CF Running",
       "enqueued" => "\u25CF Enqueued",
+      "canceling" => "\u25D0 Canceling",
+      "canceled" => "\u2298 Canceled",
       "succeeded" => "\u2713 Succeeded",
       "failed" => "\u2717 Failed",
       "halted" => "\u2298 Halted",
@@ -18,16 +39,37 @@ module GoodPipeline
       tag.span(label, class: "badge badge-#{status}")
     end
 
+    def status_pill(status)
+      status = status.to_s
+      meta = status_meta(status)
+      tag.span("#{meta[:glyph]} #{meta[:label]}", class: "gp-status-pill gp-status-#{status}")
+    end
+
+    def status_meta(status)
+      status = status.to_s
+      STATUS_META.fetch(status) do
+        { label: status, glyph: "", var: "--st-pending", variable: "--st-pending" }.freeze
+      end
+    end
+
     def humanized_type(pipeline_type)
       pipeline_type.to_s.safe_constantize&.display_name || pipeline_type.to_s.underscore.titleize
     end
 
+    def short_type(pipeline_type)
+      humanized_type(pipeline_type).sub(/\s*Pipeline\z/, "")
+    end
+
+    def step_display_key(step)
+      Dashboard::Topology.label_for(step)
+    end
+
     def relative_time_tag(datetime)
       return "" unless datetime
 
       tag.time(relative_time(datetime),
                datetime: datetime.iso8601,
-               title: datetime.strftime("%Y-%m-%d %H:%M:%S %Z"))
+               title: absolute_time(datetime))
     end
 
     def pipeline_duration(pipeline)
@@ -49,6 +91,14 @@ module GoodPipeline
       MermaidDiagramBuilder.new(pipeline).status_diagram
     end
 
+    def mermaid_edge_count(pipeline)
+      MermaidDiagramBuilder.new(pipeline).edge_count
+    end
+
+    def mermaid_overflow?(pipeline)
+      MermaidDiagramBuilder.new(pipeline).overflow?
+    end
+
     def good_job_step_url(step)
       return nil unless step.good_job_id
 
@@ -58,18 +108,52 @@ module GoodPipeline
       "#{mount_path}/jobs/#{step.good_job_id}"
     end
 
-    def relative_time(datetime)
+    def relative_time(datetime, now: Time.current)
       return "" unless datetime
 
-      distance = (Time.current - datetime).to_i
+      distance = [(now - datetime).to_i, 0].max
       case distance
-      when 0..59 then "just now"
+      when 0..59 then "#{distance}s ago"
       when 60..3599 then "#{distance / 60}m ago"
       when 3600..86_399 then "#{distance / 3600}h ago"
       else "#{distance / 86_400}d ago"
       end
     end
 
+    def absolute_time(datetime)
+      return "" unless datetime
+
+      utc_time = datetime.respond_to?(:getutc) ? datetime.getutc : datetime.in_time_zone("UTC")
+      utc_time.strftime("%Y-%m-%d %H:%M:%SZ")
+    end
+
+    def format_duration(seconds)
+      return "\u2014" if seconds.nil?
+
+      total = [seconds.to_i, 0].max
+      return "#{total}s" if total < 60
+
+      minutes, remaining_seconds = total.divmod(60)
+      return "#{minutes}m #{remaining_seconds}s" if total < 3_600
+
+      hours, remaining_minutes = minutes.divmod(60)
+      "#{hours}h #{remaining_minutes}m"
+    end
+
+    def format_number(number)
+      number.to_i.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+    end
+
+    def step_progress(steps)
+      steps = Array(steps)
+      [steps.count { |step| step.coordination_status.to_s == "succeeded" }, steps.length]
+    end
+
+    def step_progress_title(steps)
+      done, total = step_progress(steps)
+      "#{done} succeeded of #{total} total steps"
+    end
+
     def truncated_params(pipeline_params)
       return "" if pipeline_params.blank?
 

data/app/jobs/good_pipeline/pipeline_callback_job.rb

@@ -21,8 +21,8 @@ module GoodPipeline
         invoke_callback(pipeline, pipeline.on_success_callback, errors)
       when PipelineRecord.statuses[:failed], PipelineRecord.statuses[:halted]
         invoke_callback(pipeline, pipeline.on_failure_callback, errors)
-      when PipelineRecord.statuses[:skipped]
-        # Skipped pipelines only trigger on_complete (already called above)
+      when PipelineRecord.statuses[:skipped], PipelineRecord.statuses[:canceled]
+        # Skipped and canceled pipelines only trigger on_complete (already called above)
       end
 
       raise_callback_errors(errors) if errors.any?

data/app/jobs/good_pipeline/pipeline_reconciliation_job.rb

@@ -3,8 +3,7 @@
 module GoodPipeline
   class PipelineReconciliationJob < ActiveJob::Base
     def perform(batch, _context)
-      pipeline = GoodPipeline::PipelineRecord.find(batch.properties[:pipeline_id])
-      GoodPipeline::Coordinator.recompute_pipeline_status(pipeline)
+      GoodPipeline::Coordinator.recompute_pipeline_status(batch.properties[:pipeline_id])
     end
   end
 end

data/app/jobs/good_pipeline/step_finished_job.rb

@@ -3,8 +3,12 @@
 module GoodPipeline
   class StepFinishedJob < ActiveJob::Base
     def perform(batch, _context)
-      step = GoodPipeline::StepRecord.find(batch.properties[:step_id])
-      GoodPipeline::Coordinator.complete_step(step, succeeded: batch.succeeded?)
+      properties = batch.properties
+      GoodPipeline::Coordinator.complete_step(
+        properties[:step_id],
+        pipeline_id: properties[:pipeline_id],
+        succeeded: batch.succeeded?
+      )
     end
   end
 end

data/app/models/good_pipeline/pipeline_record.rb

@@ -8,20 +8,23 @@ module GoodPipeline
     self.table_name = "good_pipeline_pipelines"
     self.inheritance_column = nil
 
-    TERMINAL_STATUSES = %w[succeeded failed halted skipped].freeze
+    TERMINAL_STATUSES = %w[succeeded failed halted skipped canceled].freeze
 
     VALID_TRANSITIONS = {
-      "pending" => %w[running skipped],
-      "running" => %w[succeeded failed halted]
+      "pending" => %w[running skipped canceled],
+      "running" => %w[succeeded failed halted canceling],
+      "canceling" => %w[canceled]
     }.freeze
 
     enum :status, {
       pending: "pending",
       running: "running",
+      canceling: "canceling",
       succeeded: "succeeded",
       failed: "failed",
       halted: "halted",
-      skipped: "skipped"
+      skipped: "skipped",
+      canceled: "canceled"
     }
 
     enum :on_failure_strategy, { halt: "halt", continue: "continue", ignore: "ignore" }

data/app/models/good_pipeline/step_record.rb

@@ -7,10 +7,10 @@ module GoodPipeline
   class StepRecord < ActiveRecord::Base
     self.table_name = "good_pipeline_steps"
 
-    TERMINAL_COORDINATION_STATUSES = %w[succeeded failed skipped skipped_by_branch halted].freeze
+    TERMINAL_COORDINATION_STATUSES = %w[succeeded failed skipped skipped_by_branch halted canceled].freeze
 
     VALID_COORDINATION_TRANSITIONS = {
-      "pending" => %w[enqueued skipped skipped_by_branch succeeded failed halted],
+      "pending" => %w[enqueued skipped skipped_by_branch succeeded failed halted canceled],
       "enqueued" => %w[succeeded failed halted]
     }.freeze
 
@@ -21,7 +21,8 @@ module GoodPipeline
       failed: "failed",
       skipped: "skipped",
       skipped_by_branch: "skipped_by_branch",
-      halted: "halted"
+      halted: "halted",
+      canceled: "canceled"
     }
 
     enum :on_failure_strategy, { halt: "halt", continue: "continue", ignore: "ignore" }
@@ -54,6 +55,8 @@ module GoodPipeline
              source: :step
 
     def branch_step? = job_class == GoodPipeline::BRANCH_JOB_CLASS
+    def barrier_step? = job_class == GoodPipeline::BARRIER_JOB_CLASS
+    def structural_step? = branch_step? || barrier_step?
     def branch_arm_step? = branch_arm.present?
 
     def duration

data/app/views/good_pipeline/pipelines/_actions.html.erb

@@ -0,0 +1,28 @@
+<%
+  status = pipeline.status.to_s
+  cancel_confirmation = "Cancel this pipeline? Future DAG steps won't be scheduled; enqueued, scheduled, or retrying jobs will continue normally."
+  rerun_confirmation = "Start this pipeline again from the beginning as a new standalone execution? It will use the stored parameters and current pipeline definition, may repeat side effects, will not change the original, and will not copy chain relationships."
+%>
+<div class="gp-actions">
+  <% if GoodPipeline.dashboard_mutations_enabled? %>
+    <% if pipeline.terminal? %>
+      <%= button_to "re-run pipeline", rerun_pipeline_path(pipeline), method: :post,
+                    class: "gp-action",
+                    form: { class: "gp-action-form", data: { gp_confirm: rerun_confirmation } } %>
+    <% else %>
+      <button class="gp-action" type="button" disabled title="available after the pipeline finishes">re-run pipeline</button>
+    <% end %>
+    <% if %w[pending running].include?(status) %>
+      <%= button_to "cancel pipeline", cancel_pipeline_path(pipeline), method: :post,
+                    class: "gp-action gp-action--danger",
+                    form: { class: "gp-action-form", data: { gp_confirm: cancel_confirmation } } %>
+    <% elsif status == "canceling" %>
+      <button class="gp-action gp-action--danger" type="button" disabled>cancel requested</button>
+    <% elsif status == "canceled" %>
+      <button class="gp-action gp-action--danger" type="button" disabled title="pipeline already canceled">cancel pipeline</button>
+    <% end %>
+  <% end %>
+  <% if local_assigns[:detail_link] %>
+    <%= link_to "detail page + dag ↗", pipeline_path(pipeline), class: "gp-action gp-action--ghost" %>
+  <% end %>
+</div>

data/app/views/good_pipeline/pipelines/_chain_links.html.erb

@@ -1,30 +1,18 @@
-<% if pipeline.upstream_pipelines.any? || pipeline.downstream_pipelines.any? %>
-  <div class="chain-cards">
-    <% if pipeline.upstream_pipelines.any? %>
-      <article>
-        <header><h4>Upstream</h4></header>
-        <div class="chain-chips">
-          <% pipeline.upstream_pipelines.each do |upstream| %>
-            <%= link_to pipeline_path(upstream), class: "chain-chip" do %>
-              <span class="chain-label"><%= humanized_type(upstream.type) %></span>
-              <%= status_badge(upstream.status) %>
-            <% end %>
-          <% end %>
-        </div>
-      </article>
-    <% end %>
-    <% if pipeline.downstream_pipelines.any? %>
-      <article>
-        <header><h4>Downstream</h4></header>
-        <div class="chain-chips">
-          <% pipeline.downstream_pipelines.each do |downstream| %>
-            <%= link_to pipeline_path(downstream), class: "chain-chip" do %>
-              <span class="chain-label"><%= humanized_type(downstream.type) %></span>
-              <%= status_badge(downstream.status) %>
-            <% end %>
-          <% end %>
-        </div>
-      </article>
-    <% end %>
-  </div>
+<% upstream = pipeline.upstream_pipelines.to_a; downstream = pipeline.downstream_pipelines.to_a %>
+<% if upstream.any? || downstream.any? %>
+  <section class="gp-card">
+    <h3 class="gp-section-heading">chain</h3>
+    <div class="gp-chain">
+      <% upstream.each do |item| %>
+        <%= link_to pipeline_path(item), class: "gp-chain-chip", title: "Upstream execution" do %>
+          <span class="gp-chain-arrow">←</span><span><%= respond_to?(:short_type) ? short_type(item.type) : humanized_type(item.type) %></span><span class="gp-status gp-status--<%= item.status %>"><%= item.status %></span>
+        <% end %>
+      <% end %>
+      <% downstream.each do |item| %>
+        <%= link_to pipeline_path(item), class: "gp-chain-chip", title: "Downstream execution" do %>
+          <span><%= respond_to?(:short_type) ? short_type(item.type) : humanized_type(item.type) %></span><span class="gp-status gp-status--<%= item.status %>"><%= item.status %></span><span class="gp-chain-arrow">→</span>
+        <% end %>
+      <% end %>
+    </div>
+  </section>
 <% end %>