confctl 1.0.0

data/lib/confctl/generation/unified.rb

@@ -0,0 +1,117 @@
+module ConfCtl
+  class Generation::Unified
+    # @return [String]
+    attr_reader :host
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Integer, nil]
+    attr_reader :id
+
+    # @return [String]
+    attr_reader :toplevel
+
+    # @return [Time]
+    attr_reader :date
+
+    # @return [Boolean]
+    attr_reader :current
+
+    # @return [Generation::Build]
+    attr_reader :build_generation
+
+    # @return [Generation::Host]
+    attr_reader :host_generation
+
+    # @param host [String]
+    # @param build_generation [Generation::Build]
+    # @param host_generation [Generation::Host]
+    def initialize(host, build_generation: nil, host_generation: nil)
+      @host = host
+      @build_generation = build_generation
+      @host_generation = host_generation
+      @id = host_generation && host_generation.id
+
+      if build_generation
+        @name = build_generation.name
+        @toplevel = build_generation.toplevel
+        @date = build_generation.date
+        @current ||= build_generation.current
+      elsif host_generation
+        @name = host_generation.approx_name
+        @toplevel = host_generation.toplevel
+        @date = host_generation.date
+        @current ||= host_generation.current
+      else
+        raise ArgumentError, 'set build or host'
+      end
+    end
+
+    # @param gen [Generation::Build]
+    def build_generation=(gen)
+      @name = gen.name
+      @date = gen.date
+      @current ||= gen.current
+      @build_generation = gen
+    end
+
+    # @param gen [Generation::Host]
+    def host_generation=(gen)
+      @id = gen.id
+      @current ||= gen.current
+      @host_generation = gen
+    end
+
+    # Determines whether `gen` can be wrapped by this object
+    # @param gen [Generation::Build, Generation::Host]
+    # @return [Boolean]
+    def includes?(gen)
+      return false if host != gen.host || toplevel != gen.toplevel
+
+      if build_generation && gen.is_a?(Generation::Build)
+        build_generation.name == gen.name \
+          && build_generation.swpin_paths == gen.swpin_paths
+      else
+        true
+      end
+    end
+
+    %i[swpin_names swpin_specs].each do |v|
+      define_method(v) do
+        build_generation ? build_generation.send(v) : []
+      end
+    end
+
+    def current_str
+      build = build_generation && build_generation.current
+      host = host_generation && host_generation.current
+
+      if build && host
+        'build+host'
+      elsif build
+        'build'
+      elsif host
+        'host'
+      end
+    end
+
+    def presence_str
+      if build_generation && host_generation
+        'build+host'
+      elsif build_generation
+        'build'
+      elsif host_generation
+        'host'
+      else
+        raise 'programming error'
+      end
+    end
+
+    def destroy
+      build_generation.destroy if build_generation
+      host_generation.destroy if host_generation
+      true
+    end
+  end
+end

data/lib/confctl/generation/unified_list.rb

@@ -0,0 +1,63 @@
+module ConfCtl
+  class Generation::UnifiedList
+    def initialize
+      @generations = []
+    end
+
+    # @param generation [Generation::Build]
+    def add_build_generation(generation)
+      unified = generations.detect { |g| g.includes?(generation) }
+
+      if unified
+        unified.build_generation = generation
+      else
+        generations << Generation::Unified.new(generation.host, build_generation: generation)
+      end
+
+      true
+    end
+
+    # @param generations [Generation::BuildList]
+    def add_build_generations(generations)
+      generations.each { |v| add_build_generation(v) }
+      true
+    end
+
+    # @param generation [Generation::Host]
+    def add_host_generation(generation)
+      unified = generations.detect { |g| g.includes?(generation) }
+
+      if unified
+        unified.host_generation = generation
+      else
+        generations << Generation::Unified.new(generation.host, host_generation: generation)
+      end
+
+      true
+    end
+
+    # @param generations [Generation::HostList]
+    def add_host_generations(generations)
+      generations.each { |v| add_host_generation(v) }
+      true
+    end
+
+    def each(&)
+      generations.each(&)
+    end
+
+    def delete_if(&)
+      generations.delete_if(&)
+    end
+
+    def empty?
+      generations.empty?
+    end
+
+    include Enumerable
+
+    protected
+
+    attr_reader :generations
+  end
+end

data/lib/confctl/git_repo_mirror.rb

@@ -0,0 +1,79 @@
+require 'digest'
+require 'fileutils'
+
+module ConfCtl
+  class GitRepoMirror
+    attr_reader :url, :name
+
+    # @param url [String]
+    # @param quiet [Boolean]
+    def initialize(url, quiet: false)
+      @url = url
+      @quiet = quiet
+      @name = Digest::SHA256.hexdigest(url)
+      @cmd = SystemCommand.new
+    end
+
+    def setup
+      File.stat(mirror_path)
+    rescue Errno::ENOENT
+      FileUtils.mkdir_p(mirror_path)
+      git('clone', args: ['--mirror', url, mirror_path])
+    else
+      git_repo('fetch')
+    end
+
+    def revision_parse(str)
+      git_repo('rev-parse', args: [str])
+    end
+
+    # @param from_ref [String]
+    # @param to_ref [String]
+    def log(from_ref, to_ref, opts: [])
+      ret = "git log for #{from_ref}..#{to_ref}\n"
+      ret << git_repo(
+        'log',
+        opts: ['--no-decorate', '--left-right', '--cherry-mark'] + opts,
+        args: ["#{from_ref}..#{to_ref}"]
+      )
+      ret
+    end
+
+    # @param from_ref [String]
+    # @param to_ref [String]
+    def diff(from_ref, to_ref, opts: [])
+      ret = "git diff for #{from_ref}..#{to_ref}\n"
+      ret << git_repo(
+        'diff',
+        opts:,
+        args: ["#{from_ref}..#{to_ref}"]
+      )
+      ret
+    end
+
+    protected
+
+    attr_reader :cmd, :quiet
+
+    def git_repo(git_cmd, *args, **kwargs)
+      kwargs[:gopts] ||= []
+      kwargs[:gopts] << '-C' << mirror_path
+      git(git_cmd, *args, **kwargs)
+    end
+
+    def git(git_cmd, args: [], opts: [], gopts: [])
+      opts << '--quiet' if quiet && %w[clone fetch].include?(git_cmd)
+
+      out, = cmd.run('git', *gopts, git_cmd, *opts, *args)
+      out.strip
+    end
+
+    def mirror_path
+      File.join(mirror_dir, name)
+    end
+
+    def mirror_dir
+      File.join(ConfCtl.cache_dir, 'git-mirrors')
+    end
+  end
+end

data/lib/confctl/health_checks/base.rb

@@ -0,0 +1,66 @@
+module ConfCtl
+  class HealthChecks::Base
+    # @return [Machine]
+    attr_reader :machine
+
+    # @return [Array<String>]
+    attr_reader :errors
+
+    # @param machine [Machine]
+    def initialize(machine)
+      @machine = machine
+      @errors = []
+    end
+
+    # @yieldparam [Integer] number of attempts
+    # @yieldparam [Array] errors
+    def run
+      @started_at = Time.now
+      now = @started_at
+      attempt = 1
+
+      until timeout?(now)
+        @errors.clear
+        run_check
+        break if successful?
+
+        yield(attempt, errors) if block_given?
+        sleep(cooldown)
+        attempt += 1
+        now = Time.now
+      end
+    end
+
+    def successful?
+      @errors.empty?
+    end
+
+    def description
+      raise NotImplementedError
+    end
+
+    def message
+      @errors.join('; ')
+    end
+
+    protected
+
+    attr_reader :started_at
+
+    def run_check
+      raise NotImplementedError
+    end
+
+    def timeout?(_time)
+      true
+    end
+
+    def cooldown
+      1
+    end
+
+    def add_error(msg)
+      @errors << msg
+    end
+  end
+end

data/lib/confctl/health_checks/run_command.rb

@@ -0,0 +1,179 @@
+require 'confctl/health_checks/base'
+
+module ConfCtl
+  class HealthChecks::RunCommand < HealthChecks::Base
+    class Output
+      # @return [String, nil]
+      attr_reader :match
+
+      # @return [Array<String>]
+      attr_reader :include
+
+      # @return [Array<String>]
+      attr_reader :exclude
+
+      def initialize(opts)
+        @match = opts['match']
+        @include = opts['include']
+        @exclude = opts['exclude']
+      end
+
+      # Returns nil if there is a match
+      # @return [String, nil]
+      def check_match(str)
+        if @match.nil? || str == @match
+          nil
+        else
+          @match
+        end
+      end
+
+      # Returns the string that should be and is not included
+      # @return [String, nil]
+      def check_include(str)
+        @include.each do |inc|
+          return inc unless str.include?(inc)
+        end
+
+        nil
+      end
+
+      # Returns the string that is and should not be included
+      # @return [String, nil]
+      def check_exclude(str)
+        @exclude.each do |exc|
+          return exc if str.include?(exc)
+        end
+
+        nil
+      end
+    end
+
+    class Command
+      # @return [String]
+      attr_reader :description
+
+      # @return [Array<String>]
+      attr_reader :command
+
+      # @return [Integer]
+      attr_reader :exit_status
+
+      # @return [Output]
+      attr_reader :stdout
+
+      # @return [Output]
+      attr_reader :stderr
+
+      # @return [Integer]
+      attr_reader :timeout
+
+      # @return [Integer]
+      attr_reader :cooldown
+
+      def initialize(machine, opts)
+        @description = opts['description']
+        @command = make_command(machine, opts['command'])
+        @exit_status = opts['exitStatus']
+        @stdout = Output.new(opts['standardOutput'])
+        @stderr = Output.new(opts['standardError'])
+        @timeout = opts['timeout']
+        @cooldown = opts['cooldown']
+      end
+
+      def to_s
+        @command.join(' ')
+      end
+
+      protected
+
+      def make_command(machine, args)
+        args.map do |arg|
+          arg.gsub(/\{([^\}]+)\}/) do
+            machine[::Regexp.last_match(1)]
+          end
+        end
+      end
+    end
+
+    # @param machine [Machine]
+    # @param command [Command]
+    # @param remote [Boolean]
+    def initialize(machine, command, remote:)
+      super(machine)
+      @command = command
+      @remote = remote
+    end
+
+    def description
+      if @command.description.empty?
+        @command.to_s
+      else
+        @command.description
+      end
+    end
+
+    protected
+
+    def run_check
+      if @remote
+        run_remote_check
+      else
+        run_local_check
+      end
+    end
+
+    def run_remote_check
+      mc = MachineControl.new(machine)
+      result = mc.execute!(*@command.command)
+
+      if result.status != @command.exit_status
+        add_error("#{@command} failed with #{result.status} (#{@command.description})")
+      end
+
+      check_output(result)
+    end
+
+    def run_local_check
+      cmd = SystemCommand.new
+      result = cmd.run!(*@command.command)
+
+      if result.status != @command.exit_status
+        add_error("#{@command} failed with #{result.status} (#{@command.description})")
+      end
+
+      check_output(result)
+    end
+
+    def check_output(result)
+      # stdout
+      if (fragment = @command.stdout.check_match(result.out))
+        add_error("#{@command}: standard output does not match #{fragment.inspect}")
+
+      elsif (fragment = @command.stdout.check_include(result.out))
+        add_error("#{@command}: standard output does not include #{fragment.inspect}")
+
+      elsif (fragment = @command.stdout.check_exclude(result.out))
+        add_error("#{@command}: standard output includes #{fragment.inspect}")
+
+      # stderr
+      elsif (fragment = @command.stderr.check_match(result.err))
+        add_error("#{@command}: standard error does not match #{fragment.inspect}")
+
+      elsif (fragment = @command.stderr.check_include(result.err))
+        add_error("#{@command}: standard error does not include #{fragment.inspect}")
+
+      elsif (fragment = @command.stderr.check_exclude(result.err))
+        add_error("#{@command}: standard error includes #{fragment.inspect}")
+      end
+    end
+
+    def timeout?(time)
+      started_at + @command.timeout < time
+    end
+
+    def cooldown
+      @command.cooldown
+    end
+  end
+end

data/lib/confctl/health_checks/systemd/properties.rb

@@ -0,0 +1,84 @@
+require 'confctl/health_checks/base'
+
+module ConfCtl
+  class HealthChecks::Systemd::Properties < HealthChecks::Base
+    # @param machine [Machine]
+    # @param pattern [String, nil]
+    # @param property_checks [Array<HealthChecks::Systemd::PropertyCheck>]
+    def initialize(machine, property_checks:, pattern: nil)
+      super(machine)
+      @pattern = pattern
+      @property_checks = property_checks
+      @shortest_timeout = property_checks.inject(nil) do |acc, check|
+        if acc.nil? || check.timeout < acc
+          check.timeout
+        else
+          acc
+        end
+      end
+      @shortest_cooldown = property_checks.inject(nil) do |acc, check|
+        if acc.nil? || check.cooldown < acc
+          check.cooldown
+        else
+          acc
+        end
+      end
+    end
+
+    def description
+      ret = ''
+
+      if @pattern
+        ret << @pattern << ': '
+      else
+        ret << 'systemd: '
+      end
+
+      ret << @property_checks.map(&:to_s).join(', ')
+      ret
+    end
+
+    def message
+      if @pattern
+        "#{@pattern}: #{super}"
+      else
+        super
+      end
+    end
+
+    protected
+
+    def run_check
+      mc = MachineControl.new(machine)
+      cmd = %w[systemctl show]
+      cmd << @pattern if @pattern
+      result = mc.execute!(*cmd)
+
+      if result.failure?
+        add_error("#{cmd.join(' ')} failed with #{result.status}")
+        return
+      end
+
+      properties = HealthChecks::Systemd::PropertyList.from_enumerator(result.each)
+
+      @property_checks.each do |check|
+        v = properties[check.property]
+
+        if v.nil?
+          add_error("property #{check.property.inspect} not found")
+          next
+        end
+
+        add_error("#{check.property}=#{v}, expected #{check.value}") unless check.check(v)
+      end
+    end
+
+    def timeout?(time)
+      started_at + @shortest_timeout < time
+    end
+
+    def cooldown
+      @shortest_cooldown
+    end
+  end
+end

data/lib/confctl/health_checks/systemd/property_check.rb

@@ -0,0 +1,31 @@
+module ConfCtl
+  class HealthChecks::Systemd::PropertyCheck
+    # @return [String]
+    attr_reader :property
+
+    # @return [String]
+    attr_reader :value
+
+    # @return [Integer]
+    attr_reader :timeout
+
+    # @return [Integer]
+    attr_reader :cooldown
+
+    def initialize(opts)
+      @property = opts['property']
+      @value = opts['value']
+      @timeout = opts['timeout']
+      @cooldown = opts['cooldown']
+    end
+
+    # @return [Boolean]
+    def check(v)
+      @value == v
+    end
+
+    def to_s
+      "#{property}=#{value}"
+    end
+  end
+end

data/lib/confctl/health_checks/systemd/property_list.rb

@@ -0,0 +1,20 @@
+module ConfCtl
+  class HealthChecks::Systemd::PropertyList < Hash
+    def self.from_enumerator(it)
+      hash = new
+
+      it.each do |line|
+        stripped = line.strip
+        eq = line.index('=')
+        next if eq.nil?
+
+        k = line[0..(eq - 1)]
+        v = line[(eq + 1)..]
+
+        hash[k] = v
+      end
+
+      hash
+    end
+  end
+end

data/lib/confctl/health_checks.rb

@@ -0,0 +1,5 @@
+module ConfCtl
+  module HealthChecks
+    module Systemd; end
+  end
+end

data/lib/confctl/hook.rb

@@ -0,0 +1,35 @@
+module ConfCtl
+  module Hook
+    # @param name [Symbol]
+    def self.register(name)
+      @hooks ||= {}
+      @hooks[name] ||= []
+    end
+
+    # @param name [Symbol]
+    def self.subscribe(name, &block)
+      subscribers = (@hooks || {})[name]
+
+      raise "hook #{name.inspect} not registered" if subscribers.nil?
+
+      subscribers << block
+      nil
+    end
+
+    # @param name [Symbol]
+    # @param args [Array]
+    # @param kwargs [Hash]
+    # @return [any]
+    def self.call(name, args: [], kwargs: {})
+      return if @hooks.nil?
+
+      subscribers = @hooks[name]
+      return if subscribers.empty?
+
+      subscribers.inject(nil) do |ret, sub|
+        hook_kwargs = kwargs.merge(return_value: ret)
+        sub.call(*args, **hook_kwargs)
+      end
+    end
+  end
+end