asgard 0.5.1 → 0.6.0

data/lib/asgard/schedule/declaration.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "digest"
 require "open3"
 require "shellwords"
+require "zlib"
 
 module Asgard
   # Scheduled asgard tasks, run by the platform's own scheduler: launchd on
@@ -27,7 +29,8 @@ module Asgard
   #   #installed_entries                  # => [[project_slug, "demo"], ...] for every project
   #   #installed_columns(name)            # => { command:, schedule: } read back from the job files, or nil
   #   #installed_directory(name)          # => the project root the job runs in, or nil
-  #   #status(name)                       # => { state: :active|:stopped|:not_loaded, last_exit: String|nil }
+  #   #status(name)                       # => { state: :active|:running|:stopped|:not_loaded, last_exit: String|nil }
+  #                                       #    last_exit: an exit code ("1") or a signal ("signal 15 (Terminated)")
   #   #log_path(name)                     # => path the job's output is appended to
   #   #notes                              # => [String] platform hints to show after install
   module Schedule
@@ -37,6 +40,15 @@ module Asgard
     # Weekday numbers follow launchd and cron: 0 (Sunday) through 6 (Saturday).
     DAYS = %i[sunday monday tuesday wednesday thursday friday saturday].freeze
 
+    # Longest derived entry name, hash suffix included, so a job's file
+    # names stay well inside the 255-byte limit.
+    NAME_MAX = 64
+
+    # Options a slug spells out: lowercase words and flags. Any other option
+    # (--period=week, 'Week End') adds a hash suffix, so spellings that slug
+    # alike still name different entries.
+    PLAIN_ARG = /\A-{0,2}[a-z0-9]+(?:-[a-z0-9]+)*\z/
+
     DAY_GROUPS = {
       weekdays: %i[monday tuesday wednesday thursday friday],
       weekends: %i[saturday sunday]
@@ -73,27 +85,67 @@ module Asgard
     # task's command-line options as a String, split shell-style with quotes
     # respected ("--period week --title 'Week End'"), or an Array of words.
     # Exactly one of at: ("HH:MM" or an Array of them, with on:) or every:
-    # (seconds or a Duration) is required. as: names the entry.
-    def normalize(task, options: nil, at: nil, on: :daily, every: nil, env: {}, as: nil)
-      task = task.to_s
-      unless task.match?(/\A[\w:-]+\z/)
-        raise ArgumentError,
-              "schedule: task name #{task.inspect} must be a single word; put its flags in options:"
-      end
+    # (seconds or a Duration) is required; on: goes only with at:. as: names
+    # the entry.
+    def normalize(task, options: nil, at: nil, on: nil, every: nil, env: {}, as: nil)
+      task = task_name(task)
       raise ArgumentError, "schedule :#{task} needs either at: or every:, not both" unless at.nil? ^ every.nil?
 
       if every
+        raise ArgumentError, "schedule :#{task} on: only applies to at: times; every: runs on every day" if on
+
         every = seconds(every)
         unless every&.positive?
           raise ArgumentError,
                 "schedule :#{task} every: must be a positive number of seconds or a Duration (3.minutes)"
         end
       else
+        on ||= :daily
         calendar(at:, on:) # raises on a bad time or day
       end
 
       args = options.is_a?(Array) ? options.map(&:to_s) : Shellwords.split(options.to_s)
-      { name: entry_name(task, args, as), task:, args:, at:, on:, every:, env: env.to_h { |key, value| [key.to_s, value.to_s] } }
+      args.each { |arg| reject_control_characters!(task, "options:", arg) }
+      { name: entry_name(task, args, as), task:, args:, at:, on:, every:, env: environment_variables(task, env) }
+    end
+
+    # The command a declaration names, as Thor dispatches it: a dash is the
+    # underscore of the method name (`asgard daily-summary` runs
+    # daily_summary). A colon would name a subcommand, which is its own
+    # command word plus arguments.
+    def task_name(task)
+      name = task.to_s
+      if name.include?(":")
+        raise ArgumentError,
+              "schedule: #{name.inspect} names a subcommand; schedule its command and pass the rest in options: " \
+              "(schedule :#{name.split(':').first}, options: #{name.split(':', 2).last.inspect}, ...)"
+      end
+      unless name.match?(/\A[\w-]+\z/)
+        raise ArgumentError, "schedule: task name #{name.inspect} must be a single word; put its flags in options:"
+      end
+
+      name.tr("-", "_")
+    end
+
+    # env: as String pairs. Names must be shell-style identifiers, and no
+    # name, value or option may hold a control character other than tab: a
+    # newline would end the line it is written on in a unit file and start
+    # another directive, and plists cannot hold most of them at all.
+    def environment_variables(task, env)
+      env.to_h do |key, value|
+        key = key.to_s
+        raise ArgumentError, "schedule :#{task} env: #{key.inspect} is not a variable name" unless key.match?(/\A[A-Za-z_]\w*\z/)
+
+        value = value.to_s
+        reject_control_characters!(task, "env: #{key}", value)
+        [key, value]
+      end
+    end
+
+    def reject_control_characters!(task, what, text)
+      return unless text.match?(/[\x00-\x08\x0a-\x1f\x7f]/)
+
+      raise ArgumentError, "schedule :#{task} #{what} holds a control character (#{text.inspect})"
     end
 
     # Integer seconds from an Integer or anything Duration-like (ActiveSupport's
@@ -107,14 +159,51 @@ module Asgard
     # The task alone, or a slug of the whole command when it has arguments,
     # so one task can be scheduled more than once with different flags.
     def entry_name(task, args, as = nil)
-      name = (as || (args.empty? ? task : slug([task, *args].join(" ")))).to_s
+      name = (as || (args.empty? ? task : command_slug(task, args))).to_s
       raise ArgumentError, "schedule as: #{name.inspect} may only contain letters, digits, _ . -" unless name.match?(/\A[\w.-]+\z/)
 
       name
     end
 
+    # "report-period-week". A short hash of the exact words is appended when
+    # the slug would lose something (an option that isn't PLAIN_ARG, or more
+    # than NAME_MAX characters). Plain slugs can still meet: `--period week`
+    # and `period week` both give report-period-week, so do `report` with
+    # `period week` and `report_period` with `week`. Schedule.declare
+    # gives each of two such rivals its hashed_slug, so different commands
+    # never share a name.
+    def command_slug(task, args)
+      words = [task, *args].map(&:to_s)
+      name  = slug(words.join(" "))
+      return name if name.length <= NAME_MAX && words.drop(1).all? { |arg| arg.match?(PLAIN_ARG) }
+
+      hashed_slug(task, args)
+    end
+
+    # The slug with a short hash of the exact words appended, capped at
+    # NAME_MAX: "report-period-week-1a2b3c4d".
+    def hashed_slug(task, args)
+      words  = [task, *args].map(&:to_s)
+      digest = Digest::SHA256.hexdigest(words.join("\0"))[0, 8]
+      "#{slug(words.join(' '))[0, NAME_MAX - 9].delete_suffix('-')}-#{digest}"
+    end
+
     def slug(name) = name.to_s.downcase.gsub(/[^a-z0-9]+/, "-").delete_prefix("-").delete_suffix("-")
 
+    # The slug a project's jobs and watcher state are filed under: the
+    # basename of its root plus the CRC32 of the real path in hex
+    # ("api-9f3a1c2b"), so two projects in directories of the same name
+    # never share labels, units or state. Symlinked paths to one project
+    # agree, since the real path is hashed.
+    def project_slug(root)
+      real = File.realpath(root.to_s)
+      "#{slug(File.basename(real))}-#{format('%08x', Zlib.crc32(real))}"
+    end
+
+    # Whether +slug+ is the project the user named: the whole slug, or its
+    # basename alone when that is enough to pick it out.
+    def project_match?(slug, name) = slug == name || slug.sub(/-\h{8}\z/, "") == name
+
     # For display: the command line the job runs.
     def command_line(task, args = []) = Shellwords.join(["asgard", task.to_s, *args])
 
@@ -142,7 +231,18 @@ module Asgard
     # The state and last-exit columns of a `list` row, from a backend's live status.
     def live_columns(backend, name)
       state, last_exit = backend.status(name).values_at(:state, :last_exit)
-      { state: state.to_s.tr("_", " "), last_exit: state == :active ? (last_exit || "never run") : "-" }
+      { state: state.to_s.tr("_", " "), last_exit: %i[active running].include?(state) ? (last_exit || "never run") : "-" }
+    end
+
+    # The [slug, name] entries whose job files name a project directory
+    # that no longer exists: the project moved or was deleted, and its jobs
+    # fire in a directory that is not there. An entry whose directory
+    # cannot be read is left alone.
+    def orphaned_entries(entries, directory_of:, exists: File.method(:directory?))
+      entries.select do |slug, name|
+        dir = directory_of.call(slug, name)
+        dir && !exists.call(dir)
+      end
     end
 
     # The command a job runs, from its program arguments: everything from
@@ -172,7 +272,7 @@ module Asgard
       return :daily unless days
 
       names = days.map { |day| DAYS.fetch(day) }
-      DAY_GROUPS.key(names) || names
+      DAY_GROUPS.find { |_group, members| members.sort == names.sort }&.first || names
     end
 
     def compact_times(times)
@@ -200,6 +300,8 @@ module Asgard
       return nil if on.to_s == "daily"
 
       names = DAY_GROUPS.fetch(on.is_a?(Array) ? nil : on.to_sym) { Array(on) }
+      raise ArgumentError, "on: needs at least one day" if names.empty?
+
       names.map do |day|
         DAYS.index(day.to_sym) or raise ArgumentError, "on: unknown day #{day.inspect}"
       end
@@ -208,6 +310,8 @@ module Asgard
     # One entry per time: [{ hour: 17, minute: 30, days: [1, 2, 3, 4, 5] }];
     # days is nil for every day.
     def calendar(at:, on: :daily)
+      raise ArgumentError, "at: needs at least one time" if Array(at).empty?
+
       days = weekdays(on)
       Array(at).map do |time|
         hour, minute = parse_time(time)
@@ -215,6 +319,29 @@ module Asgard
       end
     end
 
+    # A job's last exit when a signal ended it: "signal 15 (Terminated)".
+    def signal_exit(number, name) = "signal #{number} (#{name})"
+
+    # Raises when a job file's name passes the 255-byte filename limit.
+    def check_lengths!(paths)
+      long = paths.map { |path| File.basename(path) }.find { |base| base.bytesize > 255 }
+      raise Error, "schedule: job file name is too long (#{long.bytesize} bytes, limit 255): #{long}; use a shorter as: name" if long
+    end
+
+    # Runs the block that writes job files; a failure there (the system
+    # message names the path) is a Schedule::Error, not a backtrace.
+    def writing
+      yield
+    rescue SystemCallError => e
+      raise Error, "schedule: could not write job files: #{e.message}"
+    end
+
+    # Writes a job file only its owner can read: it holds the env: values.
+    def write_private(path, content)
+      File.write(path, content, perm: 0o600)
+      File.chmod(0o600, path) # perm: applies only when the file is created
+    end
+
     # PATH captured at install time, plus the declaration's env:.
     def environment(spec, path = ENV.fetch("PATH", nil)) = { "PATH" => path.to_s }.merge(spec[:env])
 

data/lib/asgard/schedule/job_files.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Asgard
+  module Schedule
+    # Reading back the job files a backend writes, the same way for
+    # launchd plists and systemd units. Pure apart from reading the files.
+    module JobFiles
+      module_function
+
+      # [[project_slug, name], ...], sorted, for each job file in +dir+.
+      def entries_in(dir, prefix:, ext:) = entries(Dir.glob(File.join(dir, "#{prefix}.*#{ext}")), prefix:, ext:)
+
+      # [[project_slug, name], ...], sorted, for each of +paths+ named
+      # <prefix>.<project_slug>.<name><ext>; any other file name is skipped.
+      def entries(paths, prefix:, ext:)
+        paths.map { File.basename(it, ext).delete_prefix("#{prefix}.").split(".", 2) }.select { it.size == 2 }.sort
+      end
+
+      # The project root +parser+ reads from the job file at +path+, or nil
+      # when there is no such file.
+      def directory(path, parser) = File.exist?(path) ? parser.call(File.read(path)) : nil
+    end
+  end
+end

data/lib/asgard/schedule/launchd.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "job_files"
 
 module Asgard
   module Schedule
@@ -28,6 +29,9 @@ module Asgard
       # ("label" => disabled, or "label" => true on older macOS).
       def self.disabled_labels(output) = output.scan(/"([^"]+)"\s*=>\s*(disabled|true)\b/).map(&:first)
 
+      # Whether the installed file at +path+ already holds +content+.
+      def self.unchanged?(path, content) = File.exist?(path) && File.read(path) == content
+
       def self.plist(label:, arguments:, working_directory:, environment:, log_path:, intervals: nil, every: nil)
         dict = {
           "Label"                => label,
@@ -134,12 +138,21 @@ module Asgard
         { plist_path(name) => plist }
       end
 
+      # An unchanged plist whose job is loaded is left alone: a bootout
+      # would kill a run in progress for nothing. A changed one is linted
+      # before it replaces the installed file, then reloaded.
       def install(spec, asgard:, direnv:)
-        name  = spec[:name]
-        plist = plist_path(name)
-        FileUtils.mkdir_p [File.dirname(plist), File.dirname(log_path(name))]
-        files(spec, asgard:, direnv:).each { |path, content| File.write(path, content) }
-        run! "plutil", "-lint", "-s", plist
+        name    = spec[:name]
+        plist   = plist_path(name)
+        log     = log_path(name)
+        content = files(spec, asgard:, direnv:).fetch(plist)
+        Schedule.check_lengths!([plist, "#{plist}.new", log])
+        return :active if self.class.unchanged?(plist, content) && loaded?(name)
+
+        Schedule.writing do
+          FileUtils.mkdir_p [File.dirname(plist), File.dirname(log)]
+          write_linted(plist, content)
+        end
         unload(name)
         return :stopped if stopped?(name)
 
@@ -171,11 +184,7 @@ module Asgard
       end
 
       # Every asgard entry on this machine, whatever its project: [[project_slug, name], ...].
-      def installed_entries
-        paths = Dir.glob(File.join(@home, "Library", "LaunchAgents", "#{LABEL_PREFIX}.*.plist"))
-        paths.map { |path| File.basename(path, ".plist").delete_prefix("#{LABEL_PREFIX}.").split(".", 2) }
-             .select { |entry| entry.size == 2 }.sort
-      end
+      def installed_entries = JobFiles.entries_in(File.join(@home, "Library", "LaunchAgents"), prefix: LABEL_PREFIX, ext: ".plist")
 
       # { command:, schedule: } as installed, read from the plist; nil when there isn't one.
       def installed_columns(name)
@@ -186,17 +195,23 @@ module Asgard
       end
 
       # The project root the job runs in, read from the plist; nil when there isn't one.
-      def installed_directory(name)
-        path = plist_path(name)
-        self.class.parse_directory(File.read(path)) if File.exist?(path)
-      end
+      def installed_directory(name) = JobFiles.directory(plist_path(name), self.class.method(:parse_directory))
 
       def status(name)
         out, ok = run("launchctl", "print", target(name))
         return { state: stopped?(name) ? :stopped : :not_loaded, last_exit: nil } unless ok
 
+        { state: out.include?("state = running") ? :running : :active, last_exit: self.class.last_exit(out) }
+      end
+
+      # The last exit from `launchctl print`: its code, or the signal that
+      # ended it ("signal 15 (Terminated)"); nil when it never exited.
+      def self.last_exit(out)
         code = out[/last exit code = (\d+)/, 1]
-        { state: :active, last_exit: code }
+        return code if code
+
+        signal = out.match(/last terminating signal = ([^:\n]+): (\d+)/)
+        Schedule.signal_exit(signal[2], signal[1]) if signal
       end
 
       def notes = []
@@ -205,6 +220,17 @@ module Asgard
 
       def target(name) = "#{@domain}/#{label(name)}"
 
+      # Written beside the plist (not *.plist, so never listed), linted,
+      # then renamed over it; a plist plutil rejects never lands.
+      def write_linted(plist, content)
+        draft = "#{plist}.new"
+        Schedule.write_private(draft, content)
+        run! "plutil", "-lint", "-s", draft
+        File.rename(draft, plist)
+      ensure
+        FileUtils.rm_f(draft)
+      end
+
       def loaded?(name) = run("launchctl", "print", target(name)).last
 
       def stopped?(name)
@@ -213,16 +239,27 @@ module Asgard
       end
 
       # bootout returns before the job is fully gone; bootstrapping the same
-      # label too soon fails with "Input/output error", so wait for it.
+      # label too soon fails with "Input/output error", so wait for it. A job
+      # still loaded afterwards raises, so callers never delete the plist of
+      # a job launchd keeps running.
       def unload(name)
         return unless loaded?(name)
 
-        run "launchctl", "bootout", target(name)
+        out, ok = run("launchctl", "bootout", target(name))
+        return if ok && unloaded?(name)
+        return unless loaded?(name)
+
+        raise Error, "launchctl bootout #{target(name)} left #{label(name)} still loaded: #{out.strip}"
+      end
+
+      # Polls for up to two seconds; true once the job is gone.
+      def unloaded?(name)
         20.times do
-          break unless loaded?(name)
+          return true unless loaded?(name)
 
           sleep 0.1
         end
+        false
       end
 
       def run(*argv) = @runner.call(*argv)

data/lib/asgard/schedule/systemd.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "etc"
+require_relative "job_files"
 
 module Asgard
   module Schedule
@@ -15,6 +16,8 @@ module Asgard
     class Systemd
       UNIT_PREFIX = "asgard"
       DAY_ABBREVIATIONS = %w[Sun Mon Tue Wed Thu Fri Sat].freeze
+      # The service properties status asks `systemctl show` for.
+      SHOW_PROPERTIES = %w[ActiveState SubState ExecMainCode ExecMainStatus ExecMainExitTimestampMonotonic].freeze
 
       # ---- pure helpers -----------------------------------------------------
 
@@ -31,14 +34,23 @@ module Asgard
       # systemd expands %specifiers everywhere; % must be doubled to be literal.
       def self.escape_specifiers(text) = text.to_s.gsub("%", "%%")
 
-      # A double-quoted word for ExecStart=/Environment=. $ is doubled too so
-      # ExecStart= doesn't expand it as a variable.
-      def self.quote(text)
-        %("#{escape_specifiers(text).gsub('\\') { '\\\\' }.gsub('"', '\\"').gsub('$', '$$')}")
-      end
+      # A double-quoted word for ExecStart=. $ is doubled too so ExecStart=
+      # doesn't expand it as a variable.
+      def self.quote(text) = %("#{quote_body(text).gsub('$', '$$')}")
+
+      # A double-quoted Environment= assignment. Environment= does no
+      # variable expansion, so a $ there is already literal and doubling it
+      # would leave $$ in the value (systemd.exec(5)).
+      def self.quote_env(text) = %("#{quote_body(text)}")
 
+      # % doubled, \ and " backslash-escaped: what both kinds of quoting share.
+      def self.quote_body(text) = escape_specifiers(text).gsub('\\') { '\\\\' }.gsub('"', '\\"')
+
+      # KillMode=process: when the run ends, systemd kills only the task's own
+      # process, so background jobs it started (setsid alone can't leave the
+      # unit's cgroup) keep running, as they do under launchd.
       def self.service_unit(description:, arguments:, working_directory:, environment:, log_path:)
-        env_lines = environment.map { |key, value| "Environment=#{quote("#{key}=#{value}")}" }
+        env_lines = environment.map { |key, value| "Environment=#{quote_env("#{key}=#{value}")}" }
         log       = escape_specifiers(log_path)
         <<~UNIT
           [Unit]
@@ -46,6 +58,7 @@ module Asgard
 
           [Service]
           Type=oneshot
+          KillMode=process
           WorkingDirectory=#{escape_specifiers(working_directory)}
           #{env_lines.join("\n")}
           ExecStart=#{arguments.map { |arg| quote(arg) }.join(' ')}
@@ -103,6 +116,22 @@ module Asgard
       # `systemctl show -p A -p B` output => { "A" => "...", "B" => "..." }
       def self.parse_show(output) = output.lines.to_h { |line| line.chomp.split("=", 2) }.reject { |k, _| k.to_s.empty? }
 
+      # parse_show of SHOW_PROPERTIES => { running: Boolean, last_exit: String|nil }.
+      # A oneshot service is "activating" while its command runs. ExecMainCode
+      # 2 (killed) or 3 (dumped) means ExecMainStatus is a signal number.
+      def self.service_status(props)
+        stamp  = props["ExecMainExitTimestampMonotonic"].to_s
+        status = props["ExecMainStatus"] unless stamp.empty? || stamp == "0"
+        signal = status if %w[2 3].include?(props["ExecMainCode"])
+        {
+          running:   props["ActiveState"] == "activating" || props["SubState"] == "running",
+          last_exit: signal ? Schedule.signal_exit(signal, "SIG#{Signal.signame(signal.to_i)}") : status
+        }
+      end
+
+      # The { path => content } entries whose file is missing or differs.
+      def self.changed_files(files) = files.reject { |path, content| File.exist?(path) && File.read(path) == content }
+
       # ---- backend API ------------------------------------------------------
 
       def initialize(project:, root:, home: Dir.home, runner: Schedule.runner, env: ENV, user: Etc.getpwuid(Process.uid).name)
@@ -144,25 +173,36 @@ module Asgard
         { service_path(name) => service, timer_path(name) => timer }
       end
 
-      # A timer that exists but is disabled was stopped on purpose; keep it so.
+      # A timer that exists but is disabled was stopped on purpose; keep it
+      # so. That is only true once an install has finished, so a first
+      # install that fails takes its unit files back out. Unchanged units are
+      # left alone: restarting a timer would restart an every: countdown, and
+      # `start` is a no-op for a timer already running.
       def install(spec, asgard:, direnv:)
         name       = spec[:name]
         timer_file = timer_path(name)
         timer_unit = timer(name)
-        stopped    = File.exist?(timer_file) && !enabled?(name)
-        FileUtils.mkdir_p [File.dirname(timer_file), File.dirname(log_path(name))]
-        files(spec, asgard:, direnv:).each { |path, content| File.write(path, content) }
-        systemctl! "daemon-reload"
+        job        = files(spec, asgard:, direnv:)
+        Schedule.check_lengths!([*job.keys, log_path(name)])
+        first      = !File.exist?(timer_file)
+        stopped    = !first && !enabled?(name)
+        changed    = write_changed(job, name).any?
+        systemctl! "daemon-reload" if changed
         return :stopped if stopped
 
         systemctl! "enable", timer_unit
-        systemctl! "restart", timer_unit # picks up a changed schedule
+        systemctl! changed ? "restart" : "start", timer_unit # restart picks up a changed schedule
         :active
+      rescue Error
+        FileUtils.rm_f([service_path(name), timer_file]) if first
+        raise
       end
 
+      # A timer that won't disable is left installed, files and all, rather
+      # than deleted while systemd keeps it running.
       def uninstall(name)
         service_unit = service(name)
-        systemctl "disable", "--now", timer(name)
+        systemctl! "disable", "--now", timer(name)
         systemctl "stop", service_unit
         FileUtils.rm_f [service_path(name), timer_path(name)]
         systemctl "daemon-reload"
@@ -181,11 +221,7 @@ module Asgard
       end
 
       # Every asgard entry on this machine, whatever its project: [[project_slug, name], ...].
-      def installed_entries
-        paths = Dir.glob(File.join(@config, "systemd", "user", "#{UNIT_PREFIX}.*.timer"))
-        paths.map { |path| File.basename(path, ".timer").delete_prefix("#{UNIT_PREFIX}.").split(".", 2) }
-             .select { |entry| entry.size == 2 }.sort
-      end
+      def installed_entries = JobFiles.entries_in(File.join(@config, "systemd", "user"), prefix: UNIT_PREFIX, ext: ".timer")
 
       # { command:, schedule: } as installed, read from the unit files; nil when there are none.
       def installed_columns(name)
@@ -198,10 +234,7 @@ module Asgard
       end
 
       # The project root the job runs in, read from the service unit; nil when there isn't one.
-      def installed_directory(name)
-        path = service_path(name)
-        self.class.parse_directory(File.read(path)) if File.exist?(path)
-      end
+      def installed_directory(name) = JobFiles.directory(service_path(name), self.class.method(:parse_directory))
 
       def status(name)
         _, active = systemctl("is-active", "--quiet", timer(name))
@@ -209,11 +242,10 @@ module Asgard
                 elsif enabled?(name) then :not_loaded
                 else :stopped
                 end
-        out, = systemctl("show", service(name), "-p", "ExecMainStatus", "-p", "ExecMainExitTimestampMonotonic")
-        props = self.class.parse_show(out)
-        stamp = props["ExecMainExitTimestampMonotonic"].to_s
-        ran   = !stamp.empty? && stamp != "0"
-        { state:, last_exit: ran ? props["ExecMainStatus"] : nil }
+        klass = self.class
+        out,  = systemctl("show", service(name), *SHOW_PROPERTIES.flat_map { |prop| ["-p", prop] })
+        running, last_exit = klass.service_status(klass.parse_show(out)).values_at(:running, :last_exit)
+        { state: running ? :running : state, last_exit: }
       end
 
       def notes
@@ -229,6 +261,16 @@ module Asgard
 
       def service(name) = "#{unit(name)}.service"
 
+      # Writes the unit files whose content changed (and the log directory);
+      # returns them as { path => content }.
+      def write_changed(job, name)
+        changed = self.class.changed_files(job)
+        Schedule.writing do
+          FileUtils.mkdir_p [File.dirname(timer_path(name)), File.dirname(log_path(name))]
+          changed.each { |path, content| Schedule.write_private(path, content) }
+        end
+      end
+
       def enabled?(name) = systemctl("is-enabled", "--quiet", timer(name)).last
 
       def systemctl(*) = run("systemctl", "--user", *)