ruby_raider 4.1.0 → 4.2.0

data/lib/utilities/schedules/legacy.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'adapter'
+require_relative 'os_enumerator'
+require_relative 'rule'
+
+module RubyRaider
+  module Schedules
+    # Removes the schedules Ruby Raider 4.1 made in a project (Kind::FLOW_LEGACY): they can't run in 4.2.
+    # Every `raider schedule` command runs it first, and so does the hidden stub an old OS entry reaches.
+    # It only ever acts on this project's os_ids, each recomputed from the project's real path and a name
+    # (from the old schedules.yml or the OS scheduler); an os_id stored in the yml is never used. It deletes
+    # the old schedules.yml once every entry is gone, and nothing else, and only when the file is a 4.1
+    # schedules file all of whose entries are this project's: a file it can't read, or one with an entry
+    # of another path (a moved project), stays, since its os_ids are what the user needs to remove by hand.
+    # An adapter's error text is passed through as is on purpose: it names the os_id the README says to look for.
+    # Never raises.
+    # :reek:TooManyConstants { max_constants: 6 } -- the kind, file, size cap, open flags and the old rule
+    # :reek:TooManyInstanceVariables { max_instance_variables: 5 } -- the project, its root, adapter, stream and whether the yml may go
+    class Legacy
+      KIND = Kind::FLOW_LEGACY
+      FILE = 'schedules.yml'
+      MAX_BYTES = 1_000_000
+      NOFOLLOW = defined?(File::NOFOLLOW) ? File::NOFOLLOW : 0
+      NONBLOCK = defined?(File::NONBLOCK) ? File::NONBLOCK : 0
+
+      # The 4.1 rule, for its os_ids only (os_id_for, os_id_prefix_for)
+      class OldRule < Rule
+        def self.kind = KIND
+      end
+
+      # project: a Project (its real root); adapter: nil picks this machine's OS scheduler when first needed
+      def initialize(project, adapter: nil, err: $stderr)
+        @project = project
+        @root = project.root
+        @adapter = adapter
+        @err = err
+        @yml_clean = false
+      end
+
+      # True when the project has a real .raider/flows folder (4.1 always made one; this never deletes it):
+      # without one there is nothing to clean, so `raider schedule` skips the cleanup for one lstat
+      def self.folder?(project)
+        File.lstat(File.join(project.root, KIND.dir)).directory?
+      rescue SystemCallError
+        false
+      end
+
+      # Removes every 4.1 schedule of the project, then its schedules.yml. Prints and returns the notice, nil
+      # when there was nothing to remove. last: the name of the entry running this (the stub's own), removed
+      # after the notice is written and the yml deleted, since removing it may end this process.
+      def cleanup(last: nil)
+        current = adapter
+        return nil unless current
+
+        names = (yml_names | OsEnumerator.new(current, schedule_class: OldRule, root: @root).names).sort
+        own = names.delete(last) if last
+        removed, failed = remove_all(current, names)
+        removed << own if own
+        delete_yml if failed.empty?
+        notice = notice(removed, failed)
+        say(notice) if notice
+        remove_own(current, own) if own
+        notice
+      rescue StandardError => e
+        say("Could not remove the schedules made with Ruby Raider 4.1: #{e.message}")
+      end
+
+      private
+
+      def adapter
+        @adapter ||= Schedules.adapter(kind: KIND)
+      rescue Error
+        nil
+      end
+
+      # [removed names, [name, message] of each that failed]; one already gone is neither
+      def remove_all(current, names)
+        removed = []
+        failed = []
+        names.each do |name|
+          removed << name if current.remove(OldRule.os_id_for(@root, name))
+        rescue Error, SystemCallError => e
+          failed << [name, e.message]
+        end
+        [removed, failed]
+      end
+
+      # Its own entry last: the notice is out (and flushed) and the yml gone before this may end the process
+      def remove_own(current, name)
+        current.remove(OldRule.os_id_for(@root, name))
+      rescue Error, SystemCallError => e
+        say("Could not remove #{name}: #{e.message}")
+      end
+
+      def notice(removed, failed)
+        lines = []
+        lines << removed_text(removed) unless removed.empty?
+        lines << failed_text(failed) unless failed.empty?
+        lines.empty? ? nil : Schedules.printable(lines.join(' '))
+      end
+
+      def removed_text(names)
+        one = names.size == 1
+        "Removed #{counted(names.size)} made with Ruby Raider 4.1 (#{names.join(', ')}); #{one ? 'it' : 'they'} can't run in 4.2. " \
+          "Add #{one ? 'it' : 'them'} again with raider schedule add."
+      end
+
+      def failed_text(failed)
+        reasons = failed.map { |name, message| "#{name}: #{message}" }.join(', ')
+        "Could not remove #{counted(failed.size)} made with Ruby Raider 4.1 (#{reasons}); " \
+          "#{failed.size == 1 ? 'it is' : 'they are'} tried again next time."
+      end
+
+      def counted(count) = count == 1 ? '1 schedule' : "#{count} schedules"
+
+      # One printable line on err, flushed; returns it
+      def say(text)
+        line = Schedules.printable(text)
+        err = @err
+        err.puts(line)
+        err.flush if err.respond_to?(:flush)
+        line
+      rescue StandardError
+        line
+      end
+
+      def dir = File.join(@root, KIND.dir)
+
+      def yml = File.join(dir, FILE)
+
+      # .raider and .raider/flows are real folders, not links (a missing one is one failed lstat)
+      def real_dirs? = [File.join(@root, '.raider'), dir].all? { |path| File.lstat(path).directory? }
+
+      # The names of the yml's entries that 4.1 would read as this project's: valid, with the os_id it
+      # computes for this project; anything else in the file, or a file that is not a schedules file, gives
+      # none. The yml may go only when it was a schedules file and every entry was one of these.
+      def yml_names
+        entries = read_entries
+        return [] unless entries
+
+        names = entries.map { |entry| entry_name(entry) }
+        @yml_clean = names.all?
+        names.compact.uniq
+      end
+
+      def entry_name(entry)
+        return nil unless entry.is_a?(Hash)
+
+        name = entry['name']
+        name if name.is_a?(String) && KIND.valid_name?(name) && entry['os_id'] == OldRule.os_id_for(@root, name)
+      end
+
+      # The entries of a schedules file ([] for an empty document); nil when there is none or it is not one
+      def read_entries
+        text = read_text
+        return nil unless text
+
+        data = YAML.safe_load(text)
+        return [] unless data
+
+        entries = data.is_a?(Hash) ? data['schedules'] : nil
+        entries.is_a?(Array) ? entries : nil
+      rescue Psych::Exception
+        nil
+      end
+
+      # The yml through one handle that is not a link, a regular file up to MAX_BYTES; nil otherwise.
+      # The folders are lstat'ed and then the file opened (and later unlinked) by path, so a folder swapped
+      # for a link in between is followed: that takes write access to the project, and Ruby has no
+      # openat/unlinkat to close the window.
+      def read_text
+        return nil unless real_dirs?
+
+        File.open(yml, File::RDONLY | NONBLOCK | NOFOLLOW) do |file|
+          next nil unless file.stat.file?
+
+          text = file.read(MAX_BYTES + 1) || +'' # an empty file reads nil
+          text.bytesize > MAX_BYTES ? nil : text.force_encoding(Encoding::UTF_8)
+        end
+      rescue SystemCallError
+        nil
+      end
+
+      # The yml only, when it was read as a clean schedules file and the folders and it still are real
+      # (a link or folder stays)
+      def delete_yml
+        path = yml
+        File.unlink(path) if @yml_clean && real_dirs? && File.lstat(path).file?
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/utilities/schedules/legacy_stub.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'legacy'
+require_relative 'project'
+
+module RubyRaider
+  module Schedules
+    # What a Ruby Raider 4.1 OS entry reaches now: `raider flow run NAME --project ROOT --trigger schedule ...`.
+    # Raider.start sends it here before Thor, so any argv works. It removes the project's 4.1 schedules (its
+    # own entry last), writes one line to stderr (the entry's scheduler.log) and always exits 2. It never
+    # sends a notification and never takes the project from the current folder.
+    module LegacyStub
+      EXIT = 2
+      REMOVED = 'This command was removed in Ruby Raider 4.2. To run tests on a schedule, use raider schedule add.'
+      OPTION = '--project'
+
+      # The exit code: always 2
+      def self.run(argv, err: $stderr)
+        root = project_root(argv)
+        root ? clean(root, own_name(argv), err) : err.puts(REMOVED)
+        EXIT
+      rescue StandardError
+        EXIT
+      end
+
+      def self.clean(root, name, err)
+        return if Legacy.new(Project.new(root), err: err).cleanup(last: name)
+
+        err.puts(Schedules.printable("This schedule was made with Ruby Raider 4.1 and can't run in 4.2, and none was found for #{root} " \
+                                     'to remove: see Upgrading from 4.1 in the README.'))
+      end
+
+      # The real path of the first --project value: valid UTF-8, absolute, a folder with a regular Gemfile
+      def self.project_root(argv)
+        path = project_value(argv)
+        return nil unless path.is_a?(String) && path.valid_encoding? && !path.include?("\0") && File.absolute_path?(path)
+
+        root = File.realpath(path)
+        File.directory?(root) && File.lstat(File.join(root, 'Gemfile')).file? ? root : nil
+      rescue SystemCallError
+        nil
+      end
+
+      # --project VALUE or --project=VALUE, whichever comes first
+      def self.project_value(argv)
+        argv.each_with_index do |arg, index|
+          next unless arg.is_a?(String) && arg.valid_encoding?
+          return argv[index + 1] if arg == OPTION
+          return arg.delete_prefix("#{OPTION}=") if arg.start_with?("#{OPTION}=")
+        end
+        nil
+      end
+
+      # The name after the first run, when it is a valid 4.1 name
+      def self.own_name(argv)
+        index = argv.index('run')
+        name = index && argv[index + 1]
+        name if name.is_a?(String) && name.valid_encoding? && Legacy::KIND.valid_name?(name)
+      end
+    end
+  end
+end

data/lib/utilities/{flows → schedules}/next_run.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require 'date'
-require_relative 'schedule'
+require_relative 'base'
 
 module RubyRaider
-  module Flows
+  module Schedules
     # When a schedule next runs, in local time, as launchd, schtasks, systemd and cron count it.
     # A day, weekday or week rule whose time falls in a spring-forward gap runs at the first minute
     # after the gap; one that falls in a fall-back hour runs at its first occurrence only.

data/lib/utilities/{flows → schedules}/notifier.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require 'rbconfig'
-require_relative 'project'
+require_relative 'base'
 require_relative 'os/command_runner'
 
 module RubyRaider
-  module Flows
-    # A desktop notification for `raider flow run --notify`. The title and message only ever travel as argv
+  module Schedules
+    # A desktop notification for a scheduled run with --notify. The title and message only ever travel as argv
     # items after `--` (osascript, notify-send: so a title like -e is not read as an option or a script) or as
-    # environment values (PowerShell), so a hostile flow name or step title can't run as AppleScript or PowerShell. Never raises: a notification
+    # environment values (PowerShell), so a hostile schedule name or test title can't run as AppleScript or PowerShell. Never raises: a notification
     # that can't be shown must not change how the run ends.
     # :reek:TooManyConstants { max_constants: 7 } -- the fixed command of each OS, the message cap and the timeout
     # :reek:TooManyInstanceVariables { max_instance_variables: 5 } -- the injected runner, OS, stream and PowerShell path, and the warned flag
@@ -64,10 +64,10 @@ module RubyRaider
 
       private
 
-      def clean(text) = Flows.printable(text)[0, MAX].to_s
+      def clean(text) = Schedules.printable(text)[0, MAX].to_s
 
       def failed(reason)
-        @err.puts("Could not show a desktop notification: #{Flows.printable(reason.strip)}") unless @warned
+        @err.puts("Could not show a desktop notification: #{Schedules.printable(reason.strip)}") unless @warned
         @warned = true
         false
       end

data/lib/utilities/{flows → schedules}/os/command_runner.rb

@@ -3,7 +3,7 @@
 require 'open3'
 
 module RubyRaider
-  module Flows
+  module Schedules
     module Os
       # Runs an OS scheduler command (launchctl, schtasks, systemctl, crontab) with no shell. Adapters
       # take one, so tests pass a double and never touch the real scheduler.

data/lib/utilities/{flows → schedules}/os/cron.rb

@@ -2,22 +2,22 @@
 
 require 'shellwords'
 require_relative 'command_runner'
-require_relative '../schedule'
+require_relative '../base'
 
 module RubyRaider
-  module Flows
+  module Schedules
     module Os
       # Linux without a systemd user manager: one tagged block per schedule in the user's crontab, read with
       # `crontab -l` and written back with `crontab -`. Every value goes through Shellwords.escape, which also
       # escapes % as \% (cron would turn a bare % into a newline). Lines that are not ours keep every byte.
       class Cron
         CRONTAB = 'crontab'
-        TAG = '# raider-flow '
         # Debian's vixie cron cuts a command at MAX_COMMAND (1000) bytes without a word; stay under it
         MAX_LINE = 990
-        OS_ID = /\A#{Regexp.escape(Schedule::OS_ID_PREFIX)}\.[0-9a-f]{10}\.([a-z0-9_]{1,60})\z/
 
-        def initialize(runner: CommandRunner.new)
+        # kind: the Kind whose entries this crontab block holds
+        def initialize(kind:, runner: CommandRunner.new)
+          @kind = kind
           @runner = runner
         end
 
@@ -28,7 +28,7 @@ module RubyRaider
         # Minute hour day-of-month month day-of-week (the system time zone), then the command for /bin/sh
         def line(schedule)
           ruby = schedule.ruby
-          raise Error, "cron can not run ruby from #{Flows.printable(ruby)}: env would read the = as a variable" if ruby.include?('=')
+          raise Error, "cron can not run ruby from #{Schedules.printable(ruby)}: env would read the = as a variable" if ruby.include?('=')
 
           env = schedule.env.map { |key, value| "#{key}=#{value}" }
           command = ['cd', escape(schedule.working_directory), '&&', '/usr/bin/env', *[*env, *schedule.argv].map { |word| escape(word) },
@@ -43,7 +43,7 @@ module RubyRaider
           raise Error, "cron can not run #{schedule.name}: its crontab line is #{entry.bytesize} bytes, over #{MAX_LINE}" if entry.bytesize > MAX_LINE
 
           rest, = without(read, os_id)
-          save("#{TAG}#{os_id}\n#{entry}\n#{rest}")
+          save("#{@kind.cron_tag}#{os_id}\n#{entry}\n#{rest}")
           true
         end
 
@@ -60,6 +60,16 @@ module RubyRaider
           without(read, tag).last
         end
 
+        # The os_ids of this kind starting with prefix on our tag lines, sorted
+        def list_ids(prefix)
+          tag = @kind.cron_tag
+          read.dup.force_encoding(Encoding::UTF_8).scrub.each_line.filter_map do |text|
+            line = text.chomp
+            id = line.delete_prefix(tag)
+            id if id != line && @kind.listed?(id, prefix)
+          end.uniq.sort
+        end
+
         # True when crontab -l answers (an empty crontab counts)
         def usable?
           read
@@ -84,7 +94,7 @@ module RubyRaider
 
         # cron counts Sunday as 0
         def weekday(day)
-          index = Schedule::DAYS.index(day)
+          index = DAYS.index(day)
           raise Error, "Invalid day #{day.inspect}" unless index
 
           (index + 1) % 7
@@ -95,8 +105,8 @@ module RubyRaider
         # The crontab without any of our tag lines, each with the line after it when that line is our command,
         # and whether a tag was there
         def without(table, os_id)
-          tag = "#{TAG}#{os_id}"
-          name = OS_ID.match(os_id).to_a[1]
+          tag = "#{@kind.cron_tag}#{os_id}"
+          name = @kind.os_id_pattern.match(os_id).to_a[1]
           kept = []
           found = after_tag = false
           table.lines.each do |text|
@@ -108,28 +118,28 @@ module RubyRaider
           [kept.join, found]
         end
 
-        # The line under our tag runs `raider flow run <name> --project ... --trigger schedule`
-        def our_command?(text, name) = text.include?(" exec raider flow run #{name} --project ") && text.include?(' --trigger schedule')
+        # The line under our tag runs `raider <command> run <name> --project ... --trigger schedule`
+        def our_command?(text, name) = @kind.our_command?(text, name)
 
         def read
           result = @runner.call(CRONTAB, '-l')
           return result.stdout if result.success?
 
-          stderr = result.stderr
+          stderr = result.stderr.scrub('?')
           return '' if stderr.match?(/no crontab/i)
 
-          raise Error, "cron could not read the crontab: #{Flows.printable(stderr.strip)}"
+          raise Error, "cron could not read the crontab: #{Schedules.printable(stderr.strip)}"
         end
 
         def save(table)
           result = @runner.call(CRONTAB, '-', stdin_data: table)
-          raise Error, "cron could not save the crontab: #{Flows.printable(result.stderr.strip)}" unless result.success?
+          raise Error, "cron could not save the crontab: #{Schedules.printable(result.stderr.strip)}" unless result.success?
         end
 
         def checked_os_id(os_id)
-          return os_id if os_id.is_a?(String) && (match = OS_ID.match(os_id)) && Flows.valid_name?(match[1])
+          return os_id if @kind.name_in(os_id)
 
-          raise Error, "Invalid os_id #{Flows.printable(os_id.inspect)}: not a flow schedule"
+          raise Error, "Invalid os_id #{Schedules.printable(os_id.inspect)}: #{@kind.not_ours}"
         end
       end
     end

data/lib/utilities/{flows → schedules}/os/launchd.rb

@@ -3,14 +3,14 @@
 require 'fileutils'
 require 'securerandom'
 require_relative 'command_runner'
-require_relative '../schedule'
+require_relative '../base'
 
 module RubyRaider
-  module Flows
+  module Schedules
     module Os
       # macOS: a LaunchAgent plist in ~/Library/LaunchAgents per schedule, loaded into the user's GUI
       # domain with launchctl. Every value in the plist goes through one XML escaper.
-      # :reek:TooManyConstants { max_constants: 6 } -- the two tools, NOFOLLOW, the XML escapes and header, the os_id rule
+      # :reek:TooManyConstants { max_constants: 5 } -- the two tools, NOFOLLOW, the XML escapes and header
       class Launchd
         LAUNCHCTL = '/bin/launchctl'
         PLUTIL = '/usr/bin/plutil'
@@ -21,9 +21,10 @@ module RubyRaider
           <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
           <plist version="1.0">
         XML
-        OS_ID = /\A#{Regexp.escape(Schedule::OS_ID_PREFIX)}\.[0-9a-f]{10}\.([a-z0-9_]{1,60})\z/
 
-        def initialize(runner: CommandRunner.new, home: Dir.home, uid: Process.uid)
+        # kind: the Kind whose LaunchAgents this adapter writes and removes
+        def initialize(kind:, runner: CommandRunner.new, home: Dir.home, uid: Process.uid)
+          @kind = kind
           @runner = runner
           @home = home
           @uid = uid
@@ -57,18 +58,35 @@ module RubyRaider
           result = launchctl('bootstrap', domain, path)
           return true if result.success?
 
-          raise Error, "launchd could not load #{os_id}: #{Flows.printable(result.stderr.strip)}#{discard(path)}"
+          raise Error, "launchd could not load #{os_id}: #{Schedules.printable(result.stderr.strip)}#{discard(path)}"
         end
 
-        # True when a plist or a loaded service was removed, false when it was already gone
+        # True when a plist or a loaded service was removed, false when it was already gone. The plist goes
+        # first: a job removing itself is ended by its own bootout, and its plist must be gone by then.
+        # If the unlink succeeds and the bootout fails, the job stays loaded with no plist until logout.
         def remove(os_id)
-          path = plist_path(os_id)
+          unlinked = unlink(plist_path(os_id))
           unloaded = launchctl('bootout', service(os_id)).success?
-          unlink(path) || unloaded
+          unlinked || unloaded
         end
 
         def present?(os_id) = launchctl('print', service(checked_os_id(os_id))).success?
 
+        # The os_ids of this kind starting with prefix that have a plist, sorted; runs nothing
+        def list_ids(prefix)
+          dir = agents_dir
+          Dir.children(dir).filter_map do |file|
+            next unless file.valid_encoding? && file.end_with?('.plist')
+
+            id = file.delete_suffix('.plist')
+            id if @kind.listed?(id, prefix)
+          end.sort
+        rescue Errno::ENOENT
+          []
+        rescue SystemCallError => e
+          raise Error, "Could not read #{dir}: #{e.message}"
+        end
+
         private
 
         def launchctl(*args) = @runner.call(LAUNCHCTL, *args)
@@ -90,9 +108,9 @@ module RubyRaider
         def agents_dir = File.join(@home, 'Library', 'LaunchAgents')
 
         def checked_os_id(os_id)
-          return os_id if os_id.is_a?(String) && (match = OS_ID.match(os_id)) && Flows.valid_name?(match[1])
+          return os_id if @kind.name_in(os_id)
 
-          raise Error, "Invalid os_id #{Flows.printable(os_id.inspect)}: not a flow schedule"
+          raise Error, "Invalid os_id #{Schedules.printable(os_id.inspect)}: #{@kind.not_ours}"
         end
 
         def escape(text) = text.to_s.gsub(/[&<>"']/, ESCAPES)
@@ -110,7 +128,7 @@ module RubyRaider
 
         def indent(lines) = lines.map { |line| "\t#{line}" }
 
-        # Schedule::DAYS runs mon..sun
+        # DAYS runs mon..sun
         def calendar(schedule)
           time = [['Hour', integer(schedule.hour)], ['Minute', integer(schedule.minute)]]
           case schedule.every
@@ -124,7 +142,7 @@ module RubyRaider
 
         # launchd counts Sunday as 0
         def weekday(day)
-          index = Schedule::DAYS.index(day)
+          index = DAYS.index(day)
           raise Error, "Invalid day #{day.inspect}" unless index
 
           (index + 1) % 7
@@ -150,7 +168,7 @@ module RubyRaider
             file.chmod(0o644)
           end
           lint = @runner.call(PLUTIL, '-lint', temp)
-          raise Error, "launchd plist for #{File.basename(path)} is invalid: #{Flows.printable("#{lint.stdout} #{lint.stderr}".strip)}" unless lint.success?
+          raise Error, "launchd plist for #{File.basename(path)} is invalid: #{Schedules.printable("#{lint.stdout} #{lint.stderr}".strip)}" unless lint.success?
 
           File.rename(temp, path)
         rescue SystemCallError => e

data/lib/utilities/{flows → schedules}/os/linux.rb

@@ -5,16 +5,18 @@ require_relative 'systemd'
 require_relative 'cron'
 
 module RubyRaider
-  module Flows
+  module Schedules
     module Os
       # Linux: systemd user timers when the user's systemd manager answers, cron otherwise. A schedule made over
       # ssh (no user bus, so cron) must still go when unscheduled from a desktop session, so remove and present?
       # also look in the other scheduler when it answers. The reverse (a systemd timer, unscheduled where no user
       # bus answers) can only be seen from its unit files, and can only be removed where systemctl --user works.
       class Linux
-        def self.pick(runner = CommandRunner.new) = new(runner: runner)
+        def self.pick(runner = CommandRunner.new, kind:) = new(kind: kind, runner: runner)
 
-        def initialize(runner: CommandRunner.new, systemd: Systemd.new(runner: runner), cron: Cron.new(runner: runner))
+        # kind: the Kind of the schedules this adapter installs and removes
+        def initialize(kind:, runner: CommandRunner.new, systemd: Systemd.new(kind: kind, runner: runner), cron: Cron.new(kind: kind, runner: runner))
+          @kind = kind
           # systemd is the other one only when it answers, so with cron first there is no other one
           @systemd = systemd
           @primary, @other = systemd.usable? ? [systemd, cron] : [cron, nil]
@@ -38,16 +40,32 @@ module RubyRaider
         # True when either scheduler has it, or systemd unit files are there though systemd does not answer
         def present?(os_id) = @primary.present?(os_id) || other_present?(os_id) || stranded?(os_id)
 
+        # Both schedulers' ids plus systemd unit files (there even when systemd does not answer); only the
+        # primary scheduler failing is an error
+        def list_ids(prefix)
+          (@primary.list_ids(prefix) + other_ids(prefix) + quietly { @systemd.list_ids(prefix) }).uniq.sort
+        end
+
         private
 
+        def other_ids(prefix)
+          other = @other
+          other&.usable? ? quietly { other.list_ids(prefix) } : []
+        end
+
+        def quietly
+          yield
+        rescue Error
+          []
+        end
+
         def stranded?(os_id) = @primary != @systemd && @systemd.unit_files?(os_id)
 
         # Raises so the schedules.yml entry stays until the timer can really go
         def refuse_stranded(os_id)
           return unless stranded?(os_id)
 
-          raise Error, "This schedule is a systemd timer; run raider flow unschedule #{os_id.split('.').last} " \
-                       'from a session where systemctl --user works'
+          raise Error, @kind.stranded(os_id.split('.').last)
         end
 
         # The other scheduler failing counts as not there