confctl 1.0.0

data/lib/confctl/conf_cache.rb

@@ -0,0 +1,105 @@
+require 'fileutils'
+require 'json'
+
+module ConfCtl
+  # Cache the list of configuration files to detect changes
+  #
+  # The assumption is that if there hasn't been any changes in configuration
+  # directory, we can reuse previously built artefacts, such as the list of
+  # machines, etc. This is much faster than invoking nix-build to query
+  # the machines.
+  class ConfCache
+    # @param conf_dir [ConfDir]
+    def initialize(conf_dir)
+      @conf_dir = conf_dir
+      @cmd = SystemCommand.new
+      @cache_dir = File.join(conf_dir.cache_dir, 'build')
+      @cache_file = File.join(@cache_dir, 'git-files.json')
+      @files = {}
+      @loaded = false
+      @uptodate = nil
+      @checked_at = nil
+    end
+
+    # Load file list from cache file
+    def load_cache
+      begin
+        data = File.read(@cache_file)
+      rescue Errno::ENOENT
+        return
+      end
+
+      @files = JSON.parse(data)['files']
+      @loaded = true
+    end
+
+    # Check if cached file list differs from files on disk
+    # @param force [Boolean] force a new check
+    def uptodate?(force: false)
+      return @uptodate if !@uptodate.nil? && !force
+
+      @uptodate = check_uptodate
+      @uptodate
+    end
+
+    # Update cache file with the current state of the configuration directory
+    def update
+      @files.clear
+
+      list_files.each do |file|
+        begin
+          st = File.lstat(file)
+        rescue Errno::ENOENT
+          next
+        end
+
+        @files[file] = {
+          'mtime' => st.mtime.to_i,
+          'size' => st.size
+        }
+      end
+
+      tmp = "#{@cache_file}.new"
+
+      FileUtils.mkpath(@cache_dir)
+      File.write(tmp, { 'files' => @files }.to_json)
+      File.rename(tmp, @cache_file)
+
+      @uptodate = true
+    end
+
+    # @return [Time, nil]
+    def mtime
+      File.lstat(@cache_file).mtime
+    rescue Errno::ENOENT
+      nil
+    end
+
+    protected
+
+    def check_uptodate
+      load_cache unless @loaded
+      return false if @files.empty?
+
+      list_files.each do |file_path|
+        file = @files[file_path]
+        return false if file.nil?
+
+        begin
+          st = File.lstat(file_path)
+        rescue Errno::ENOENT
+          return false
+        end
+
+        return false if file['mtime'] != st.mtime.to_i || file['size'] != st.size
+      end
+
+      true
+    end
+
+    def list_files
+      out, = @cmd.run('git', '-C', @path, 'ls-files', '-z')
+      out.strip.split("\0")
+    end
+  end
+end

data/lib/confctl/conf_dir.rb

@@ -0,0 +1,88 @@
+require 'digest'
+require 'singleton'
+
+module ConfCtl
+  class ConfDir
+    include Singleton
+
+    class << self
+      %i[
+        path
+        hash
+        short_hash
+        cache_dir
+        generation_dir
+        log_dir
+        user_script_dir
+        changed?
+        unchanged?
+        state_mtime
+        update_state
+      ].each do |v|
+        define_method(v) do |*args, **kwargs, &block|
+          instance.send(v, *args, **kwargs, &block)
+        end
+      end
+    end
+
+    def initialize
+      @cache = ConfCache.new(self)
+    end
+
+    # Path to the directory containing cluster configuration
+    # @return [String]
+    def path
+      @path ||= File.realpath(Dir.pwd)
+    end
+
+    # Unique hash identifying the configuration based on its filesystem path
+    # @return [String]
+    def hash
+      @hash ||= Digest::SHA256.hexdigest(path)
+    end
+
+    # Shorter prefix of {hash}
+    # @return [String]
+    def short_hash
+      @short_hash ||= hash[0..7]
+    end
+
+    # Path to configuration-specific cache directory
+    # @return [String]
+    def cache_dir
+      @cache_dir ||= File.join(path, '.confctl')
+    end
+
+    # Path to directory with build generations
+    # @return [String]
+    def generation_dir
+      @generation_dir ||= File.join(cache_dir, 'generations')
+    end
+
+    # Path to configuration-specific log directory
+    # @return [String]
+    def log_dir
+      @log_dir ||= File.join(cache_dir, 'logs')
+    end
+
+    def user_script_dir
+      @user_script_dir ||= File.join(path, 'scripts')
+    end
+
+    def changed?
+      !unchanged?
+    end
+
+    def unchanged?
+      @cache.uptodate?
+    end
+
+    def state_mtime
+      @cache.mtime
+    end
+
+    def update_state
+      @cache.update
+    end
+  end
+end

data/lib/confctl/erb_template.rb

@@ -0,0 +1,37 @@
+require 'erb'
+
+module ConfCtl
+  class ErbTemplate
+    def self.render(name, vars)
+      t = new(name, vars)
+      t.render
+    end
+
+    def self.render_to(name, vars, path)
+      File.write("#{path}.new", render(name, vars))
+      File.rename("#{path}.new", path)
+    end
+
+    def initialize(name, vars)
+      @_tpl = ERB.new(
+        File.read(
+          File.join(ConfCtl.root, 'template', "#{name}.erb")
+        ), trim_mode: '-'
+      )
+
+      vars.each do |k, v|
+        if v.is_a?(Proc)
+          define_singleton_method(k, &v)
+        elsif v.is_a?(Method)
+          define_singleton_method(k) { |*args| v.call(*args) }
+        else
+          define_singleton_method(k) { v }
+        end
+      end
+    end
+
+    def render
+      @_tpl.result(binding)
+    end
+  end
+end

data/lib/confctl/exceptions.rb

@@ -0,0 +1,3 @@
+module ConfCtl
+  class Error < ::StandardError; end
+end

data/lib/confctl/gcroot.rb

@@ -0,0 +1,30 @@
+require 'confctl/utils/file'
+require 'etc'
+require 'fileutils'
+
+module ConfCtl
+  module GCRoot
+    extend Utils::File
+
+    def self.dir
+      File.join(
+        '/nix/var/nix/gcroots/per-user',
+        Etc.getlogin,
+        "confctl-#{ConfDir.short_hash}"
+      )
+    end
+
+    def self.exist?(name)
+      File.symlink?(File.join(dir, name))
+    end
+
+    def self.add(name, path)
+      FileUtils.mkdir_p(dir)
+      File.symlink(path, File.join(dir, name))
+    end
+
+    def self.remove(name)
+      unlink_if_exists(File.join(dir, name))
+    end
+  end
+end

data/lib/confctl/generation/build.rb

@@ -0,0 +1,145 @@
+require 'fileutils'
+require 'json'
+require 'time'
+
+module ConfCtl
+  class Generation::Build
+    # @return [String]
+    attr_reader :host
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Time]
+    attr_reader :date
+
+    # @return [String]
+    attr_reader :toplevel
+
+    # @return [Array<String>]
+    attr_reader :swpin_names
+
+    # @return [Hash]
+    attr_reader :swpin_paths
+
+    # @return [Hash]
+    attr_reader :swpin_specs
+
+    # @param current [Boolean]
+    # @return [Boolean]
+    attr_accessor :current
+
+    # @param host [String]
+    def initialize(host)
+      @host = host
+    end
+
+    # @param toplevel [String]
+    # @param swpin_paths [Hash]
+    # @param swpin_specs [Hash]
+    # @param date [Time]
+    def create(toplevel, swpin_paths, swpin_specs, date: nil)
+      @toplevel = toplevel
+      @swpin_names = swpin_paths.keys
+      @swpin_paths = swpin_paths
+      @swpin_specs = swpin_specs
+      @date = date || Time.now
+      @name = date.strftime('%Y-%m-%d--%H-%M-%S')
+    end
+
+    # @param name [String]
+    def load(name)
+      @name = name
+
+      cfg = JSON.parse(File.read(config_path))
+      @toplevel = cfg['toplevel']
+
+      @swpin_names = []
+      @swpin_paths = {}
+      @swpin_specs = {}
+
+      cfg['swpins'].each do |swpin_name, swpin|
+        @swpin_names << swpin_name
+        @swpin_paths[swpin_name] = swpin['path']
+        @swpin_specs[swpin_name] = Swpins::Spec.for(swpin['spec']['type'].to_sym).new(
+          swpin_name,
+          swpin['spec']['nix_options'],
+          swpin['spec']
+        )
+      end
+
+      @date = Time.iso8601(cfg['date'])
+    rescue StandardError => e
+      raise Error, "invalid generation '#{name}': #{e.message}"
+    end
+
+    def save
+      FileUtils.mkdir_p(dir)
+      File.symlink(toplevel, toplevel_path)
+
+      swpin_paths.each do |name, path|
+        File.symlink(path, swpin_path(name))
+      end
+
+      File.open(config_path, 'w') do |f|
+        f.puts(JSON.pretty_generate({
+          date: date.iso8601,
+          toplevel:,
+          swpins: swpin_paths.to_h do |name, path|
+            [name, { path:, spec: swpin_specs[name].as_json }]
+          end
+        }))
+      end
+
+      add_gcroot
+    end
+
+    def destroy
+      remove_gcroot
+      File.unlink(toplevel_path)
+      swpin_paths.each_key { |name| File.unlink(swpin_path(name)) }
+      File.unlink(config_path)
+      Dir.rmdir(dir)
+    end
+
+    def add_gcroot
+      GCRoot.add(gcroot_name('toplevel'), toplevel_path)
+      swpin_paths.each_key do |name|
+        GCRoot.add(gcroot_name("swpin.#{name}"), toplevel_path)
+      end
+    end
+
+    def remove_gcroot
+      GCRoot.remove(gcroot_name('toplevel'))
+      swpin_paths.each_key do |name|
+        GCRoot.remove(gcroot_name("swpin.#{name}"))
+      end
+    end
+
+    def dir
+      @dir ||= File.join(ConfDir.generation_dir, escaped_host, name)
+    end
+
+    protected
+
+    def config_path
+      @config_path ||= File.join(dir, 'generation.json')
+    end
+
+    def toplevel_path
+      @toplevel_path ||= File.join(dir, 'toplevel')
+    end
+
+    def swpin_path(name)
+      File.join(dir, "#{name}.swpin")
+    end
+
+    def escaped_host
+      @escaped_host ||= ConfCtl.safe_host_name(host)
+    end
+
+    def gcroot_name(file)
+      "#{escaped_host}-generation-#{name}-#{file}"
+    end
+  end
+end

data/lib/confctl/generation/build_list.rb

@@ -0,0 +1,106 @@
+require 'confctl/utils/file'
+
+module ConfCtl
+  class Generation::BuildList
+    include Utils::File
+
+    # @return [String]
+    attr_reader :host
+
+    # @return [Generation::Build, nil]
+    attr_reader :current
+
+    # @return [String]
+    def initialize(host)
+      @host = host
+      @generations = []
+      @index = {}
+
+      return unless Dir.exist?(dir)
+
+      Dir.entries(dir).each do |v|
+        abs_path = File.join(dir, v)
+        next if %w[. ..].include?(v) || !Dir.exist?(abs_path) || File.symlink?(abs_path)
+
+        gen = Generation::Build.new(host)
+
+        begin
+          gen.load(v)
+        rescue Error => e
+          warn "Ignoring invalid generation #{gen.dir}"
+          next
+        end
+
+        generations << gen
+        index[gen.name] = gen
+      end
+
+      generations.sort! do |a, b|
+        a.date <=> b.date
+      end
+
+      current_gen =
+        if File.exist?(current_symlink)
+          name = File.basename(File.readlink(current_symlink))
+          index[name] || generations.last
+        else
+          generations.last
+        end
+
+      change_current(current_gen) if current_gen
+    end
+
+    # @param name [String]
+    def [](name)
+      index[name]
+    end
+
+    def each(&)
+      generations.each(&)
+    end
+
+    # @return [Array<Generation::Build>]
+    def to_a
+      generations.clone
+    end
+
+    # @return [Integer]
+    def count
+      generations.length
+    end
+
+    # @param gen [Generation::Build]
+    def current=(gen)
+      change_current(gen)
+      generations << gen unless generations.include?(gen)
+      replace_symlink(current_symlink, gen.name)
+    end
+
+    # @param toplevel [String]
+    # @param swpin_paths [Hash]
+    # @return [Generation::Build, nil]
+    def find(toplevel, swpin_paths)
+      generations.detect do |gen|
+        gen.toplevel == toplevel && gen.swpin_paths == swpin_paths
+      end
+    end
+
+    protected
+
+    attr_reader :generations, :index
+
+    def dir
+      @dir ||= File.join(ConfDir.generation_dir, ConfCtl.safe_host_name(host))
+    end
+
+    def current_symlink
+      @current_symlink ||= File.join(dir, 'current')
+    end
+
+    def change_current(gen)
+      @current = gen
+      generations.each { |g| g.current = false }
+      gen.current = true
+    end
+  end
+end

data/lib/confctl/generation/host.rb

@@ -0,0 +1,35 @@
+module ConfCtl
+  class Generation::Host
+    attr_reader :host, :profile, :id, :toplevel, :date, :current
+
+    # @param host [String]
+    # @param profile [String]
+    # @param id [Integer]
+    # @param toplevel [String]
+    # @param date [Time]
+    # @param mc [MachineControl]
+    def initialize(host, profile, id, toplevel, date, current: false, mc: nil)
+      @host = host
+      @profile = profile
+      @id = id
+      @toplevel = toplevel
+      @date = date
+      @current = current
+      @mc = mc
+    end
+
+    def approx_name
+      @approx_name ||= date.strftime('%Y-%m-%d--%H-%M-%S')
+    end
+
+    def destroy
+      raise 'machine control not available' if mc.nil?
+
+      mc.execute('nix-env', '-p', profile, '--delete-generations', id.to_s)
+    end
+
+    protected
+
+    attr_reader :mc
+  end
+end

data/lib/confctl/generation/host_list.rb

@@ -0,0 +1,81 @@
+module ConfCtl
+  class Generation::HostList
+    # @param mc [MachineControl]
+    # @return [Generation::HostList]
+    def self.fetch(mc, profile: '/nix/var/nix/profiles/system')
+      out, = mc.bash_script(<<-END
+        realpath #{profile}
+
+        for generation in `ls -d -1 #{profile}-*-link` ; do
+          echo "$generation;$(readlink $generation);$(stat --format=%Y $generation)"
+        done
+      END
+                           )
+
+      list = new(mc.machine.name)
+      lines = out.strip.split("\n")
+      current_path = lines.shift
+      id_rx = /^#{Regexp.escape(profile)}-(\d+)-link$/
+
+      lines.each do |line|
+        link, path, created_at = line.split(';')
+
+        if id_rx =~ link
+          id = ::Regexp.last_match(1).to_i
+        else
+          warn "Invalid profile generation link '#{link}'"
+          next
+        end
+
+        list << Generation::Host.new(
+          mc.machine.name,
+          profile,
+          id,
+          path,
+          Time.at(created_at.to_i),
+          current: path == current_path,
+          mc:
+        )
+      end
+
+      list.sort
+      list
+    end
+
+    # @return [String]
+    attr_reader :host
+
+    # @param host [String]
+    def initialize(host)
+      @host = host
+      @generations = []
+    end
+
+    # @param generation [Generation::Host]
+    def <<(generation)
+      generations << generation
+    end
+
+    def sort
+      generations.sort! { |a, b| a.id <=> b.id }
+    end
+
+    def each(&)
+      generations.each(&)
+    end
+
+    # @return [Integer]
+    def count
+      generations.length
+    end
+
+    # @return [Generation::Host]
+    def current
+      generations.detect(&:current)
+    end
+
+    protected
+
+    attr_reader :generations
+  end
+end