confctl 1.0.0

data/lib/confctl/line_buffer.rb

@@ -0,0 +1,53 @@
+module ConfCtl
+  # Feed string data and get output as lines
+  class LineBuffer
+    # If instantiated with a block, the block is invoked for each read line
+    # @yieldparam line [String]
+    def initialize(&block)
+      @buffer = ''
+      @block = block
+    end
+
+    # Feed string
+    # @param str [String]
+    def <<(str)
+      buffer << str
+      return if block.nil?
+
+      loop do
+        out_line = read_line
+        break if out_line.nil?
+
+        block.call(out_line)
+      end
+    end
+
+    # Read one line if there is one
+    # @return [String, nil]
+    def read_line
+      nl = buffer.index("\n")
+      return if nl.nil?
+
+      line = buffer[0..nl]
+      @buffer = buffer[nl + 1..]
+      line
+    end
+
+    # Return the buffer's contents and flush it
+    #
+    # If block was given to {LineBuffer}, it will be invoked with the buffer
+    # contents.
+    #
+    # @return [String]
+    def flush
+      ret = buffer.clone
+      buffer.clear
+      block.call(ret) if block
+      ret
+    end
+
+    protected
+
+    attr_reader :buffer, :block
+  end
+end

data/lib/confctl/logger.rb

@@ -0,0 +1,151 @@
+require 'fileutils'
+require 'pathname'
+require 'pp'
+require 'singleton'
+
+module ConfCtl
+  class Logger
+    class << self
+      %i[
+        open
+        close
+        unlink
+        close_and_unlink
+        keep?
+        keep
+        io
+        path
+        relative_path
+      ].each do |v|
+        define_method(v) { |*args, **kwargs| instance.send(v, *args, **kwargs) }
+      end
+    end
+
+    include Singleton
+
+    def initialize
+      @mutex = Mutex.new
+      @readers = []
+      @keep = false
+    end
+
+    def open(name, output: nil)
+      if output
+        @io = output
+      else
+        dir = ConfDir.log_dir
+        FileUtils.mkdir_p(dir)
+
+        @io = File.new(File.join(dir, file_name(name)), 'w')
+      end
+    end
+
+    def open?
+      !@io.nil?
+    end
+
+    def close
+      raise 'log file not open' if @io.nil?
+
+      @io.close
+    end
+
+    def io
+      raise 'log file not open' if @io.nil?
+
+      @io
+    end
+
+    def path
+      raise 'log file not open' if @io.nil?
+
+      @io.path
+    end
+
+    def relative_path
+      return @relative_path if @relative_path
+
+      abs = Pathname.new(path)
+      dir = Pathname.new(ConfDir.path)
+      abs.relative_path_from(dir).to_s
+    end
+
+    def keep?
+      @keep
+    end
+
+    def keep
+      @keep = true
+    end
+
+    def unlink
+      raise 'log file not open' if @io.nil?
+
+      File.unlink(@io.path)
+    end
+
+    def close_and_unlink
+      close
+      unlink
+    end
+
+    def write(str)
+      sync do
+        @io << str
+        @io.flush
+      end
+
+      readers.each { |r| r << str }
+    end
+
+    def <<(str)
+      write(str)
+    end
+
+    def cli(cmd, gopts, opts, args)
+      sync do
+        PP.pp({
+          command: cmd,
+          global_options: prune_opts(gopts.clone),
+          command_options: prune_opts(opts.clone),
+          arguments: args
+        }, @io)
+      end
+    end
+
+    # @param obj [#<<]
+    def add_reader(obj)
+      @readers << obj
+    end
+
+    # @param obj [#<<]
+    def remove_reader(obj)
+      @readers.delete(obj)
+    end
+
+    protected
+
+    attr_reader :mutex, :readers
+
+    def sync(&)
+      if mutex.owned?
+        yield
+      else
+        mutex.synchronize(&)
+      end
+    end
+
+    def file_name(name)
+      n = [
+        Time.now.strftime('%Y-%m-%d--%H-%M-%S'),
+        'confctl',
+        name
+      ].compact.join('-')
+      "#{n}.log"
+    end
+
+    def prune_opts(hash)
+      hash.delete_if { |k, _v| k.is_a?(::Symbol) }
+    end
+  end
+end

data/lib/confctl/machine.rb

@@ -0,0 +1,107 @@
+module ConfCtl
+  class Machine
+    attr_reader :name, :safe_name, :managed, :spin, :opts
+
+    # @param opts [Hash]
+    def initialize(opts)
+      @opts = opts
+      @name = opts['name']
+      @safe_name = opts['name'].gsub('/', ':')
+      @managed = opts['managed']
+      @spin = opts['spin']
+    end
+
+    def target_host
+      (opts['host'] && opts['host']['target']) || name
+    end
+
+    def localhost?
+      target_host == 'localhost'
+    end
+
+    def nix_paths
+      opts['nix']['nixPath'].to_h do |v|
+        eq = v.index('=')
+        raise "'#{v}' is not a valid nix path entry " if eq.nil?
+
+        [v[0..eq - 1], v[eq + 1..]]
+      end
+    end
+
+    def health_checks
+      return @health_checks if @health_checks
+
+      @health_checks = []
+
+      opts['healthChecks'].each do |type, checks|
+        case type
+        when 'systemd'
+          next if !checks['enable'] || spin != 'nixos'
+
+          if checks['systemProperties'].any?
+            @health_checks << HealthChecks::Systemd::Properties.new(
+              self,
+              property_checks: checks['systemProperties'].map do |v|
+                HealthChecks::Systemd::PropertyCheck.new(v)
+              end
+            )
+          end
+
+          checks['unitProperties'].each do |unit_name, prop_checks|
+            health_checks << HealthChecks::Systemd::Properties.new(
+              self,
+              pattern: unit_name,
+              property_checks: prop_checks.map do |v|
+                HealthChecks::Systemd::PropertyCheck.new(v)
+              end
+            )
+          end
+
+        when 'builderCommands', 'machineCommands'
+          checks.each do |cmd|
+            health_checks << HealthChecks::RunCommand.new(
+              self,
+              HealthChecks::RunCommand::Command.new(self, cmd),
+              remote: type == 'machineCommands'
+            )
+          end
+
+        else
+          raise "Unsupported health-check type #{type.inspect}"
+        end
+      end
+
+      @health_checks
+    end
+
+    def [](key)
+      if key.index('.')
+        get(opts, key.split('.'))
+      elsif key == 'checks'
+        health_checks.length
+      else
+        opts[key]
+      end
+    end
+
+    def to_s
+      name
+    end
+
+    protected
+
+    def get(hash, keys)
+      k = keys.shift
+
+      return unless hash.has_key?(k)
+
+      if keys.empty?
+        hash[k]
+      elsif hash[k].nil?
+        nil
+      else
+        get(hash[k], keys)
+      end
+    end
+  end
+end

data/lib/confctl/machine_control.rb

@@ -0,0 +1,172 @@
+require 'etc'
+
+module ConfCtl
+  class MachineControl
+    # @return [Machine]
+    attr_reader :machine
+
+    # @param machine [Machine]
+    def initialize(machine)
+      @machine = machine
+      @extra_ssh_opts = []
+      @cmd = SystemCommand.new
+    end
+
+    # Try to open SSH connection
+    # @raise [TTY::Command::ExitError]
+    def test_connection
+      with_ssh_opts(
+        '-o', 'ConnectTimeout=3',
+        '-o', 'ServerAliveInterval=3',
+        '-o', 'ServerAliveCountMax=1'
+      ) { uptime }
+    end
+
+    def interactive_shell
+      if machine.localhost?
+        Kernel.system(Etc.getpwuid(0).shell)
+      else
+        Kernel.system(*ssh_args)
+      end
+    end
+
+    # Reboot the machine
+    def reboot
+      execute!('reboot')
+    end
+
+    # Reboot the machine and wait for it to come back online
+    # @param timeout [Integer, nil]
+    # @yieldparam [:reboot, :went_down, :is_down, :is_up, :timeout] state
+    # @return [Integer] seconds it took to reboot the machine
+    def reboot_and_wait(timeout: nil)
+      initial_uptime = uptime
+      t = Time.now
+      went_down = false
+      reboot
+      yield :reboot, timeout if block_given?
+
+      loop do
+        state = nil
+
+        begin
+          current_uptime = with_ssh_opts(
+            '-o', 'ConnectTimeout=3',
+            '-o', 'ServerAliveInterval=3',
+            '-o', 'ServerAliveCountMax=1'
+          ) { uptime }
+
+          if current_uptime < initial_uptime
+            yield :is_up, nil
+            return Time.now - t
+          end
+        rescue TTY::Command::ExitError
+          if went_down
+            state = :is_down
+          else
+            state = :went_down
+            went_down = true
+          end
+        end
+
+        if timeout
+          timeleft = (t + timeout) - Time.now
+
+          raise 'timeout' if timeleft <= 0
+
+          yield state, timeleft if block_given?
+        elsif block_given?
+          yield state, nil
+        end
+
+        sleep(0.3)
+      end
+    end
+
+    # @return [Integer] uptime in seconds
+    def uptime
+      read_file('/proc/uptime').strip.split[0].to_f
+    end
+
+    # @return [Array<String>]
+    def timezone
+      out, = run_cmd('date', '+%Z;%z')
+      out.strip.split(';')
+    end
+
+    # @param path [String]
+    # @return [String]
+    def read_file(path)
+      out, = run_cmd('cat', path)
+      out
+    end
+
+    # @param path [String]
+    # @return [String]
+    def read_symlink(path)
+      out, = run_cmd('readlink', path)
+      out.strip
+    end
+
+    # Execute command, raises exception on error
+    # @yieldparam out [String]
+    # @yieldparam err [String]
+    # @raise [TTY::Command::ExitError]
+    # @return [TTY::Command::Result]
+    def execute(...)
+      run_cmd(...)
+    end
+
+    # Execute command, no exception raised on error
+    # @yieldparam out [String]
+    # @yieldparam err [String]
+    # @return [TTY::Command::Result]
+    def execute!(...)
+      run_cmd!(...)
+    end
+
+    # @param script [String]
+    # @return [TTY::Command::Result]
+    def bash_script(script)
+      run_cmd('bash', '--norc', input: script)
+    end
+
+    protected
+
+    attr_reader :cmd, :extra_ssh_opts
+
+    def run_cmd(...)
+      do_run_cmd(:run, ...)
+    end
+
+    def run_cmd!(...)
+      do_run_cmd(:run!, ...)
+    end
+
+    # rubocop:disable Style/ArgumentsForwarding
+
+    def do_run_cmd(method, *command, **kwargs, &)
+      args =
+        if machine.localhost?
+          command
+        else
+          ssh_args + command
+        end
+
+      cmd.method(method).call(*args, **kwargs, &)
+    end
+
+    # rubocop:enable Style/ArgumentsForwarding
+
+    def with_ssh_opts(*opts)
+      @extra_ssh_opts = opts
+      ret = yield
+      @extra_ssh_opts = []
+      ret
+    end
+
+    def ssh_args
+      ['ssh', '-l', 'root'] + extra_ssh_opts + [machine.target_host]
+    end
+  end
+end

data/lib/confctl/machine_list.rb

@@ -0,0 +1,108 @@
+require 'json'
+
+module ConfCtl
+  class MachineList
+    # @param machine [Machine]
+    # @return [MachineList]
+    def self.from_machine(machine)
+      new(machines: { machine.name => machine })
+    end
+
+    # @param opts [Hash]
+    # @option opts [Boolean] :show_trace
+    # @option opts [MachineList] :machines
+    def initialize(opts = {})
+      @opts = opts
+      @machines = opts[:machines] || parse(extract)
+    end
+
+    # @yieldparam [String] host
+    # @yieldparam [Machine] machine
+    def each(&)
+      machines.each(&)
+    end
+
+    # @yieldparam [String] host
+    def each_key(&)
+      machines.each_key(&)
+    end
+
+    # @yieldparam [Machine] machine
+    def each_value(&)
+      machines.each_value(&)
+    end
+
+    # @yieldparam [String] host
+    # @yieldparam [Machine] machine
+    # @return [MachineList]
+    def select(&)
+      self.class.new(machines: machines.select(&))
+    end
+
+    # @yieldparam [String] host
+    # @yieldparam [Machine] machine
+    # @return [Array]
+    def map(&)
+      machines.map(&)
+    end
+
+    # @return [MachineList]
+    def managed
+      select { |_host, machine| machine.managed }
+    end
+
+    # @return [MachineList]
+    def unmanaged
+      select { |_host, machine| !machine.managed }
+    end
+
+    # @param host [String]
+    def [](host)
+      @machines[host]
+    end
+
+    # @return [Machine, nil]
+    def first
+      @machines.each_value.first
+    end
+
+    # @return [Integer]
+    def length
+      @machines.length
+    end
+
+    def empty?
+      @machines.empty?
+    end
+
+    def any?
+      !empty?
+    end
+
+    # @return [Array<HealthChecks::Base>]
+    def health_checks
+      checks = []
+
+      machines.each_value do |machine|
+        checks.concat(machine.health_checks)
+      end
+
+      checks
+    end
+
+    protected
+
+    attr_reader :opts, :machines
+
+    def extract
+      nix = Nix.new
+      nix.list_machines
+    end
+
+    def parse(data)
+      data.transform_values do |info|
+        Machine.new(info)
+      end
+    end
+  end
+end

data/lib/confctl/machine_status.rb

@@ -0,0 +1,135 @@
+require 'tty-command'
+
+module ConfCtl
+  class MachineStatus
+    class SwpinState
+      # @return [Swpins::Specs::Base]
+      attr_reader :target_spec
+
+      # @return [Hash, nil]
+      attr_reader :current_info
+
+      # @param target_spec [Swpins::Specs::Base]
+      # @param current_info [Hash, nil]
+      def initialize(target_spec, current_info)
+        @target_spec = target_spec
+        @current_info = current_info
+        @uptodate =
+          if current_info
+            target_spec.check_info(current_info)
+          else
+            false
+          end
+      end
+
+      def uptodate?
+        @uptodate
+      end
+
+      def outdated?
+        !uptodate?
+      end
+
+      # @return [String, nil]
+      def target_version
+        target_spec.version
+      end
+
+      # @return [String, nil]
+      def current_version
+        target_spec.version_info(current_info) || 'unknown'
+      end
+    end
+
+    # @return [Machine]
+    attr_reader :machine
+
+    # @return [Boolean]
+    attr_reader :status
+
+    # @return [Boolean]
+    attr_reader :online
+    alias online? online
+
+    # @return [Float]
+    attr_reader :uptime
+
+    # @return [String]
+    attr_accessor :target_toplevel
+
+    # @return [String]
+    attr_reader :current_toplevel
+
+    # @return [String]
+    attr_reader :timezone_name
+
+    # @return [String]
+    attr_reader :timezone_offset
+
+    # @return [Generation::HostList]
+    attr_reader :generations
+
+    # @return [Hash]
+    attr_accessor :target_swpin_specs
+
+    # @return [Hash]
+    attr_reader :swpins_info
+
+    # @return [Hash]
+    attr_reader :swpins_state
+
+    # @param machine [Machine]
+    def initialize(machine)
+      @machine = machine
+      @mc = MachineControl.new(machine)
+    end
+
+    # Connect to the machine and query its state
+    def query(toplevel: true, generations: true)
+      begin
+        @uptime = mc.uptime
+      rescue TTY::Command::ExitError
+        return
+      end
+
+      if toplevel
+        begin
+          @current_toplevel = mc.read_symlink('/run/current-system')
+        rescue TTY::Command::ExitError
+          return
+        end
+      end
+
+      if generations
+        begin
+          @generations = Generation::HostList.fetch(mc)
+        rescue TTY::Command::ExitError
+          return
+        end
+      end
+
+      begin
+        @swpins_info = Swpins::DeployedInfo.parse!(mc.read_file('/etc/confctl/swpins-info.json'))
+      rescue Error
+        nil
+      end
+    end
+
+    def evaluate
+      @swpins_state = {}
+
+      target_swpin_specs.each do |name, spec|
+        swpins_state[name] = SwpinState.new(spec, swpins_info && swpins_info[name])
+      end
+
+      outdated_swpins = swpins_state.detect { |_k, v| v.outdated? }
+      @online = uptime ? true : false
+      @status = online? && !outdated_swpins
+      @status = false if target_toplevel && target_toplevel != current_toplevel
+    end
+
+    protected
+
+    attr_reader :mc
+  end
+end