confctl 1.0.0

data/lib/confctl/nix_format.rb

@@ -0,0 +1,124 @@
+require 'pathname'
+
+module ConfCtl
+  # Format Ruby values in Nix
+  class NixFormat
+    # @param value [any]
+    # @param sort [Boolean] sort hash keys
+    # @return [String]
+    def self.to_nix(value, sort: true)
+      new(sort:).to_nix(value)
+    end
+
+    # @param sort [Boolean] sort hash keys
+    def initialize(sort: true)
+      @sort = sort
+      @output = ''
+      @level = 0
+    end
+
+    # @param value [any]
+    # @return [String]
+    def to_nix(value)
+      format_value(value).strip
+    end
+
+    def pad(str, indent: true)
+      if indent
+        "#{' ' * @level}#{str}"
+      else
+        str
+      end
+    end
+
+    def indent
+      @level += 2
+      yield
+      @level -= 2
+    end
+
+    protected
+
+    def format_value(value, indent: true, semicolon: false, nl: false)
+      if value.respond_to?(:to_nix)
+        return value.to_nix(nix_format: self, indent:, semicolon:, nl:)
+      end
+
+      case value
+      when Hash
+        format_hash(value, indent:, semicolon:, nl:)
+
+      when Array
+        format_array(value, indent:, semicolon:, nl:)
+
+      else
+        simple =
+          case value
+          when String
+            value.dump
+
+          when Symbol
+            value.to_s.dump
+
+          when Numeric, true, false
+            value.to_s
+
+          when Pathname
+            str = value.to_s
+
+            if str.start_with?('/')
+              str
+            else
+              "./#{str}"
+            end
+
+          when nil
+            'null'
+
+          else
+            raise "Unable to format #{value.inspect} (#{value.class}) to nix: " \
+                  'implement #to_nix()?'
+          end
+
+        pad("#{simple}#{semicolon ? ';' : ''}#{nl ? "\n" : ''}", indent:)
+      end
+    end
+
+    def format_hash(hash, indent: true, semicolon: false, nl: true)
+      ret = pad("{\n", indent:)
+
+      quote_keys = !hash.each_key.all? { |k| /^[a-zA-Z_][a-zA-Z_\-']*$/ =~ k }
+
+      sorted =
+        if @sort
+          hash.sort do |a, b|
+            a[0] <=> b[0]
+          end
+        else
+          hash
+        end
+
+      indent do
+        sorted.each do |k, v|
+          ret << (quote_keys ? pad("\"#{k}\"") : pad(k.to_s))
+          ret << " = #{format_value(v, indent: false, semicolon: true, nl: false)}\n"
+        end
+      end
+
+      ret << pad("}#{semicolon ? ';' : ''}#{nl ? "\n" : ''}")
+      ret
+    end
+
+    def format_array(array, indent: true, semicolon: false, nl: true)
+      ret = pad("[\n", indent:)
+
+      indent do
+        array.each do |v|
+          ret << "#{pad(format_value(v, indent: false, nl: false))}\n"
+        end
+      end
+
+      ret << pad("]#{semicolon ? ';' : ''}#{nl ? "\n" : ''}")
+    end
+  end
+end

data/lib/confctl/nix_literal_expression.rb

@@ -0,0 +1,15 @@
+module ConfCtl
+  class NixLiteralExpression
+    def initialize(value)
+      @value = value
+    end
+
+    def to_s
+      @value
+    end
+
+    def to_nix(**)
+      @value
+    end
+  end
+end

data/lib/confctl/parallel_executor.rb

@@ -0,0 +1,43 @@
+module ConfCtl
+  class ParallelExecutor
+    attr_reader :thread_count
+
+    def initialize(threads)
+      @thread_count = threads
+      @threads = []
+      @queue = Queue.new
+      @retvals = []
+      @mutex = Mutex.new
+    end
+
+    def add(&block)
+      queue << block
+    end
+
+    def run
+      thread_count.times do
+        threads << Thread.new { worker }
+      end
+
+      threads.each(&:join)
+      retvals
+    end
+
+    protected
+
+    attr_reader :threads, :queue, :mutex, :retvals
+
+    def worker
+      loop do
+        begin
+          block = queue.pop(true)
+        rescue ThreadError
+          return
+        end
+
+        v = block.call
+        mutex.synchronize { retvals << v }
+      end
+    end
+  end
+end

data/lib/confctl/pattern.rb

@@ -0,0 +1,9 @@
+module ConfCtl
+  module Pattern
+    # @param pattern [String]
+    # @param name [String]
+    def self.match?(pattern, name)
+      File.fnmatch?(pattern, name, File::FNM_EXTGLOB)
+    end
+  end
+end

data/lib/confctl/settings.rb

@@ -0,0 +1,50 @@
+require 'singleton'
+
+module ConfCtl
+  class Settings
+    include Singleton
+
+    def initialize
+      @settings = nil
+    end
+
+    def list_columns
+      read_settings { |s| s['list']['columns'] }
+    end
+
+    def max_jobs
+      read_settings { |s| s['nix']['maxJobs'] }
+    end
+
+    def nix_paths
+      read_settings { |s| s['nix']['nixPath'] }
+    end
+
+    def core_swpin_channels
+      read_settings { |s| s['swpins']['core']['channels'] }
+    end
+
+    def core_swpin_pins
+      read_settings { |s| s['swpins']['core']['pins'] }
+    end
+
+    def build_generations
+      read_settings { |s| s['buildGenerations'] }
+    end
+
+    def host_generations
+      read_settings { |s| s['hostGenerations'] }
+    end
+
+    protected
+
+    def read_settings
+      if @settings.nil?
+        nix = Nix.stateless
+        @settings = nix.confctl_settings
+      end
+
+      yield(@settings)
+    end
+  end
+end

data/lib/confctl/std_line_buffer.rb

@@ -0,0 +1,40 @@
+module ConfCtl
+  # Pair of line buffers for standard output/error
+  class StdLineBuffer
+    # @yieldparam out [String, nil]
+    # @yieldparam err [String, nil]
+    def initialize(&block)
+      @out_buffer = LineBuffer.new
+      @err_buffer = LineBuffer.new
+      @block = block
+      @mutex = Mutex.new
+    end
+
+    # Get a block which can be called to feed data to the buffer
+    # @return [Proc]
+    def feed_block
+      proc do |stdout, stderr|
+        @mutex.synchronize do
+          out_buffer << stdout if stdout
+          err_buffer << stderr if stderr
+
+          loop do
+            out_line = out_buffer.read_line
+            err_line = err_buffer.read_line
+            break if out_line.nil? && err_line.nil?
+
+            block.call(out_line, err_line)
+          end
+        end
+      end
+    end
+
+    def flush
+      block.call(out_buffer.flush, err_buffer.flush)
+    end
+
+    protected
+
+    attr_reader :out_buffer, :err_buffer, :block
+  end
+end

data/lib/confctl/swpins/change_set.rb

@@ -0,0 +1,151 @@
+module ConfCtl
+  class Swpins::ChangeSet
+    class SpecOwner
+      attr_reader :name, :path
+    end
+
+    SpecSet = Struct.new(:spec, :original_version, :original_info, keyword_init: true) do
+      def name
+        spec.name
+      end
+
+      def new_version
+        spec.version
+      end
+
+      def new_info
+        spec.info
+      end
+
+      def changed?
+        original_version != new_version
+      end
+
+      def string_changelog(type)
+        if original_info
+          spec.string_changelog_info(type, original_info, color: false)
+        else
+          "Initial version\n"
+        end
+      end
+    end
+
+    def initialize
+      @owners = {}
+    end
+
+    # @param owner [SpecOwner]
+    # @param spec [Swpins::Spec]
+    def add(owner, spec)
+      @owners[owner] ||= []
+      @owners[owner] << SpecSet.new(
+        spec:,
+        original_version: spec.valid? ? spec.version : nil,
+        original_info: spec.valid? ? spec.info : nil
+      )
+      nil
+    end
+
+    # @param type [:upgrade, :downgrade]
+    # @param changelog [Boolean]
+    def commit(type: :upgrade, changelog: false)
+      return if @owners.empty?
+
+      ret = Kernel.system(
+        'git',
+        'commit',
+        '-e',
+        '-m', build_message(type, changelog),
+        *changed_files
+      )
+
+      return if ret
+
+      raise 'git commit exited with non-zero status code'
+    end
+
+    protected
+
+    def build_message(type, changelog)
+      [
+        build_title(type, changelog),
+        build_description(type, changelog)
+      ].join("\n\n")
+    end
+
+    def build_title(type, changelog)
+      msg = 'swpins: '
+
+      if same_changes?
+        spec_sets = @owners.first[1]
+        msg << "#{@owners.each_key.map(&:name).sort.join(', ')}: update "
+
+        msg << spec_sets.map do |spec_set|
+          "#{spec_set.name} to #{spec_set.new_version}"
+        end.join(', ')
+      else
+        all_spec_names = []
+
+        @owners.each_value do |spec_sets|
+          spec_sets.each do |spec_set|
+            all_spec_names << spec_set.name unless all_spec_names.include?(spec_set.name)
+          end
+        end
+
+        msg << "#{@owners.each_key.map(&:name).join(', ')}: update #{all_spec_names.sort.join(', ')}"
+      end
+
+      msg
+    end
+
+    def build_description(type, changelog)
+      msg = ''
+
+      @owners.each do |owner, spec_sets|
+        spec_sets.each do |spec_set|
+          if spec_set.changed?
+            msg << "#{owner.name} #{spec_set.name}: "
+
+            msg << if spec_set.original_version
+                     "#{spec_set.original_version} -> #{spec_set.new_version}\n"
+                   else
+                     "set to #{spec_set.new_version}\n"
+                   end
+
+            if changelog
+              msg << spec_set.string_changelog(type)
+              msg << "\n"
+            end
+          else
+            msg << "  #{spec_set.name}: unchanged\n"
+          end
+        end
+
+        msg << "\n" if changelog
+      end
+
+      msg
+    end
+
+    def changed_files
+      @owners.each_key.map(&:path)
+    end
+
+    def same_changes?
+      return true if @owners.length == 1
+
+      expected_spec_sets = @owners.first[1]
+
+      @owners.each_value do |spec_sets|
+        return false if expected_spec_sets.length != spec_sets.length
+
+        spec_sets.each do |spec_set|
+          expected = expected_spec_sets.detect { |v| v.name == spec_set.name }
+          return false if expected.nil? || expected.new_version != spec_set.new_version
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/confctl/swpins/channel.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+require 'json'
+
+module ConfCtl
+  class Swpins::Channel
+    # @return [String]
+    attr_reader :path
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Hash<String, Swpins::Specs::Base>]
+    attr_reader :specs
+
+    # @param name [String]
+    # @param nix_specs [Hash]
+    def initialize(name, nix_specs)
+      @name = name
+      @path = File.join(ConfCtl::Swpins.channel_dir, "#{name}.json")
+      @nix_specs = nix_specs
+    end
+
+    def parse
+      @json_specs = if File.exist?(path)
+                      JSON.parse(File.read(path))
+                    else
+                      {}
+                    end
+
+      @specs = nix_specs.to_h do |name, nix_opts|
+        [
+          name,
+          Swpins::Spec.for(nix_opts['type'].to_sym).new(
+            name,
+            nix_opts[nix_opts['type']],
+            json_specs[name]
+          )
+        ]
+      end
+    end
+
+    def valid?
+      specs.values.all?(&:valid?)
+    end
+
+    def save
+      tmp = "#{path}.new"
+
+      FileUtils.mkdir_p(ConfCtl::Swpins.channel_dir)
+
+      File.open(tmp, 'w') do |f|
+        f.puts(JSON.pretty_generate(specs))
+      end
+
+      File.rename(tmp, path)
+    end
+
+    protected
+
+    attr_reader :nix_specs, :json_specs
+  end
+end

data/lib/confctl/swpins/channel_list.rb

@@ -0,0 +1,47 @@
+module ConfCtl
+  class Swpins::ChannelList < Array
+    # @return [Swpins::ChannelList]
+    def self.get
+      @get ||= new
+    end
+
+    # @param pattern [String]
+    def self.pattern(pattern)
+      get.pattern(pattern)
+    end
+
+    def self.refresh
+      get.refresh
+    end
+
+    # @param pattern [String]
+    def initialize(pattern: '*')
+      super()
+      parse(pattern:)
+    end
+
+    # @param pattern [String]
+    # @return [Array<Swpins::Channel>]
+    def pattern(pattern)
+      select { |c| Pattern.match?(pattern, c.name) }
+    end
+
+    def refresh
+      clear
+      parse
+    end
+
+    protected
+
+    def parse(pattern: '*')
+      nix = Nix.new
+      nix.list_swpins_channels.each do |name, nix_specs|
+        next unless Pattern.match?(pattern, name)
+
+        c = Swpins::Channel.new(name, nix_specs)
+        c.parse
+        self << c
+      end
+    end
+  end
+end

data/lib/confctl/swpins/cluster_name.rb

@@ -0,0 +1,94 @@
+require 'fileutils'
+require 'json'
+
+module ConfCtl
+  class Swpins::ClusterName
+    # @return [Machine]
+    attr_reader :machine
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [String]
+    attr_reader :path
+
+    # @return [Hash<String, Swpins::Specs::Base>]
+    attr_reader :specs
+
+    # @return [Array<Swpins::Channel>]
+    attr_reader :channels
+
+    # @param machine [Machine]
+    # @param channels [Swpins::ChannelList]
+    def initialize(machine, channels)
+      @machine = machine
+      @name = machine.name
+      @path = File.join(ConfCtl::Swpins.cluster_dir, "#{name.gsub('/', ':')}.json")
+      @channels = channels.select do |c|
+        machine['swpins']['channels'].include?(c.name)
+      end
+      @nix_specs = machine['swpins']['pins']
+    end
+
+    def parse
+      @specs = {}
+
+      # Add specs from channels
+      channels.each do |chan|
+        chan.specs.each do |name, chan_spec|
+          s = chan_spec.clone
+          s.channel = chan.name
+          specs[name] = s
+        end
+      end
+
+      # Add machine-specific specs
+      @json_specs = if File.exist?(path)
+                      JSON.parse(File.read(path))
+                    else
+                      {}
+                    end
+
+      nix_specs.each do |name, nix_opts|
+        specs[name] = Swpins::Spec.for(nix_opts['type'].to_sym).new(
+          name,
+          nix_opts[nix_opts['type']],
+          json_specs[name]
+        )
+      end
+    end
+
+    def valid?
+      specs.values.all?(&:valid?)
+    end
+
+    def save
+      custom = {}
+      specs.each do |name, s|
+        custom[name] = s unless s.from_channel?
+      end
+
+      if custom.empty?
+        begin
+          File.unlink(path)
+        rescue Errno::ENOENT
+          # ignore
+        end
+      else
+        tmp = "#{path}.new"
+
+        FileUtils.mkdir_p(ConfCtl::Swpins.cluster_dir)
+
+        File.open(tmp, 'w') do |f|
+          f.puts(JSON.pretty_generate(custom))
+        end
+
+        File.rename(tmp, path)
+      end
+    end
+
+    protected
+
+    attr_reader :nix_specs, :json_specs
+  end
+end

data/lib/confctl/swpins/cluster_name_list.rb

@@ -0,0 +1,15 @@
+module ConfCtl
+  class Swpins::ClusterNameList < Array
+    # @param channels [Swpins::ChannelList]
+    # @param pattern [String]
+    # @param machines [MachineList]
+    def initialize(channels: nil, pattern: '*', machines: nil)
+      super()
+      channels ||= ConfCtl::Swpins::ChannelList.get
+
+      (machines || MachineList.new).each_value do |machine|
+        self << Swpins::ClusterName.new(machine, channels) if Pattern.match?(pattern, machine.name)
+      end
+    end
+  end
+end