fun_ci 2.1.1-aarch64-linux → 2.3.0-aarch64-linux

data/lib/fun_ci/console/console_state.rb

@@ -2,12 +2,14 @@
 
 require_relative "run_message"
 require_relative "console_events"
+require_relative "job_message"
 
 module FunCi
   module Console
     # What the console shows: the page of runs BoardData reads that the View
-    # puts on screen, and the clock's time, as a protocol `board` message,
-    # after the `event`s for what changed since the last one.
+    # puts on screen, the daily and weekly jobs below it, and the clock's
+    # time, as a protocol `board` message, after the `event`s for what changed
+    # since the last one.
     class ConsoleState
       KEYS = { "up" => :up, "down" => :down, "esc" => :escape, "ctrl_c" => "q", "enter" => :enter }.freeze
 
@@ -26,18 +28,22 @@ module FunCi
 
       def updates
         @board_data.record_dead_slow_suites
+        @board_data.record_dead_jobs
         runs = @board_data.runs
-        [*@events.since_last(runs), board(runs)]
+        [*@events.since_last(runs), board(runs, @board_data.jobs(runs))]
       end
 
       private
 
-      def board(runs)
-        page = @view.page(runs, more: @board_data.more?)
+      def board(runs, jobs)
+        page = @view.page(runs, more: @board_data.more?, jobs: jobs)
         { t: "board", now: @clock.call.to_i, streak: @board_data.streak, **page,
-          runs: page[:runs].map { |run| RunMessage.from(run) }, **stale_trunks(runs) }
+          runs: page[:runs].map { |run| RunMessage.from(run) }, **job_section(jobs), **stale_trunks(runs) }
       end
 
+      # Only when there are jobs, as the protocol lets a board leave them out.
+      def job_section(jobs) = jobs.empty? ? {} : { jobs: jobs.map { |job| JobMessage.from(job) } }
+
       # Only when a trunk is stale, as the protocol lets a board leave it out.
       def stale_trunks(runs)
         stale = @board_data.stale_trunks(runs, now: @clock.call)

data/lib/fun_ci/console/job_message.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FunCi
+  module Console
+    # Where a job stands (Jobs::Standing) as the protocol's `board` carries it
+    # under `jobs`: protocol status names and epoch seconds. Formatting them
+    # is the renderer's job.
+    module JobMessage
+      # The protocol's word for a Jobs::State, where it has one of its own:
+      # a cancelled job is due again, and one it can't read is shown due.
+      STATUS = { "over_budget" => "timeout", "cancelled" => "due", "unknown" => "due" }.freeze
+
+      def self.from(standing)
+        { project: standing.project, name: standing.name, cadence: standing.cadence,
+          status: STATUS.fetch(standing.state, standing.state), **run(standing.run, standing.starts_at),
+          due_at: standing.due_at&.to_i }.compact
+      end
+
+      # What the latest run says: which, on what, and when; a run waiting its
+      # turn (Jobs::Schedule) has not started, and says when it starts.
+      def self.run(run, starts_at)
+        return {} unless run
+
+        { run_id: run[:id], sha: run[:commit_hash], branch: run[:branch], **times(run, starts_at) }
+      end
+
+      def self.times(run, starts_at)
+        return { starts_at: starts_at.to_i } if starts_at
+
+        { started_at: epoch(run[:started_at]), updated_at: epoch(run[:completed_at] || run[:started_at]) }
+      end
+
+      def self.epoch(iso) = Time.parse(iso).to_i
+      private_class_method :run, :times, :epoch
+    end
+  end
+end

data/lib/fun_ci/console/job_order.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # The order of the job section's rows (design.md, The console): what
+    # needs you first, then running, waiting its turn to (Jobs::Schedule),
+    # due and passed; among equals, the
+    # board's projects in its order, then each project's jobs by name. Rows
+    # answer #state (Jobs::State), #project and #name.
+    module JobOrder
+      URGENCY = { "failed" => 0, "lost" => 0, "over_budget" => 1, "running" => 2, "scheduled" => 3, "due" => 4,
+                  "cancelled" => 4, "passed" => 5 }.freeze
+      # A state this fun-ci doesn't know, which a newer one sharing the database may have written.
+      UNKNOWN = 6
+
+      def self.of(rows, projects:)
+        rows.sort_by do |row|
+          [URGENCY.fetch(row.state, UNKNOWN), projects.index(row.project) || projects.size, row.name]
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/console/job_rows.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "job_order"
+require_relative "../jobs/standings"
+
+module FunCi
+  module Console
+    # The job section's rows (design.md, The console): where each daily and
+    # weekly job of the board's projects stands (Jobs::Standing), in JobOrder.
+    class JobRows
+      def initialize(db)
+        @db = db
+      end
+
+      def of(projects, now:)
+        standings = projects.flat_map { |project| Jobs::Standings.new(@db, project, now: now).all }
+        JobOrder.of(standings, projects: projects)
+      end
+    end
+  end
+end

data/lib/fun_ci/console/key_handler.rb

@@ -2,9 +2,10 @@
 
 module FunCi
   module Console
-    # What a key means for the runs BoardData loads: moving the cursor,
-    # quitting, and cancelling the run under the cursor (a running one after
-    # the user confirms with `y`).
+    # What a key means for the runs BoardData loads, and the daily and weekly
+    # jobs after them: moving the cursor through both, quitting, and
+    # cancelling the run or job under the cursor (a running one after the
+    # user confirms with `y`).
     class KeyHandler
       CONFIRMATION_ANSWERS = ["y", "n", :escape].freeze
 
@@ -27,10 +28,6 @@ module FunCi
         !@confirm_cancel.nil?
       end
 
-      def confirmation_run
-        @confirm_cancel
-      end
-
       private
 
       def act(key)
@@ -41,15 +38,16 @@ module FunCi
         end
       end
 
-      # Onto the last run loaded, which loads the next page.
+      # Onto the last run loaded, which loads the next page, then into the jobs.
       def move_cursor_down
-        last = @board_data.runs.length - 1
+        runs = @board_data.runs
+        last = runs.length + @board_data.jobs(runs).length - 1
         return if last.negative?
         return @cursor_index = 0 if @cursor_index.nil?
         return unless @cursor_index < last
 
         @cursor_index += 1
-        @board_data.load_more if @cursor_index == last
+        @board_data.load_more if @cursor_index == runs.length - 1
       end
 
       def move_cursor_up
@@ -57,17 +55,40 @@ module FunCi
       end
 
       def initiate_cancel
-        run = @cursor_index && @board_data.runs[@cursor_index]
-        return unless run
+        kind, row = under_cursor
+        return unless row
 
+        kind == :job ? offer_job_cancel(row) : offer_run_cancel(row)
+      end
+
+      # A run waiting to start is cancelled at once; a running one once the user confirms.
+      def offer_run_cancel(run)
         @board_data.cancel_run(run[:id]) if run[:status] == "scheduled"
-        @confirm_cancel = run if run[:status] == "running"
+        @confirm_cancel = [:run, run] if run[:status] == "running"
+      end
+
+      # A job (a Jobs::Standing) waiting its turn is cancelled at once; a
+      # running one once the user confirms.
+      def offer_job_cancel(job)
+        cancel(:job, job) if job.state == "scheduled"
+        @confirm_cancel = [:job, job] if job.state == "running"
+      end
+
+      # [:run, the run] or [:job, the job row] under the cursor, or none.
+      def under_cursor
+        runs = @board_data.runs
+        return [] unless @cursor_index
+        return [:run, runs[@cursor_index]] if @cursor_index < runs.length
+
+        [:job, @board_data.jobs(runs)[@cursor_index - runs.length]]
       end
 
       def confirm(key)
-        @board_data.cancel_run(@confirm_cancel[:id]) if key == "y"
+        cancel(*@confirm_cancel) if key == "y"
         @confirm_cancel = nil if CONFIRMATION_ANSWERS.include?(key)
       end
+
+      def cancel(kind, row) = kind == :job ? @board_data.cancel_job(row.run[:id]) : @board_data.cancel_run(row[:id])
     end
   end
 end

data/lib/fun_ci/console/paging.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module FunCi
+  module Console
+    # How many branches BoardData loads: a page of `page_size` at first, a
+    # page more each time the cursor reaches the last one loaded.
+    class Paging
+      attr_reader :limit
+
+      def initialize(page_size)
+        @page_size = page_size
+        @limit = page_size
+      end
+
+      def load_more
+        @limit += @page_size
+      end
+
+      # Pages by `page_size` from now on, loading at least one such page.
+      def resize(page_size)
+        @page_size = page_size
+        @limit = [@limit, page_size].max
+      end
+    end
+  end
+end

data/lib/fun_ci/console/view.rb

@@ -11,6 +11,8 @@ module FunCi
       # table: a page this many rows short of the terminal fits one line per
       # row, however the renderer spaces them (renderer-protocol.md, `board`).
       CHROME_ROWS = 18
+      # A blank line and one for the job section, the least the renderer folds it to.
+      JOB_LINES = 2
 
       def initialize(key_handler:)
         @key_handler = key_handler
@@ -25,23 +27,30 @@ module FunCi
       # :quit when the key ends the session.
       def press(key) = @key_handler.handle_key(key)
 
-      # `more`: whether the store holds runs beyond `runs`.
-      def page(runs, more:)
-        first = first_shown
-        { cursor: cursor_on_page(first), confirming: @key_handler.confirming?,
-          has_more: more || first + @page_size < runs.size, runs: runs[first, @page_size] || [] }
+      # `more`: whether the store holds runs beyond `runs`. `jobs`: the job
+      # section's rows, below the page, which the cursor reaches after the runs.
+      def page(runs, more:, jobs: [])
+        size = jobs.empty? ? @page_size : [@page_size - JOB_LINES, 0].max
+        first = first_shown(runs.size, size)
+        { cursor: cursor_on_page(first, size), confirming: @key_handler.confirming?,
+          has_more: more || first + size < runs.size, runs: runs[first, size] || [] }
       end
 
       private
 
-      def first_shown
+      # The last page of runs while the cursor is on a job.
+      def first_shown(count, size)
         cursor = @key_handler.cursor_index
-        cursor ? [cursor - @page_size + 1, 0].max : 0
+        return 0 unless cursor
+
+        [[cursor, count - 1].min - size + 1, 0].max
       end
 
-      def cursor_on_page(first)
+      # Past the page's runs while the cursor is on a job: a page that holds
+      # a job's cursor ends at the last run.
+      def cursor_on_page(first, size)
         cursor = @key_handler.cursor_index
-        cursor - first if cursor && @page_size.positive?
+        cursor - first if cursor && size.positive?
       end
     end
   end

data/lib/fun_ci/evidence/settings.rb

@@ -4,6 +4,7 @@ require "yaml"
 require_relative "catalog"
 require_relative "patterns"
 require_relative "settings_check"
+require_relative "../jobs/job"
 
 module FunCi
   module Evidence
@@ -13,11 +14,11 @@ module FunCi
     # what is wrong, for `fun-ci check`.
     class Settings
       DEFAULTS = { "budget" => 2, "detect" => true, "skip" => [], "mask" => [], "masking" => true,
-                   "stages" => {} }.freeze
+                   "stages" => {}, "jobs" => {} }.freeze
 
       # The settings in the config file at `path`, or the defaults without one.
       def self.load(path)
-        new(File.exist?(path) ? (YAML.safe_load_file(path) || {})["evidence"] : nil)
+        new(File.exist?(path) ? (YAML.safe_load_file(path, aliases: true) || {})["evidence"] : nil)
       rescue Psych::Exception, NoMethodError, TypeError
         new(nil)
       end
@@ -36,8 +37,12 @@ module FunCi
                             .then { |sources| Patterns.compile(sources) }
       end
 
-      # The raw entries for `stage`: those for every stage, then its own.
-      def entries(stage) = stage_list("all") + stage_list(stage)
+      # The raw entries for `stage`: those for every stage, then its own; for
+      # a job (`jobs/<name>`), those under `jobs:`.
+      def entries(stage)
+        job = Jobs::Job.named_by(stage)
+        stage_list("all") + (job ? list("jobs", job) : stage_list(stage))
+      end
 
       # The globs whose files are stamped when the stage starts, so what it
       # wrote to them can be told from what was there before.
@@ -54,10 +59,12 @@ module FunCi
       def values = @raw.is_a?(Hash) ? DEFAULTS.merge(@raw) : DEFAULTS
       def value(key) = values[key]
 
-      def stage_list(stage)
-        stages = value("stages")
-        list = stages[stage] if stages.is_a?(Hash)
-        list.is_a?(Array) ? list : []
+      def stage_list(stage) = list("stages", stage)
+
+      def list(setting, name)
+        lists = value(setting)
+        found = lists[name] if lists.is_a?(Hash)
+        found.is_a?(Array) ? found : []
       end
     end
   end

data/lib/fun_ci/evidence/settings_check.rb

@@ -8,7 +8,7 @@ module FunCi
     # What is wrong with the `evidence` key of .fun-ci/config, each as a line
     # `fun-ci check` prints.
     class SettingsCheck
-      KNOWN = %w[budget detect skip mask masking stages].freeze
+      KNOWN = %w[budget detect skip mask masking stages jobs].freeze
       STAGES = %w[all lint build fast slow].freeze
 
       # "2", 2, 2.5 or "2s" as seconds, or nil.
@@ -28,7 +28,7 @@ module FunCi
         return [] if @raw.nil?
         return ["evidence must be a mapping, not #{@raw.inspect}"] unless @raw.is_a?(Hash)
 
-        unknown + budget + stages
+        unknown + budget + stages + jobs
       end
 
       private
@@ -48,12 +48,23 @@ module FunCi
         lists.flat_map { |stage, entries| stage_errors(stage, entries) }
       end
 
+      def jobs
+        lists = @raw.fetch("jobs", {})
+        return ["evidence.jobs must be a mapping of job to entries"] unless lists.is_a?(Hash)
+
+        lists.flat_map { |job, entries| entry_errors("evidence.jobs.#{job}", entries) }
+      end
+
+      def entry_errors(where, entries)
+        Array(entries).filter_map { |entry| refusal(entry) }.map { |message| "#{where}: #{message}" }
+      end
+
       def stage_errors(stage, entries)
         unless STAGES.include?(stage)
           return ["evidence.stages has no stage '#{stage}': use all, lint, build, fast or slow"]
         end
 
-        Array(entries).filter_map { |entry| refusal(entry) }.map { |message| "evidence.stages.#{stage}: #{message}" }
+        entry_errors("evidence.stages.#{stage}", entries)
       end
 
       def refusal(entry)

data/lib/fun_ci/jobs/due.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "time"
+
+module FunCi
+  module Jobs
+    # Whether a job is due, from its latest run alone ({ status:, started_at: },
+    # or nil when it never ran): when it never ran, when that run was
+    # cancelled, or a period after that run started, unless it still runs or
+    # waits to (design.md, Daily and weekly jobs).
+    class Due
+      def initialize(latest, period, now:)
+        @latest = latest
+        @period = period
+        @now = now
+      end
+
+      def now?
+        return true if @latest.nil? || @latest[:status] == "cancelled"
+
+        !running? && again <= @now
+      end
+
+      # When it is due again, or nil while it is due now or still runs.
+      def at = now? || running? ? nil : again
+
+      private
+
+      # A run waiting its turn (Schedule) counts as running: it is the job's run.
+      def running? = %w[running scheduled].include?(@latest[:status])
+      def again = Time.parse(@latest[:started_at]) + @period
+    end
+  end
+end

data/lib/fun_ci/jobs/due_jobs.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "standings"
+require_relative "schedule"
+require_relative "../pipeline/run_canceller"
+require_relative "../setup/project_config"
+
+module FunCi
+  module Jobs
+    # The project's jobs that are due at `now`, read from the database without
+    # taking any lock: who starts a job is decided again, under its lock, by
+    # the process that runs it. A job left running by a process that died is
+    # recorded failed first, or it would never be due again, and no process
+    # would start to find it dead.
+    class DueJobs
+      BEGUN = %w[running scheduled].freeze
+      DAY = 86_400
+
+      def initialize(project, db, now:)
+        @project = project
+        @db = db
+        @now = now
+      end
+
+      def list = standings.select(&:due_now?).map(&:job)
+
+      # [job, when its turn to start comes] for each due job (Schedule): a day
+      # shared evenly among the project's jobs apart, or its `job_spacing`,
+      # after its jobs still running or waiting to. Each is due again a
+      # period after its own start, so the spread holds from day to day.
+      def starts
+        all = standings
+        Schedule.new(spacing(all.size), begun(all), now: @now).starts(all.select(&:due_now?).map(&:job))
+      end
+
+      private
+
+      def spacing(jobs) = Setup::ProjectConfig.new(@project).job_spacing || (DAY / [jobs, 1].max)
+
+      # When each of the project's jobs still running or waiting to began, or is to.
+      def begun(all) = all.select { |one| BEGUN.include?(one.state) }.map { |one| Time.parse(one.run[:started_at]) }
+
+      def standings
+        Pipeline::RunCanceller.new.record_dead_jobs(@db)
+        Standings.new(@db, @project, now: @now).all
+      end
+    end
+  end
+end

data/lib/fun_ci/jobs/folders.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "job"
+
+module FunCi
+  module Jobs
+    # The jobs a project keeps in .fun-ci/daily/ and .fun-ci/weekly/: each
+    # executable `<name>.sh`. A script that can't run, or a name in both
+    # folders, is no job; #errors says why, for `fun-ci check`.
+    class Folders
+      CADENCES = Job::PERIODS.keys
+      # A name a command line keeps whole, since agents paste it: fun-ci why --job NAME.
+      NAME = /\A[A-Za-z0-9._-]+\z/
+
+      def initialize(project_root)
+        @fun_ci_dir = File.join(project_root, ".fun-ci")
+      end
+
+      # By name.
+      def jobs
+        all = scripts
+        twice = twice(all)
+        all.select { |job| runnable?(job) && NAME.match?(job.name) && !twice.include?(job.name) }.sort_by(&:name)
+      end
+
+      def errors
+        all = scripts
+        all.reject { |job| runnable?(job) }.map { |job| "#{path(job)} is not executable" } +
+          all.reject { |job| NAME.match?(job.name) }.map { |job| misnamed(job) } +
+          twice(all).map { |name| "the job #{name} is in both .fun-ci/daily/ and .fun-ci/weekly/: rename one" }
+      end
+
+      private
+
+      def runnable?(job) = File.executable?(job.script)
+      def path(job) = ".fun-ci/#{job.cadence}/#{job.name}.sh"
+      def misnamed(job) = "the job '#{job.name}' needs a name of letters, digits, '.', '_' and '-': rename #{path(job)}"
+
+      def twice(all) = all.group_by(&:name).select { |_, jobs| jobs.size > 1 }.keys.sort
+
+      def scripts
+        CADENCES.flat_map do |cadence|
+          Dir.glob("*.sh", base: File.join(@fun_ci_dir, cadence)).map do |file|
+            Job.new(name: File.basename(file, ".sh"), cadence: cadence, script: File.join(@fun_ci_dir, cadence, file))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_ci/jobs/job.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module FunCi
+  module Jobs
+    # A script a project runs at most once a day or once a week, named after
+    # it (design.md, Daily and weekly jobs). `cadence` is "daily" or "weekly".
+    Job = Data.define(:name, :cadence, :script)
+
+    class Job
+      PERIODS = { "daily" => 86_400, "weekly" => 604_800 }.freeze
+      # Every job's, the weekly ones' too.
+      BUDGET = 86_400
+      # How a job is named where a stage would be.
+      STAGE = "jobs/"
+
+      # The name of the job a stage name names, or nil for a pipeline stage's.
+      def self.named_by(stage) = (stage.delete_prefix(STAGE) if stage.start_with?(STAGE))
+
+      # Seconds from one run's start until the job is due again.
+      def period = PERIODS.fetch(cadence)
+
+      # What evidence knows it by: `evidence: jobs: <name>:` in .fun-ci/config.
+      def stage = "#{STAGE}#{name}"
+
+      # The shell command that runs it on a commit, its path quoted.
+      def command(sha) = "#{Shellwords.escape(script)} #{sha}"
+    end
+  end
+end

data/lib/fun_ci/jobs/job_fork.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "job_run"
+require_relative "../persistence/database"
+require_relative "../pipeline/worktrees"
+require_relative "../pipeline/priorities"
+
+module FunCi
+  module Jobs
+    # Starts a job in a process of its own (architecture.md, Daily and weekly
+    # jobs). The trigger that forks it exits when its pipeline ends, and the
+    # terminal of the commit may close; a job can run for hours, so it leads a
+    # session of its own, prints nowhere, and opens its own connection, since
+    # a child must not inherit one. `priorities` says what its script runs under.
+    class JobFork
+      def initialize(project:, db_path:, priorities: Pipeline::Priorities.for(RUBY_PLATFORM))
+        @project = project
+        @db_path = db_path
+        @priorities = priorities
+      end
+
+      # at: when the job's turn to start comes (Schedule); now when nil.
+      def start(job, commit, at: nil) = Process.detach(fork { run_in_child(job, commit, at) })
+
+      private
+
+      def run_in_child(job, commit, at)
+        Process.setsid
+        silence
+        db = Persistence::Database.connection(@db_path)
+        JobRun.new(job, commit, site(db), Pipeline::Seams.new(priorities: @priorities)).start(at: at)
+      ensure
+        db&.close
+      end
+
+      # The process's own descriptors, whatever $stdout and $stderr stand for
+      # (a test's StringIO, a guard's file), onto an open /dev/null, since
+      # reopening by path can't change a stream's access mode.
+      def silence
+        File.open(File::NULL, File::RDWR) do |null|
+          (0..2).each { |fd| IO.for_fd(fd, autoclose: false).reopen(null) }
+        end
+      end
+
+      def site(db)
+        worktrees = Pipeline::Worktrees.new(@project)
+        Site.new(project: @project, db: db, worktrees: worktrees, locks: Locks.new(worktrees.jobs_root),
+                 clock: -> { Time.now })
+      end
+    end
+  end
+end