confctl 1.0.0

data/lib/confctl/cli/generation.rb

@@ -0,0 +1,335 @@
+require 'time'
+
+module ConfCtl::Cli
+  class Generation < Command
+    def list
+      machines = select_machines(args[0])
+      gens = select_generations(machines, args[1])
+      list_generations(gens)
+    end
+
+    def remove
+      machines = select_machines(args[0])
+      gens = select_generations(machines, args[1])
+
+      if gens.empty?
+        puts 'No generations found'
+        return
+      end
+
+      ask_confirmation! do
+        puts 'The following generations will be removed:'
+        list_generations(gens)
+        puts
+        puts "Garbage collection: #{opts[:remote] && opts[:gc] ? 'yes' : 'no'}"
+      end
+
+      gens.each do |gen|
+        puts "Removing #{gen.presence_str} generation #{gen.host}@#{gen.name}"
+        gen.destroy
+      end
+
+      return unless opts[:remote] && opts[:gc]
+
+      machines_gc = machines.select do |host, _machine|
+        gens.detect { |gen| gen.host == host }
+      end
+
+      run_gc(machines_gc)
+    end
+
+    def rotate
+      machines = select_machines(args[0])
+
+      to_delete = []
+
+      to_delete.concat(host_generations_rotate(machines)) if opts[:remote]
+
+      to_delete.concat(build_generations_rotate(machines)) if opts[:local] || (!opts[:local] && !opts[:remote])
+
+      if to_delete.empty?
+        puts 'No generations to delete'
+        return
+      end
+
+      ask_confirmation! do
+        puts 'The following generations will be removed:'
+        OutputFormatter.print(to_delete, %i[host name type id], layout: :columns)
+        puts
+        puts "Garbage collection: #{opts[:remote] ? 'when enabled in configuration' : 'no'}"
+      end
+
+      to_delete.each do |gen|
+        puts "Removing #{gen[:type]} generation #{gen[:host]}@#{gen[:name]}"
+        gen[:generation].destroy
+      end
+
+      return unless opts[:remote]
+
+      global = ConfCtl::Settings.instance.host_generations
+
+      machines_gc = machines.select do |_host, machine|
+        gc = machine['buildGenerations']['collectGarbage']
+
+        if gc.nil?
+          global['collectGarbage']
+        else
+          gc
+        end
+      end
+
+      run_gc(machines_gc) if machines_gc.any?
+    end
+
+    def collect_garbage
+      machines = select_machines(args[0])
+
+      raise 'No machines to collect garbage on' if machines.empty?
+
+      ask_confirmation! do
+        puts 'Collect garbage on the following machines:'
+        list_machines(machines)
+      end
+
+      run_gc(machines)
+    end
+
+    protected
+
+    def select_generations(machines, pattern)
+      gens = ConfCtl::Generation::UnifiedList.new
+      include_remote = opts[:remote]
+      include_local = opts[:local] || (!opts[:remote] && !opts[:local])
+
+      if include_remote
+        tw = ConfCtl::ParallelExecutor.new(machines.length)
+        statuses = {}
+
+        machines.each do |host, machine|
+          st = ConfCtl::MachineStatus.new(machine)
+          statuses[host] = st
+
+          tw.add do
+            st.query(toplevel: false)
+          end
+        end
+
+        tw.run
+
+        statuses.each_value do |st|
+          gens.add_host_generations(st.generations) if st.generations
+        end
+      end
+
+      if include_local
+        machines.each_key do |host|
+          gens.add_build_generations(ConfCtl::Generation::BuildList.new(host))
+        end
+      end
+
+      select_old = pattern == 'old'
+      select_older_than =
+        (Time.now - (::Regexp.last_match(1).to_i * 24 * 60 * 60) if !select_old && /\A(\d+)d\Z/ =~ pattern)
+
+      if pattern
+        gens.delete_if do |gen|
+          if select_old
+            gen.current
+          elsif select_older_than
+            gen.date >= select_older_than
+          else
+            !ConfCtl::Pattern.match?(pattern, gen.name)
+          end
+        end
+      end
+
+      gens
+    end
+
+    def build_generations_rotate(machines)
+      global = ConfCtl::Settings.instance.build_generations
+      ret = []
+
+      machines.each do |host, machine|
+        to_delete = generations_rotate(
+          ConfCtl::Generation::BuildList.new(host),
+          min: machine['buildGenerations']['min'] || global['min'],
+          max: machine['buildGenerations']['max'] || global['max'],
+          max_age: machine['buildGenerations']['maxAge'] || global['maxAge']
+        ) do |gen|
+          {
+            name: gen.name,
+            type: 'build'
+          }
+        end
+
+        ret.concat(to_delete)
+      end
+
+      ret
+    end
+
+    def host_generations_rotate(machines)
+      global = ConfCtl::Settings.instance.host_generations
+      ret = []
+
+      tw = ConfCtl::ParallelExecutor.new(machines.length)
+      statuses = {}
+
+      machines.each do |host, machine|
+        st = ConfCtl::MachineStatus.new(machine)
+        statuses[host] = st
+
+        tw.add do
+          st.query(toplevel: false)
+        end
+      end
+
+      tw.run
+
+      statuses.each_value do |st|
+        next unless st.generations
+
+        machine = st.machine
+
+        to_delete = generations_rotate(
+          st.generations,
+          min: machine['hostGenerations']['min'] || global['min'],
+          max: machine['hostGenerations']['max'] || global['max'],
+          max_age: machine['hostGenerations']['maxAge'] || global['maxAge']
+        ) do |gen|
+          {
+            type: 'host',
+            name: gen.approx_name,
+            id: gen.id
+          }
+        end
+
+        ret.concat(to_delete)
+      end
+
+      ret
+    end
+
+    def generations_rotate(gens, min: nil, max: nil, max_age: nil)
+      ret = []
+
+      return ret if gens.count <= min
+
+      machine_deleted = 0
+
+      gens.each do |gen|
+        next if gen.current
+
+        if (gens.count - machine_deleted) > max || (gen.date + max_age) < Time.now
+          ret << {
+            host: gen.host,
+            generation: gen
+          }.merge(yield(gen))
+          machine_deleted += 1
+        end
+
+        break if gens.count - machine_deleted <= min
+      end
+
+      ret
+    end
+
+    def run_gc(machines)
+      nix = ConfCtl::Nix.new
+
+      header =
+        if machines.length > 1
+          Rainbow("Collecting garbage on #{machines.length} machines").bright
+        else
+          Rainbow('Collecting garbage on ').bright + Rainbow(machines.first.to_s).yellow
+        end
+
+      LogView.open(
+        header: "#{header}\n",
+        title: Rainbow('Live view').bright,
+        size: :auto,
+        reserved_lines: machines.length + 8
+      ) do |lw|
+        multibar = TTY::ProgressBar::Multi.new(
+          'Collecting garbage [:bar] :current',
+          width: 80
+        )
+        executor = ConfCtl::ParallelExecutor.new(opts['max-concurrent-gc'])
+
+        machines.each do |host, machine|
+          pb = multibar.register(
+            "#{host} [:bar] :current"
+          )
+
+          executor.add do
+            end_stats = nil
+
+            ret = nix.collect_garbage(machine) do |progress|
+              lw << "#{host}> #{progress}"
+
+              if progress.path?
+                lw.sync_console do
+                  pb.advance
+                end
+
+              elsif /^\d+ store paths deleted/ =~ progress.line
+                end_stats = progress.line
+              end
+            end
+
+            lw.sync_console do
+              pb.format = if ret
+                            "#{host}: #{end_stats || 'done'}"
+                          else
+                            "#{host}: error occurred"
+                          end
+
+              pb.finish
+            end
+
+            ret ? nil : host
+          end
+        end
+
+        retvals = executor.run
+        failed = retvals.compact
+
+        raise "Gargabe collection failed on: #{failed.join(', ')}" if failed.any?
+      end
+    end
+
+    def list_generations(gens)
+      swpin_names = []
+
+      gens.each do |gen|
+        gen.swpin_names.each do |name|
+          swpin_names << name unless swpin_names.include?(name)
+        end
+      end
+
+      rows = gens.map do |gen|
+        row = {
+          'host' => gen.host,
+          'name' => gen.name,
+          'id' => gen.id,
+          'presence' => gen.presence_str,
+          'current' => gen.current_str
+        }
+
+        gen.swpin_specs.each do |name, spec|
+          row[name] = spec.version
+        end
+
+        row
+      end
+
+      OutputFormatter.print(
+        rows,
+        %w[host name id presence current] + swpin_names,
+        layout: :columns,
+        sort: %w[name host]
+      )
+    end
+  end
+end

data/lib/confctl/cli/log_view.rb

@@ -0,0 +1,267 @@
+require 'io/console'
+require 'rainbow'
+require 'tty-cursor'
+
+module ConfCtl::Cli
+  # Create a fixed-size box showing the last `n` lines from streamed data
+  class LogView
+    # All writes to the console must go through this lock
+    CONSOLE_LOCK = Monitor.new
+
+    def self.sync_console(&)
+      CONSOLE_LOCK.synchronize(&)
+    end
+
+    # Instantiate {LogView}, yield and then cleanup
+    # @yieldparam log_view [LogView]
+    def self.open(**kwargs)
+      lw = new(**kwargs)
+      lw.start
+
+      begin
+        yield(lw)
+      ensure
+        lw.stop
+      end
+    end
+
+    # Instantiate {LogView} with feed from {ConfCtl::Logger}, yield
+    # and then cleanup
+    # @yieldparam log_view [LogView]
+    def self.open_with_logger(**kwargs)
+      lw = new(**kwargs)
+      lw.start
+
+      lb = ConfCtl::LineBuffer.new { |line| lw << line }
+      ConfCtl::Logger.instance.add_reader(lb)
+
+      begin
+        yield(lw)
+      ensure
+        ConfCtl::Logger.instance.remove_reader(lb)
+        lw.stop
+      end
+    end
+
+    # @param header [String]
+    #   optional string outputted above the box, must have new lines
+    # @param title [String]
+    #   optional box title
+    # @param size [Integer, :auto]
+    #   number of lines to show
+    # @param reserved_lines [Integer]
+    #   number of reserved lines below the box when `size` is `:auto`
+    # @param output [IO]
+    def initialize(header: nil, title: nil, size: 10, reserved_lines: 0, output: $stdout)
+      @cursor = TTY::Cursor
+      @outmutex = Mutex.new
+      @inlines = Queue.new
+      @outlines = []
+      @header = header
+      @title = title || 'Log'
+      @size = size
+      @current_size = size if size != :auto
+      @reserved_lines = reserved_lines
+      @output = output
+      @enabled = output.respond_to?(:tty?) && output.tty?
+      @resized = false
+      @stop = false
+      @generation = 0
+      @rendered = 0
+    end
+
+    def start
+      return unless enabled?
+
+      @stop = false
+      fetch_size
+      init
+      render_inplace(outlines)
+      @feeder = Thread.new { feeder_loop }
+      @renderer = Thread.new { renderer_loop }
+
+      Signal.trap('WINCH') do
+        fetch_size
+        @resized = true
+      end
+    end
+
+    def stop
+      return if @stop || !enabled?
+
+      @stop = true
+      inlines.clear
+      inlines << :stop
+      feeder.join
+      renderer.join
+      Signal.trap('WINCH', 'DEFAULT')
+    end
+
+    def flush
+      sleep(1)
+    end
+
+    def <<(line)
+      inlines << line.strip
+    end
+
+    def sync_console(&)
+      self.class.sync_console(&)
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    protected
+
+    attr_reader :output, :cursor, :outmutex, :inlines, :outlines, :size,
+                :current_size, :reserved_lines, :feeder, :renderer, :rows, :cols, :header, :title,
+                :generation, :rendered
+
+    def feeder_loop
+      loop do
+        line = inlines.pop
+        break if stop?
+
+        sync_outlines do
+          # TABs have variable width, there's no way to correctly determine
+          # their size, so we replace them with spaces.
+          outlines << line.gsub("\t", '  ')
+          outlines.shift while outlines.length > current_size
+          @generation += 1
+        end
+      end
+    end
+
+    def renderer_loop
+      loop do
+        return if stop?
+
+        lines = nil
+        do_render = true
+
+        sync_outlines do
+          if generation == rendered && !resized?
+            do_render = false
+            next
+          end
+
+          lines = outlines.clone
+          @rendered = generation
+        end
+
+        if do_render
+          sync_console do
+            if resized?
+              output.print(cursor.clear_screen)
+              @resized = false
+            end
+
+            render_scoped(lines)
+          end
+        end
+
+        return if stop?
+
+        sleep(0.1)
+      end
+    end
+
+    def init
+      sync_console do
+        rows.times { output.puts }
+        output.print(cursor.clear_screen)
+        output.print(cursor.move_to)
+      end
+    end
+
+    def render_scoped(lines)
+      sync_console do
+        output.print(cursor.save)
+        output.print(cursor.move_to)
+        render_inplace(lines)
+        output.print(cursor.restore)
+      end
+    end
+
+    def render_inplace(lines)
+      sync_console do
+        if header
+          header.each_line do |line|
+            output.print(cursor.clear_line)
+            output.print(line)
+          end
+        end
+
+        output.print(cursor.clear_line)
+        output.puts(title_bar(title))
+
+        current_size.times do |i|
+          output.print(cursor.clear_line)
+
+          if lines[i].nil?
+            output.puts
+            next
+          end
+
+          output.puts(fit_line(lines[i]))
+        end
+
+        output.print(cursor.clear_line)
+        output.puts("<#{'-' * (cols - 1)}")
+        output.puts
+      end
+    end
+
+    def title_bar(s)
+      uncolored = Rainbow::StringUtils.uncolor(s)
+
+      ret = ''
+      ret << s
+      ret << ' '
+      ret << ('-' * (cols - uncolored.length - 2))
+      ret << '>'
+      ret
+    end
+
+    def fit_line(line)
+      if line.length >= (cols - 4)
+        "#{line[0..(cols - 4)]}..."
+      else
+        line
+      end
+    end
+
+    def fetch_size
+      @rows, @cols = IO.console.winsize
+
+      return unless size == :auto
+
+      new_size = rows
+      new_size -= header.lines.count if header
+      new_size -= reserved_lines
+      @current_size = [new_size, 10].max
+    end
+
+    def sync_outlines(&)
+      sync_mutex(outmutex, &)
+    end
+
+    def sync_mutex(mutex, &block)
+      if mutex.owned?
+        block.call
+      else
+        mutex.synchronize(&block)
+      end
+    end
+
+    def resized?
+      @resized
+    end
+
+    def stop?
+      @stop
+    end
+  end
+end