confctl 1.0.0

data/lib/confctl/swpins/core.rb

@@ -0,0 +1,137 @@
+require 'fileutils'
+require 'json'
+
+module ConfCtl
+  class Swpins::Core
+    # @return [Swpins::Core]
+    def self.get
+      return @instance if @instance
+
+      @instance = new
+      @instance.parse
+      @instance
+    end
+
+    include Utils::File
+
+    # @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
+
+    def initialize
+      @name = 'core'
+      @path = File.join(ConfCtl::Swpins.core_dir, 'core.json')
+
+      settings = ConfCtl::Settings.instance
+
+      @channels = Swpins::ChannelList.get.select do |c|
+        settings.core_swpin_channels.include?(c.name)
+      end
+
+      @nix_specs = settings.core_swpin_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 core-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.core_dir)
+
+        File.open(tmp, 'w') do |f|
+          f.puts(JSON.pretty_generate(custom))
+        end
+
+        File.rename(tmp, path)
+      end
+    end
+
+    def pre_evaluate
+      nix = ConfCtl::Nix.new
+      paths = nix.eval_core_swpins
+
+      FileUtils.mkdir_p(cache_dir)
+
+      paths.each do |pin, path|
+        name = "core-swpin.#{pin}"
+        link = File.join(cache_dir, name)
+        replace_symlink(link, path)
+        ConfCtl::GCRoot.add(name, link) unless ConfCtl::GCRoot.exist?(name)
+      end
+    end
+
+    def pre_evaluated_store_paths
+      swpins_path = File.join(cache_dir, 'core.swpins')
+      return unless File.exist?(swpins_path)
+
+      swpins = JSON.parse(File.read(swpins_path))
+
+      missing_path = swpins.each_value.detect do |path|
+        !Dir.exist?(path)
+      end
+
+      return if missing_path
+
+      swpins
+    end
+
+    protected
+
+    attr_reader :nix_specs, :json_specs
+
+    def cache_dir
+      File.join(ConfDir.cache_dir, 'build')
+    end
+  end
+end

data/lib/confctl/swpins/deployed_info.rb

@@ -0,0 +1,23 @@
+require 'json'
+
+module ConfCtl
+  class Swpins::DeployedInfo
+    # @param json [String]
+    def self.parse!(json)
+      new(JSON.parse(json))
+    rescue JSON::ParserError => e
+      raise Error, "unable to parse swpins info: #{e.message}"
+    end
+
+    # @return [Hash]
+    attr_reader :swpins
+
+    def initialize(hash)
+      @swpins = hash
+    end
+
+    def [](swpin)
+      swpins[swpin]
+    end
+  end
+end

data/lib/confctl/swpins/spec.rb

@@ -0,0 +1,20 @@
+module ConfCtl
+  module Swpins::Spec
+    # @param name [Symbol]
+    # @param klass [Class]
+    def self.register(name, klass)
+      @specs ||= {}
+      @specs[name] = klass
+    end
+
+    # @param name [Symbol]
+    # @return [Class]
+    def self.for(name)
+      @specs[name]
+    end
+  end
+
+  module Swpins::Specs; end
+end
+
+require_rel 'specs'

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

@@ -0,0 +1,184 @@
+module ConfCtl
+  class Swpins::Specs::Base
+    class << self
+      attr_reader :type
+
+      # @param name [Symbol]
+      def handle(name)
+        @type = name
+        Swpins::Spec.register(name, self)
+      end
+    end
+
+    # @return [String]
+    attr_reader :name
+
+    # @param [String]
+    # @return [String, nil]
+    attr_accessor :channel
+
+    # @return [Array]
+    attr_reader :errors
+
+    # @return [Hash]
+    attr_reader :info
+
+    # @param name [String]
+    # @param nix_opts [Hash] options from the user's nix configuration
+    # @param json_opts [Hash] options from generated json file
+    def initialize(name, nix_opts, json_opts)
+      @name = name
+      @nix_opts = nix_opts
+      @json_opts = json_opts
+      @state = nil
+      @info = nil
+      @fetcher = nil
+      @fetcher_opts = nil
+      @errors = []
+      parse
+    end
+
+    def type
+      self.class.type
+    end
+
+    # Check that current nix options match those that generated json options
+    # @return [Boolean]
+    def check_opts
+      raise NotImplementedError
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def can_update?
+      nix_opts['update']['ref'] ? true : false
+    end
+
+    def auto_update?
+      can_update? && nix_opts['update']['auto']
+    end
+
+    def from_channel?
+      !channel.nil?
+    end
+
+    def status
+      valid? ? version : 'update'
+    end
+
+    def version
+      raise NotImplementedError
+    end
+
+    def prefetch_set(args)
+      raise NotImplementedError
+    end
+
+    def prefetch_update
+      raise NotImplementedError
+    end
+
+    # Check that `other_info` corresponds to this spec
+    # @param other_info [Hash]
+    # @return [Boolean]
+    def check_info(other_info)
+      raise NotImplementedError
+    end
+
+    # Return version based on the info hash
+    # @param other_info [Hash]
+    # @return [String]
+    def version_info(other_info)
+      raise NotImplementedError
+    end
+
+    # Generate changelog between revisions
+    # @param type [:upgrade, :downgrade]
+    # @param other_info [any] version reference
+    # @param opts [Hash] options
+    # @option opts [Boolean] :color
+    # @option opts [Boolean] :verbose
+    # @option opts [Boolean] :patch
+    # @return [String, nil]
+    def string_changelog_info(type, other_info, **opts)
+      raise NotImplementedError
+    end
+
+    # Generate diff between revisions
+    # @param type [:upgrade, :downgrade]
+    # @param other_info [any] version reference
+    # @param opts [Hash] options
+    # @option opts [Boolean] :color
+    # @return [String, nil]
+    def string_diff_info(type, other_info, **opts)
+      raise NotImplementedError
+    end
+
+    def as_json
+      ret = {}
+      ret['type'] = type.to_s
+      ret['nix_options'] = nix_opts
+      ret['state'] = state
+      ret['info'] = info
+      ret['fetcher'] = fetcher && {
+        'type' => fetcher,
+        'options' => fetcher_opts
+      }
+      ret
+    end
+
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+
+    protected
+
+    # @return [Hash]
+    attr_reader :nix_opts
+
+    # @return [Hash]
+    attr_reader :json_opts
+
+    # @return [Hash]
+    attr_accessor :state
+
+    attr_writer :info
+
+    # @return [String]
+    attr_reader :fetcher
+
+    # @return [Hash]
+    attr_reader :fetcher_opts
+
+    def parse
+      errors.clear
+
+      if json_opts.nil?
+        errors << 'needs prefetch'
+      elsif type.to_s != json_opts['type']
+        errors << 'invalid type, needs update'
+      elsif !json_opts['nix_options'] || !check_opts
+        errors << 'outdated options, needs update'
+      elsif json_opts['fetcher'].nil?
+        errors << 'no fetcher, needs update'
+      end
+
+      return if errors.any?
+
+      @state = json_opts['state']
+      @info = json_opts['info']
+
+      return unless json_opts['fetcher']
+
+      @fetcher = json_opts['fetcher']['type']
+      @fetcher_opts = json_opts['fetcher']['options']
+    end
+
+    def set_fetcher(name, opts)
+      @fetcher = name
+      @fetcher_opts = opts
+    end
+  end
+end

data/lib/confctl/swpins/specs/directory.rb

@@ -0,0 +1,51 @@
+require_relative 'base'
+require 'json'
+require 'time'
+
+module ConfCtl
+  class Swpins::Specs::Directory < Swpins::Specs::Base
+    handle :directory
+
+    def check_opts
+      nix_opts['path'] === json_opts['nix_options']['path']
+    end
+
+    def version
+      'directory'
+    end
+
+    def can_update?
+      true
+    end
+
+    def auto_update?
+      true
+    end
+
+    def prefetch_set(args)
+      raise "spec #{name} does not accept any arguments" if args.any?
+
+      set_fetcher(:directory, { path: nix_opts['path'] })
+    end
+
+    def prefetch_update
+      set_fetcher(:directory, { path: nix_opts['path'] })
+    end
+
+    def check_info(_other_info)
+      false
+    end
+
+    def version_info(_other_info)
+      'directory'
+    end
+
+    def string_changelog_info(_type, _other_info, verbose: false, patch: false, color: false)
+      nil
+    end
+
+    def string_diff_info(_type, _other_info, _opts = {})
+      nil
+    end
+  end
+end

data/lib/confctl/swpins/specs/git.rb

@@ -0,0 +1,135 @@
+require_relative 'base'
+require 'json'
+require 'time'
+
+module ConfCtl
+  class Swpins::Specs::Git < Swpins::Specs::Base
+    handle :git
+
+    def check_opts
+      nix_opts['url'] === json_opts['nix_options']['url'] \
+        && nix_opts['fetchSubmodules'] === json_opts['nix_options']['fetchSubmodules']
+    end
+
+    def version
+      state['rev'][0..8]
+    end
+
+    def auto_update?
+      super && (
+        state['date'].nil? \
+        || (Time.iso8601(state['date']) + nix_opts['update']['interval'] < Time.now)
+      )
+    end
+
+    def prefetch_set(args)
+      ref = args[0]
+
+      if %r{^https://github\.com/} =~ nix_opts['url'] && !nix_opts['fetchSubmodules']
+        set_fetcher('zip', prefetch_github(ref))
+      else
+        set_fetcher('git', prefetch_git(ref))
+      end
+    end
+
+    def prefetch_update
+      prefetch_set([nix_opts['update']['ref']])
+    end
+
+    def check_info(other_info)
+      return false if !other_info.is_a?(Hash) || !info.is_a?(Hash)
+
+      other_info['rev'] == info['rev'] && other_info['sha256'] == info['sha256']
+    end
+
+    def version_info(other_info)
+      return false if !other_info.is_a?(Hash) || !info.is_a?(Hash)
+
+      other_info['rev'] && other_info['rev'][0..8]
+    end
+
+    def string_changelog_info(type, other_info, verbose: false, patch: false, color: false)
+      opts = []
+      opts << '--color=always' if color
+      opts << '--oneline' unless verbose
+      opts << '-p' if patch
+
+      args =
+        if type == :upgrade
+          [other_info['rev'], state['rev']]
+        else
+          [state['rev'], other_info['rev']]
+        end
+
+      git_mirror_with_info(other_info) do |mirror|
+        mirror.log(*args, opts:)
+      end
+    end
+
+    def string_diff_info(type, other_info, color: false, **_opts)
+      gitopts = []
+      gitopts << '--color=always' if color
+
+      args =
+        if type == :upgrade
+          [other_info['rev'], state['rev']]
+        else
+          [state['rev'], other_info['rev']]
+        end
+
+      git_mirror_with_info(other_info) do |mirror|
+        mirror.diff(*args, opts: gitopts)
+      end
+    end
+
+    protected
+
+    def prefetch_git(ref)
+      json = `nix-prefetch-git --quiet #{nix_opts['url']} #{ref}`
+
+      raise "nix-prefetch-git failed with status #{$?.exitstatus}" if $?.exitstatus != 0
+
+      ret = JSON.parse(json.strip)
+      self.state = {
+        'rev' => ret['rev'],
+        'date' => Time.now.iso8601
+      }
+      self.info = {
+        'rev' => ret['rev'],
+        'sha256' => ret['sha256']
+      }
+      ret
+    end
+
+    def prefetch_github(ref)
+      mirror = GitRepoMirror.new(nix_opts['url'])
+      mirror.setup
+
+      rev = mirror.revision_parse(ref)
+      url = File.join(nix_opts['url'], 'archive', "#{rev}.tar.gz")
+      hash = `nix-prefetch-url --unpack "#{url}" 2> /dev/null`.strip
+
+      raise "nix-prefetch-url failed with status #{$?.exitstatus}" if $?.exitstatus != 0
+
+      self.state = {
+        'rev' => rev,
+        'date' => Time.now.iso8601
+      }
+      self.info = {
+        'rev' => rev,
+        'sha256' => hash
+      }
+      { 'url' => url, 'sha256' => hash }
+    end
+
+    def git_mirror_with_info(other_info)
+      raise ConfCtl::Error, 'swpin not configured' if info.nil?
+
+      return if state['rev'] == other_info['rev']
+
+      mirror = GitRepoMirror.new(nix_opts['url'], quiet: true)
+      mirror.setup
+      yield(mirror)
+    end
+  end
+end

data/lib/confctl/swpins/specs/git_rev.rb

@@ -0,0 +1,24 @@
+require_relative 'git'
+
+module ConfCtl
+  class Swpins::Specs::GitRev < Swpins::Specs::Git
+    handle :'git-rev'
+
+    def prefetch_set(args)
+      super(args)
+      wrap_fetcher
+    end
+
+    protected
+
+    def wrap_fetcher
+      set_fetcher('git-rev', {
+        'rev' => state['rev'],
+        'wrapped_fetcher' => {
+          'type' => fetcher,
+          'options' => fetcher_opts
+        }
+      })
+    end
+  end
+end

data/lib/confctl/swpins.rb

@@ -0,0 +1,17 @@
+module ConfCtl
+  module Swpins
+    def self.core_dir
+      File.join(ConfDir.path, 'swpins')
+    end
+
+    def self.channel_dir
+      File.join(ConfDir.path, 'swpins/channels')
+    end
+
+    def self.cluster_dir
+      File.join(ConfDir.path, 'swpins/cluster')
+    end
+  end
+end
+
+require_rel 'swpins'

data/lib/confctl/system_command.rb

@@ -0,0 +1,10 @@
+require 'tty-command'
+
+module ConfCtl
+  module SystemCommand
+    # @return [TTY::Command]
+    def self.new
+      TTY::Command.new(output: Logger.instance, color: false)
+    end
+  end
+end

data/lib/confctl/user_script.rb

@@ -0,0 +1,13 @@
+module ConfCtl
+  class UserScript
+    def self.register
+      UserScripts.register(self)
+    end
+
+    # @param hooks [Hook]
+    def setup_hooks(hooks); end
+
+    # @param app [GLI::App]
+    def setup_cli(app); end
+  end
+end

data/lib/confctl/user_scripts.rb

@@ -0,0 +1,41 @@
+module ConfCtl
+  module UserScripts
+    def self.load_scripts
+      dir = ConfDir.user_script_dir
+
+      begin
+        files = Dir.entries(dir)
+      rescue Errno::ENOENT
+        return
+      end
+
+      files.each do |f|
+        abs_path = File.join(dir, f)
+        next unless File.file?(abs_path)
+
+        load(abs_path)
+      end
+    end
+
+    def self.register(klass)
+      @scripts ||= []
+      @scripts << klass.new
+    end
+
+    def self.setup_all
+      each do |script|
+        script.setup_hooks(Hook)
+      end
+    end
+
+    # @return [Array<UserScript>]
+    def self.get
+      @scripts || []
+    end
+
+    # @yieldparam [UserScript]
+    def self.each(&)
+      get.each(&)
+    end
+  end
+end

data/lib/confctl/utils/file.rb

@@ -0,0 +1,21 @@
+module ConfCtl
+  module Utils::File
+    # Atomically replace or create symlink
+    # @param path [String] symlink path
+    # @param dst [String] destination
+    def replace_symlink(path, dst)
+      replacement = "#{path}.new-#{SecureRandom.hex(3)}"
+      File.symlink(dst, replacement)
+      File.rename(replacement, path)
+    end
+
+    # Unlink file if it exists
+    # @param path [String]
+    def unlink_if_exists(path)
+      File.unlink(path)
+      true
+    rescue Errno::ENOENT
+      false
+    end
+  end
+end

data/lib/confctl/version.rb

@@ -0,0 +1,3 @@
+module ConfCtl
+  VERSION = '1.0.0'.freeze
+end