confctl 1.0.0

data/lib/confctl/cli/output_formatter.rb

@@ -0,0 +1,288 @@
+require 'rainbow'
+
+module ConfCtl::Cli
+  class OutputFormatter
+    def self.to_s(*args)
+      f = new(*args)
+      f.to_s
+    end
+
+    def self.print(*args, **kwargs)
+      f = new(*args, **kwargs)
+      f.print
+    end
+
+    def initialize(objects, cols = nil, header: true, sort: nil, layout: nil, empty: '-', color: false)
+      @objects = objects
+      @header = header
+      @sort = sort
+      @layout = layout
+      @empty = empty
+      @color = color
+
+      if @layout.nil?
+        @layout = if many?
+                    :columns
+
+                  else
+                    :rows
+                  end
+      end
+
+      if cols
+        @cols = parse_cols(cols)
+
+      elsif @objects.is_a?(::Array)
+        if @objects.count == 0
+          @cols = []
+        else
+          @cols ||= parse_cols(@objects.first.keys)
+        end
+
+      elsif @objects.is_a?(::Hash) # Single item
+        @cols ||= parse_cols(@objects.keys)
+
+      else
+        raise "unsupported type #{@objects.class}"
+      end
+    end
+
+    def to_s
+      @out = ''
+      generate
+      @out
+    end
+
+    def print
+      @out = nil
+      generate
+    end
+
+    protected
+
+    def parse_cols(cols)
+      ret = []
+
+      cols.each do |c|
+        base = {
+            align: 'left'
+        }
+
+        if c.is_a?(::String) || c.is_a?(::Symbol)
+          base.update({
+              name: c,
+              label: c.to_s.upcase
+          })
+          ret << base
+
+        elsif c.is_a?(::Hash)
+          base.update(c)
+          ret << base
+
+        else
+          raise "unsupported column type #{c.class}"
+        end
+      end
+
+      ret
+    end
+
+    def generate
+      return if @cols.empty?
+
+      prepare
+
+      case @layout
+      when :columns
+        columns
+
+      when :rows
+        rows
+
+      else
+        raise "unsupported layout '#{@layout}'"
+      end
+    end
+
+    # Each object is printed on one line, it's parameters aligned into columns.
+    def columns
+      # Calculate column widths
+      @cols.each_with_index do |c, i|
+        c[:width] = col_width(i, c)
+      end
+
+      # Print header
+      if @header
+        line(@cols.map.with_index do |c, i|
+          fmt =
+            if i == (@cols.count - 1)
+              '%s'
+            elsif c[:align].to_sym == :right
+              "%#{c[:width]}s"
+            else
+              "%-#{c[:width]}s"
+            end
+
+          format(fmt, c[:label])
+        end.join('  '))
+      end
+
+      # Print data
+      @str_objects.each do |o|
+        line(@cols.map.with_index do |c, i|
+          s = o[i].to_s
+
+          if @color
+            # If there are colors in the string, they affect the string size
+            # and thus sprintf formatting. sprintf is working with characters
+            # that the terminal will consume and not display (escape sequences).
+            # The format string needs to be changed to accomodate for those
+            # unprintable characters.
+            s_nocolor = Rainbow::StringUtils.uncolor(s)
+
+            w = if s_nocolor.length == s.length
+                  c[:width]
+
+                else
+                  c[:width] + (s.length - s_nocolor.length)
+                end
+          else
+            w = c[:width]
+          end
+
+          fmt =
+            if i == (@cols.count - 1)
+              '%s'
+            elsif c[:align].to_sym == :right
+              "%#{w}s"
+            else
+              "%-#{w}s"
+            end
+
+          format(fmt, s)
+        end.join('  '))
+      end
+    end
+
+    # Each object is printed on multiple lines, one parameter per line.
+    def rows
+      w = heading_width if @header
+
+      @str_objects.each do |o|
+        @cols.each_index do |i|
+          c = @cols[i]
+
+          unless @header
+            line o[i]
+            next
+          end
+
+          if o[i].is_a?(::String) && o[i].index("\n")
+            lines = o[i].split("\n")
+            v = ([lines.first] + lines[1..].map { |l| (' ' * (w + 3)) + l }).join("\n")
+
+          else
+            v = o[i]
+          end
+
+          # rubocop:disable Lint/FormatParameterMismatch
+          line format("%#{w}s:  %s", c[:label], v)
+          # rubocop:enable Lint/FormatParameterMismatch
+        end
+
+        line
+      end
+    end
+
+    def line(str = '')
+      if @out
+        @out += "#{str}\n"
+
+      else
+        puts str
+      end
+    end
+
+    def prepare
+      @str_objects = []
+
+      each_object do |o|
+        arr = []
+
+        @cols.each do |c|
+          v = o[c[:name]]
+          str = (c[:display] ? c[:display].call(v, o) : v)
+          str = @empty if !str || (str.is_a?(::String) && str.empty?)
+
+          arr << str
+        end
+
+        @str_objects << arr
+      end
+
+      if @sort
+        col_indexes = @sort.map do |s|
+          i = @cols.index { |c| c[:name] == s }
+          raise "unknown sort column '#{s}'" unless i
+
+          i
+        end
+
+        @str_objects.sort! do |a, b|
+          a_vals = col_indexes.map { |i| a[i] }
+          b_vals = col_indexes.map { |i| b[i] }
+          cmp = a_vals <=> b_vals
+          next(cmp) if cmp
+
+          next(-1) if [nil, @empty].detect { |v| a_vals.include?(v) }
+          next(1) if [nil, @empty].detect { |v| b_vals.include?(v) }
+
+          0
+        end
+      end
+
+      @str_objects
+    end
+
+    def col_width(i, c)
+      w = c[:label].to_s.length
+
+      @str_objects.each do |o|
+        len = if @color
+                Rainbow::StringUtils.uncolor(o[i].to_s).length
+              else
+                o[i].to_s.length
+              end
+
+        w = len if len > w
+      end
+
+      w + 1
+    end
+
+    def heading_width
+      w = @cols.first[:label].to_s.length
+
+      @cols.each do |c|
+        len = c[:label].to_s.length
+
+        w = len if len > w
+      end
+
+      w + 1
+    end
+
+    def each_object(&)
+      if @objects.is_a?(::Array)
+        @objects.each(&)
+
+      else
+        yield(@objects)
+      end
+    end
+
+    def many?
+      @objects.is_a?(::Array) && @objects.size > 1
+    end
+  end
+end

data/lib/confctl/cli/swpins/base.rb

@@ -0,0 +1,40 @@
+require 'confctl/cli/command'
+require 'confctl/cli/swpins/utils'
+
+module ConfCtl::Cli
+  class Swpins::Base < Command
+    include Swpins::Utils
+
+    def update
+      run_command(Swpins::Core, :update)
+      run_command(Swpins::Channel, :update)
+      run_command(Swpins::Cluster, :update)
+    end
+
+    def reconfigure
+      each_channel('*') do |chan|
+        if chan.valid?
+          puts "Reconfiguring channel #{chan.name}"
+          chan.save
+        else
+          puts "Channel #{chan.name} needs update"
+          chan.specs.each do |name, s|
+            puts "  update #{name}" unless s.valid?
+          end
+        end
+      end
+
+      each_cluster_name('*') do |cn|
+        if cn.valid?
+          puts "Reconfiguring machine #{cn.name}"
+          cn.save
+        else
+          puts "Machine #{cn.name} needs update"
+          cn.specs.each do |name, s|
+            puts "  update #{name}" unless s.valid?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/confctl/cli/swpins/channel.rb

@@ -0,0 +1,73 @@
+require 'confctl/cli/command'
+require 'confctl/cli/swpins/utils'
+
+module ConfCtl::Cli
+  class Swpins::Channel < Command
+    include Swpins::Utils
+
+    def list
+      rows = []
+
+      each_channel_spec(args[0] || '*', args[1] || '*') do |chan, spec|
+        rows << {
+          channel: chan.name,
+          sw: spec.name,
+          type: spec.type,
+          pin: spec.status
+        }
+      end
+
+      OutputFormatter.print(
+        rows,
+        %i[channel sw type pin],
+        layout: :columns
+      )
+    end
+
+    def set
+      require_args!('channel-pattern', 'sw-pattern', 'version...', strict: false)
+      channels = []
+      change_set = ConfCtl::Swpins::ChangeSet.new
+
+      each_channel_spec(args[0], args[1]) do |chan, spec|
+        change_set.add(chan, spec)
+        spec_set_msg(chan, spec) { spec.prefetch_set(args[2..]) }
+        channels << chan unless channels.include?(chan)
+      end
+
+      channels.each(&:save)
+
+      return unless opts[:commit]
+
+      change_set.commit(
+        type: opts[:downgrade] ? :downgrade : :upgrade,
+        changelog: opts[:changelog]
+      )
+    end
+
+    def update
+      require_args!(optional: %w[channel-pattern sw-pattern])
+      channels = []
+      change_set = ConfCtl::Swpins::ChangeSet.new
+
+      each_channel_spec(args[0] || '*', args[1] || '*') do |chan, spec|
+        if spec.can_update?
+          change_set.add(chan, spec)
+          spec_update_msg(chan, spec) { spec.prefetch_update }
+          channels << chan unless channels.include?(chan)
+        else
+          puts "#{spec.name} not configured for update"
+        end
+      end
+
+      channels.each(&:save)
+
+      return unless opts[:commit]
+
+      change_set.commit(
+        type: opts[:downgrade] ? :downgrade : :upgrade,
+        changelog: opts[:changelog]
+      )
+    end
+  end
+end

data/lib/confctl/cli/swpins/cluster.rb

@@ -0,0 +1,80 @@
+require 'confctl/cli/command'
+require 'confctl/cli/swpins/utils'
+
+module ConfCtl::Cli
+  class Swpins::Cluster < Command
+    include Swpins::Utils
+
+    def list
+      rows = []
+
+      each_cluster_name_spec(args[0] || '*', args[1] || '*') do |cn, spec|
+        rows << {
+          cluster_name: cn.name,
+          sw: spec.name,
+          channel: spec.channel,
+          type: spec.type,
+          pin: spec.status
+        }
+      end
+
+      OutputFormatter.print(
+        rows,
+        %i[cluster_name sw channel type pin],
+        layout: :columns
+      )
+    end
+
+    def set
+      require_args!('cluster-name', 'sw', 'version...', strict: false)
+      cluster_names = []
+      change_set = ConfCtl::Swpins::ChangeSet.new
+
+      each_cluster_name_spec(args[0], args[1]) do |cluster_name, spec|
+        if spec.from_channel?
+          puts "Skipping #{spec.name} as it comes from channel #{spec.channel}"
+        else
+          change_set.add(cluster_name, spec)
+          spec_set_msg(cluster_name, spec) { spec.prefetch_set(args[2..]) }
+          cluster_names << cluster_name unless cluster_names.include?(cluster_name)
+        end
+      end
+
+      cluster_names.each(&:save)
+
+      return unless opts[:commit]
+
+      change_set.commit(
+        type: opts[:downgrade] ? :downgrade : :upgrade,
+        changelog: opts[:changelog]
+      )
+    end
+
+    def update
+      require_args!(optional: %w[cluster-name sw])
+      cluster_names = []
+      change_set = ConfCtl::Swpins::ChangeSet.new
+
+      each_cluster_name_spec(args[0] || '*', args[1] || '*') do |cluster_name, spec|
+        if spec.from_channel?
+          puts "Skipping #{spec.name} as it comes from channel #{spec.channel}"
+        elsif spec.can_update?
+          change_set.add(cluster_name, spec)
+          spec_update_msg(cluster_name, spec) { spec.prefetch_update }
+          cluster_names << cluster_name unless cluster_names.include?(cluster_name)
+        else
+          puts "#{spec.name} not configured for update"
+        end
+      end
+
+      cluster_names.each(&:save)
+
+      return unless opts[:commit]
+
+      change_set.commit(
+        type: opts[:downgrade] ? :downgrade : :upgrade,
+        changelog: opts[:changelog]
+      )
+    end
+  end
+end

data/lib/confctl/cli/swpins/core.rb

@@ -0,0 +1,86 @@
+require 'confctl/cli/command'
+require 'confctl/cli/swpins/utils'
+
+module ConfCtl::Cli
+  class Swpins::Core < Command
+    include Swpins::Utils
+
+    def list
+      core = ConfCtl::Swpins::Core.get
+
+      rows = []
+
+      core.specs.each do |name, spec|
+        next if args[0] && !ConfCtl::Pattern.match(args[0], name)
+
+        rows << {
+          sw: spec.name,
+          channel: spec.channel,
+          type: spec.type,
+          pin: spec.status
+        }
+      end
+
+      OutputFormatter.print(
+        rows,
+        %i[sw channel type pin],
+        layout: :columns
+      )
+    end
+
+    def set
+      require_args!('sw', 'version...', strict: false)
+
+      core = ConfCtl::Swpins::Core.get
+      change_set = ConfCtl::Swpins::ChangeSet.new
+
+      core.specs.each_value do |spec|
+        if spec.from_channel?
+          puts "Skipping #{spec.name} as it comes from channel #{spec.channel}"
+        else
+          change_set.add(core, spec)
+          spec_set_msg(core, spec) { spec.prefetch_set(args[1..]) }
+        end
+      end
+
+      core.save
+      core.pre_evaluate
+
+      return unless opts[:commit]
+
+      change_set.commit(
+        type: opts[:downgrade] ? :downgrade : :upgrade,
+        changelog: opts[:changelog]
+      )
+    end
+
+    def update
+      require_args!(optional: %w[sw])
+      core = ConfCtl::Swpins::Core.get
+      change_set = ConfCtl::Swpins::ChangeSet.new
+
+      core.specs.each do |name, spec|
+        next if args[0] && !ConfCtl::Pattern.match(args[0], name)
+
+        if spec.from_channel?
+          puts "Skipping #{spec.name} as it comes from channel #{spec.channel}"
+        elsif spec.can_update?
+          change_set.add(core, spec)
+          spec_update_msg(core, spec) { spec.prefetch_update }
+        else
+          puts "#{spec.name} not configured for update"
+        end
+      end
+
+      core.save
+      core.pre_evaluate
+
+      return unless opts[:commit]
+
+      change_set.commit(
+        type: opts[:downgrade] ? :downgrade : :upgrade,
+        changelog: opts[:changelog]
+      )
+    end
+  end
+end

data/lib/confctl/cli/swpins/utils.rb

@@ -0,0 +1,55 @@
+module ConfCtl::Cli
+  module Swpins::Utils
+    def cluster_name_list(pattern)
+      ConfCtl::Swpins::ClusterNameList.new(pattern:)
+    end
+
+    def each_cluster_name(cn_pattern)
+      cluster_name_list(cn_pattern).each do |cn|
+        cn.parse
+        yield(cn)
+      end
+    end
+
+    def each_cluster_name_spec(cn_pattern, sw_pattern)
+      each_cluster_name(cn_pattern) do |cn|
+        cn.specs.each do |name, spec|
+          yield(cn, spec) if ConfCtl::Pattern.match?(sw_pattern, name)
+        end
+      end
+    end
+
+    def channel_list(pattern)
+      ConfCtl::Swpins::ChannelList.pattern(pattern)
+    end
+
+    def each_channel(chan_pattern)
+      channel_list(chan_pattern).each do |chan|
+        chan.parse
+        yield(chan)
+      end
+    end
+
+    def each_channel_spec(chan_pattern, sw_pattern)
+      each_channel(chan_pattern) do |chan|
+        chan.specs.each do |name, spec|
+          yield(chan, spec) if ConfCtl::Pattern.match?(sw_pattern, name)
+        end
+      end
+    end
+
+    def spec_set_msg(parent, spec)
+      $stdout.write("Configuring #{spec.name} in #{parent.name}")
+      $stdout.flush
+      yield
+      puts " -> #{spec.version}"
+    end
+
+    def spec_update_msg(parent, spec)
+      $stdout.write("Updating #{spec.name} in #{parent.name}")
+      $stdout.flush
+      yield
+      puts " -> #{spec.version}"
+    end
+  end
+end

data/lib/confctl/cli/swpins.rb

@@ -0,0 +1,5 @@
+module ConfCtl::Cli
+  module Swpins; end
+end
+
+require_rel 'swpins'

data/lib/confctl/cli/tag_filters.rb

@@ -0,0 +1,30 @@
+module ConfCtl::Cli
+  class TagFilters
+    # @param str_tags [Array<String>]
+    def initialize(str_tags)
+      @must = []
+      @cant = []
+      parse_all(str_tags)
+    end
+
+    # @param machine [ConfCtl::Machine]
+    def pass?(machine)
+      must.all? { |t| machine['tags'].include?(t) } \
+        && cant.all? { |t| !machine['tags'].include?(t) }
+    end
+
+    protected
+
+    attr_reader :must, :cant
+
+    def parse_all(str_tags)
+      str_tags.each do |t|
+        if t.start_with?('^')
+          cant << t[1..]
+        else
+          must << t
+        end
+      end
+    end
+  end
+end

data/lib/confctl/cli.rb

@@ -0,0 +1,5 @@
+module ConfCtl
+  module Cli; end
+end
+
+require_rel 'cli'