ductwork 1.4.0 → 1.5.0

data/app/views/ductwork/step_errors/index.html.erb

@@ -1,101 +1,57 @@
-<div>
-  <h3>Step Errors</h3>
+<% content_for(:title, "Step errors") %>
 
-  <div class="separate-content">
-    <div class="filter-group">
-      <span class="filter-group-item">Filters:</span>
-
-      <details class="dropdown filter-group-item">
-        <summary><%= params[:klass] || "Step Class" %></summary>
-        <ul>
-          <% @klasses.each do |klass| %>
-            <li>
-              <%= link_to(klass, step_errors_path(**params.permit(:status).merge(klass: klass))) %>
-            </li>
-          <% end %>
-        </ul>
-      </details>
-
-      <%= link_to("Clear", step_errors_path) %>
-    </div>
+<div class="page-head">
+  <h1 class="page-title">Step errors</h1>
+</div>
 
-    <div role="group" style="width: auto;">
-      <button <%= first_page? && "disabled" %> data-href="<%= previous_page_path %>">
-        <%= link_to(previous_page_path, class: "stealthy-link") do %>
-          &larr;
-        <% end %>
-      </button>
-      <button data-href="<%= next_page_path %>">
-        &rarr;
-      </button>
-    </div>
+<div class="toolbar">
+  <div class="menus">
+    <%= render("ductwork/shared/filter_menu", label: "Class", param: :klass, options: @klasses) %>
   </div>
-  <table class="striped">
-    <thead>
-      <tr>
-        <th>Step ID</th>
-        <th>Step Class</th>
-        <th>Pipeline ID</th>
-        <th>Error Message</th>
-        <th>Error Backtrace</th>
-      </tr>
-    </thead>
-
-    <tbody>
-      <% @step_errors.each do |result| %>
-        <tr class="not-clickable">
-          <td>
-            <code>
-              <%= result.execution.job.step.id %>
-            </code>
-          </td>
-          <td>
-            <code>
-              <%= result.execution.job.step.klass %>
-            </code>
-          </td>
-          <td>
-            <code>
-              <%= link_to(result.execution.job.step.run.pipeline_id, pipeline_path(result.execution.job.step.run.pipeline_id)) %>
-            </code>
-          </td>
-          <td>
-            <code>
-              <%= [result.error_klass, result.error_message].join(": ") %>
-            </code>
-          </td>
-          <td>
-            <button data-open-modal="modal-<%= result.id %>" class="tight-timestamp secondary">
-              Open
-            </button>
-
-            <dialog id="modal-<%= result.id %>">
-              <article>
-                <header>
-                  <button aria-label="Close" rel="prev" data-close-modal="modal-<%= result.id %>"></button>
-                  <p>
-                  <strong>Error Backtrace</strong>
-                  </p>
-                </header>
-                <div>
-                  <h2>
-                    <%= result.error_klass %>
-                  </h2>
-                  <h5>
-                    <%= result.error_message %>
-                  </h5>
-                  <code>
-                    <%= (result.error_backtrace&.split("\n") || []).each do |line| %>
-                      <div><%= line %></div>
-                    <% end %>
-                  </code>
-                </div>
-              </article>
-            </dialog>
+</div>
 
-          </td>
-        </tr>
-      <% end %>
-    </tbody>
-  </table>
+<div class="panel">
+  <% if @step_errors.empty? %>
+    <p class="empty">No step errors match.</p>
+  <% else %>
+    <div class="row-grid row-grid-errors row-head">
+      <span>When</span>
+      <span>Error</span>
+      <span>Step</span>
+      <span>Pipeline</span>
+      <span></span>
+    </div>
+    <% @step_errors.each do |result| %>
+      <% step = result.execution.job.step %>
+      <details class="row">
+        <summary class="row-grid row-grid-errors">
+          <span class="wide-only"><%= timestamp(result.created_at) %></span>
+          <span class="cell-truncate">
+            <span class="error-title"><%= result.error_klass %></span>
+            <%= result.error_message %>
+          </span>
+          <span class="cell-truncate wide-only"><%= step.klass %></span>
+          <span class="wide-only"><%= short_id(step.run.pipeline_id) %></span>
+        </summary>
+        <div class="row-body">
+          <div class="detail-grid">
+            <div>
+              <span class="detail-label">Step</span>
+              <div><%= step.klass %> <code><%= step.id %></code></div>
+            </div>
+            <div>
+              <span class="detail-label">Pipeline</span>
+              <%= link_to(step.run.pipeline_klass, pipeline_path(step.run.pipeline_id)) %>
+              <code><%= step.run.pipeline_id %></code>
+            </div>
+          </div>
+          <div class="detail-block">
+            <%= render("ductwork/shared/error", result:) %>
+          </div>
+        </div>
+      </details>
+    <% end %>
+  <% end %>
 </div>
+
+<%= render("ductwork/shared/pager", total: @error_count) %>

data/app/views/layouts/ductwork/application.html.erb

@@ -1,7 +1,8 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
   <head>
-    <title>Ductwork Dashboard</title>
+    <meta charset="utf-8">
+    <title><%= [content_for(:title), "Ductwork"].compact.join(" · ") %></title>
 
     <meta name="viewport" content="width=device-width,initial-scale=1">
     <meta name="apple-mobile-web-app-capable" content="yes">
@@ -11,8 +12,6 @@
     <%= csrf_meta_tags %>
     <%= csp_meta_tag %>
 
-    <%= stylesheet_link_tag "ductwork/vendor/pico.min.css" %>
-    <%= stylesheet_link_tag "ductwork/vendor/flexboxgrid.min.css" %>
     <%= stylesheet_link_tag "ductwork/application.css" %>
 
     <%= javascript_include_tag "ductwork/application.js", type: "module" %>
@@ -22,27 +21,24 @@
   </head>
 
   <body>
-    <header class="sticky-header">
-      <nav class="container separate-content">
-        <ul>
-          <%= link_to(dashboard_path, class: "stealthy-link") do %>
-            <li><%= image_tag("ductwork/logo.png", class: "logo") %></li>
-            <li><h6 class="title">Ductwork</h6></li>
-          <% end %>
-        </ul>
-
-        <div>
-          <label>
-            Version
-          </label>
-          <div style="color: var(--pico-color);">
-            <%= Ductwork::VERSION %>
-          </div>
-        </div>
-      </nav>
+    <header class="topbar">
+      <div class="shell topbar-inner">
+        <%= link_to(dashboard_path, class: "brand") do %>
+          <%= image_tag("ductwork/logo.png", alt: "") %>
+          <span>Ductwork</span>
+        <% end %>
+
+        <nav class="nav" aria-label="Dashboard">
+          <%= link_to("Overview", dashboard_path, aria: { current: controller_name == "dashboards" ? "page" : nil }) %>
+          <%= link_to("Pipelines", pipelines_path, aria: { current: controller_name == "pipelines" ? "page" : nil }) %>
+          <%= link_to("Errors", step_errors_path, aria: { current: controller_name == "step_errors" ? "page" : nil }) %>
+        </nav>
+
+        <span class="version">v<%= Ductwork::VERSION %></span>
+      </div>
     </header>
 
-    <main class="container">
+    <main class="shell">
       <%= yield %>
     </main>
   </body>

data/lib/ductwork/engine.rb

@@ -11,8 +11,6 @@ module Ductwork
     initializer "ductwork.assets.precompile" do |app|
       if app.config.respond_to?(:assets)
         app.config.assets.precompile += %w[
-          ductwork/vendor/pico.min.css
-          ductwork/vendor/flexboxgrid.min.css
           ductwork/application.css
           ductwork/application.js
         ]

data/lib/ductwork/models/pipeline.rb

@@ -30,6 +30,9 @@ module Ductwork
     class DefinitionError < StandardError; end
     class ReviveError < StandardError; end
 
+    DEFAULT_STEP_ORDER_PRECISION = 6
+    private_constant :DEFAULT_STEP_ORDER_PRECISION
+
     class << self
       attr_reader :pipeline_definition
 
@@ -151,16 +154,7 @@ module Ductwork
 
         new_branch.save!
 
-        branch.steps.where(status:).find_each do |step|
-          new_step = step.dup
-          new_step.source_step = step
-          new_step.branch = new_branch
-          new_step.run = new_run
-          new_step.started_at = now
-          new_step.completed_at = now
-
-          new_step.save!
-        end
+        duplicate_succeeded_steps(branch.steps.where(status:), new_branch, new_run, now)
       end
     end
 
@@ -180,36 +174,60 @@ module Ductwork
 
     def revive_branch_steps(branch, new_branch, new_run, now)
       duplicate_prior_steps_as_completed(branch, new_branch, new_run, now)
+      revive_latest_step(branch.latest_step, new_branch, new_run, now)
+    end
 
-      if branch.job_retries_exhausted?
-        re_enqueue_failed_step(branch, new_branch, new_run, now)
+    def revive_latest_step(latest_step, new_branch, new_run, now)
+      if latest_step.failed?
+        re_enqueue_failed_step(latest_step, new_branch, new_run, now)
       else
-        re_advance_latest_step(branch, new_branch, new_run, now)
+        re_advance_latest_step(latest_step, new_branch, new_run, now)
       end
     end
 
     def duplicate_prior_steps_as_completed(branch, new_branch, new_run, now)
-      latest_step = branch.steps.order(started_at: :desc).first
+      latest_step = branch.latest_step
 
       return if latest_step.blank?
 
       status = %i[advancing waiting completed]
       id = latest_step.id
 
-      branch.steps.where(status:).where.not(id:).find_each do |step|
-        new_step = step.dup
-        new_step.source_step = step
-        new_step.branch = new_branch
-        new_step.run = new_run
-        new_step.started_at = now
-        new_step.completed_at = now
+      steps = branch.steps.where(status:).where.not(id:)
+
+      duplicate_succeeded_steps(steps, new_branch, new_run, now, steps_after: 1)
+    end
+
+    def duplicate_succeeded_steps(steps, new_branch, new_run, now, steps_after: 0)
+      ordered_steps = steps.includes(:job).order(:started_at, :id).to_a
+      tick = step_order_tick
+
+      ordered_steps.reverse_each.with_index(steps_after) do |step, ticks_back|
+        started_at = now - (ticks_back * tick)
 
-        new_step.save!
+        duplicate_succeeded_step(step, new_branch, new_run, now, started_at)
       end
     end
 
-    def re_enqueue_failed_step(branch, new_branch, new_run, now)
-      failed_step = branch.steps.find_by(status: :failed)
+    def step_order_tick
+      precision = Ductwork::Step.columns_hash["started_at"].precision
+
+      Rational(1, 10**(precision || DEFAULT_STEP_ORDER_PRECISION))
+    end
+
+    def duplicate_succeeded_step(step, new_branch, new_run, now, started_at)
+      new_step = step.dup
+      new_step.source_step = step
+      new_step.branch = new_branch
+      new_step.run = new_run
+      new_step.started_at = started_at
+      new_step.completed_at = now
+
+      new_step.save!
+      duplicate_job(step.job, new_step, now) if step.job.present?
+    end
+
+    def re_enqueue_failed_step(failed_step, new_branch, new_run, now)
       args = JSON.parse(failed_step.job.input_args).fetch("args")
       step = new_branch.steps.create!(
         run: new_run,
@@ -223,8 +241,7 @@ module Ductwork
       Ductwork::Job.enqueue(step, *args)
     end
 
-    def re_advance_latest_step(branch, new_branch, new_run, now)
-      latest_step = branch.steps.order(started_at: :desc).first
+    def re_advance_latest_step(latest_step, new_branch, new_run, now)
       step = new_branch.steps.create!(
         run: new_run,
         source_step: latest_step,
@@ -234,11 +251,15 @@ module Ductwork
         status: :advancing,
         started_at: now
       )
-      job = latest_step.job.dup
-      job.step = step
-      job.started_at = now
-      job.completed_at = now
-      job.save!
+      duplicate_job(latest_step.job, step, now)
+    end
+
+    def duplicate_job(job, new_step, now)
+      new_job = job.dup
+      new_job.step = new_step
+      new_job.started_at = now
+      new_job.completed_at = now
+      new_job.save!
     end
 
     def conditionally_duplicate_context(last_run, new_run, now, duplicate_context)

data/lib/ductwork/pipeline_graph/layout.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Ductwork
+  class PipelineGraph
+    # Places a pipeline's nodes in columns by longest path from the start, so
+    # branches of different lengths still line up where they merge. A link
+    # that spans several columns is routed through a placeholder in each one
+    # so it runs around the cards in between rather than behind them.
+    class Layout
+      CARD_WIDTH = 208
+      COLUMN_GAP = 48
+      ROW_GAP = 24
+      PADDING = 8
+      SWEEPS = 8
+
+      attr_reader :width, :height
+
+      def initialize(nodes:, links:, card_height:)
+        @nodes = nodes
+        @links = links
+        @card_height = card_height
+        @pitch = card_height + ROW_GAP
+
+        assign_columns
+        subdivide_links
+        order_columns
+        assign_rows
+        measure
+      end
+
+      def position(node)
+        [x(node), y(node)]
+      end
+
+      def route(from, to)
+        chain = chains.fetch([from, to])
+        start = "M#{right(chain.first).join(" ")}"
+        curves = chain.each_cons(2).map { |a, b| curve(a, b) }
+
+        [start, *curves].join(" ")
+      end
+
+      private
+
+      attr_reader :nodes, :links, :card_height, :pitch, :column, :columns, :chains, :rows,
+                  :predecessors, :successors
+
+      def assign_columns
+        @column = nodes.to_h { |node| [node, 0] }
+        outgoing = links.group_by(&:first)
+
+        nodes.each do |node|
+          outgoing.fetch(node, []).map(&:last).each do |to|
+            column[to] = [column[to], column[node] + 1].max
+          end
+        end
+      end
+
+      def subdivide_links
+        @predecessors = Hash.new { |hash, key| hash[key] = [] }
+        @successors = Hash.new { |hash, key| hash[key] = [] }
+        @chains = links.to_h { |from, to| [[from, to], chain_for(from, to)] }
+
+        chains.each_value do |chain|
+          chain.each_cons(2) do |a, b|
+            successors[a] << b
+            predecessors[b] << a
+          end
+        end
+      end
+
+      def chain_for(from, to)
+        placeholders = ((column[from] + 1)...column[to]).map do |index|
+          [from, to, index].tap { |placeholder| column[placeholder] = index }
+        end
+
+        [from, *placeholders, to]
+      end
+
+      def order_columns
+        @columns = column.keys.group_by { |vertex| column[vertex] }.sort.map(&:last)
+
+        (1...columns.length).each do |index|
+          ranks = columns[index - 1].each_with_index.to_h
+          columns[index] = columns[index].sort_by.with_index do |vertex, position|
+            [mean(predecessors[vertex].filter_map { |predecessor| ranks[predecessor] }) || position, position]
+          end
+        end
+      end
+
+      def assign_rows
+        @rows = {}
+        columns.each do |vertices|
+          vertices.each_with_index { |vertex, index| rows[vertex] = (index - ((vertices.length - 1) / 2.0)) * pitch }
+        end
+
+        SWEEPS.times do
+          sweep(columns, predecessors)
+          sweep(columns.reverse, successors)
+        end
+        sweep(columns, predecessors)
+      end
+
+      def sweep(ordered_columns, neighbors)
+        ordered_columns.each do |vertices|
+          targets = vertices.map { |vertex| mean(neighbors[vertex].map { |other| rows[other] }) || rows[vertex] }
+
+          vertices.zip(separate(targets)) { |vertex, row| rows[vertex] = row }
+        end
+      end
+
+      # Pushes rows apart to at least `pitch`, keeping their order and their
+      # overall center where the targets asked for it.
+      def separate(targets)
+        placed = targets.each_with_object([]) do |target, result|
+          result << (result.empty? ? target : [target, result.last + pitch].max)
+        end
+        shift = mean(targets) - mean(placed)
+
+        placed.map { |row| row + shift }
+      end
+
+      def measure
+        top = rows.values.min || 0
+        rows.transform_values! { |row| (row - top).round + PADDING }
+
+        @width = (PADDING * 2) + (columns.length * CARD_WIDTH) + ([columns.length - 1, 0].max * COLUMN_GAP)
+        @height = (rows.values.max || 0) + card_height + PADDING
+      end
+
+      def x(vertex)
+        PADDING + (column[vertex] * (CARD_WIDTH + COLUMN_GAP))
+      end
+
+      def y(vertex)
+        rows[vertex]
+      end
+
+      def left(vertex)
+        [x(vertex), y(vertex) + (card_height / 2)]
+      end
+
+      def right(vertex)
+        [x(vertex) + CARD_WIDTH, y(vertex) + (card_height / 2)]
+      end
+
+      def curve(from, to)
+        (start_x, start_y) = right(from)
+        (end_x, end_y) = left(to)
+        middle = (start_x + end_x) / 2
+        path = "C#{middle} #{start_y}, #{middle} #{end_y}, #{end_x} #{end_y}"
+
+        nodes.include?(to) ? path : "#{path} L#{right(to).join(" ")}"
+      end
+
+      def mean(values)
+        values.sum.to_f / values.length if values.any?
+      end
+    end
+  end
+end