confctl 2.2.2 → 3.0.0

data/lib/confctl/machine_status.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'tty-command'
+require 'confctl/inputs_info'
 
 module ConfCtl
   class MachineStatus
@@ -73,9 +74,15 @@ module ConfCtl
     # @return [Hash]
     attr_accessor :target_swpin_specs
 
+    # @return [Hash]
+    attr_accessor :target_inputs_info
+
     # @return [Hash]
     attr_reader :swpins_info
 
+    # @return [Hash]
+    attr_reader :inputs_info
+
     # @return [Hash]
     attr_reader :swpins_state
 
@@ -86,7 +93,7 @@ module ConfCtl
     end
 
     # Connect to the machine and query its state
-    def query(toplevel: true, generations: true)
+    def query(toplevel: true, generations: true, swpins: true, inputs: false)
       begin
         @uptime = mc.uptime
       rescue TTY::Command::ExitError
@@ -109,8 +116,18 @@ module ConfCtl
         end
       end
 
+      if swpins
+        begin
+          @swpins_info = query_swpins
+        rescue Error
+          nil
+        end
+      end
+
+      return unless inputs
+
       begin
-        @swpins_info = query_swpins
+        @inputs_info = query_inputs_info
       rescue Error
         nil
       end
@@ -145,12 +162,7 @@ module ConfCtl
     end
 
     def query_swpins
-      json =
-        if machine.carried?
-          query_carried_swpins
-        else
-          mc.read_file('/etc/confctl/swpins-info.json')
-        end
+      json = read_swpins_info_json
 
       case json
       when String
@@ -160,22 +172,53 @@ module ConfCtl
       end
     end
 
-    # @return [Hash, String]
-    def query_carried_swpins
-      begin
-        json = mc.read_file(File.join(machine.profile, 'machine.json'))
-        parsed = JSON.parse(json)
-        return parsed['swpins-info'] if parsed['swpins-info']
-      rescue TTY::Command::ExitError
-        # pass
+    def query_inputs_info
+      json = read_inputs_info_json
+
+      case json
+      when String
+        InputsInfo.parse(json)
+      when Hash
+        InputsInfo.normalize(json)
       end
+    end
 
-      begin
-        return mc.read_file(File.join(machine.profile, '/etc/confctl/swpins-info.json'))
-      rescue TTY::Command::ExitError
-        # pass
+    # @return [Hash, String, nil]
+    def read_swpins_info_json
+      if machine.carried?
+        read_carried_info_json('swpins-info', '/etc/confctl/swpins-info.json')
+      else
+        read_file('/etc/confctl/swpins-info.json')
+      end
+    end
+
+    # @return [Hash, String, nil]
+    def read_inputs_info_json
+      if machine.carried?
+        read_carried_info_json('inputs-info', '/etc/confctl/inputs-info.json')
+      else
+        read_file('/etc/confctl/inputs-info.json')
       end
+    end
+
+    def read_carried_info_json(key, path)
+      info = read_carried_machine_json(key)
+      return info if info
+
+      read_file(File.join(machine.profile, path))
+    end
+
+    def read_carried_machine_json(key)
+      json = mc.read_file(File.join(machine.profile, 'machine.json'))
+      parsed = JSON.parse(json)
+      parsed[key] if parsed[key]
+    rescue TTY::Command::ExitError, JSON::ParserError
+      nil
+    end
 
+    def read_file(path)
+      mc.read_file(path)
+    rescue TTY::Command::ExitError
       nil
     end
   end

data/lib/confctl/nix/args.rb

@@ -0,0 +1,48 @@
+module ConfCtl
+  class Nix
+    class Args
+      DEFAULT_LEGACY_NAMES = %w[nixpkgs vpsadminos vpsadmin].freeze
+
+      def initialize(settings:, impure: nil, no_update_lock_file: true)
+        @settings = settings || {}
+        @impure_override = impure
+        @no_update_lock_file = no_update_lock_file
+      end
+
+      def impure?
+        return @impure_override unless @impure_override.nil?
+
+        @settings.dig('nix', 'impureEval') == true
+      end
+
+      def legacy_nix_path?
+        @settings.dig('nix', 'legacyNixPath') == true
+      end
+
+      def legacy_names
+        names = @settings.dig('nix', 'legacyNixPathMap')
+        return DEFAULT_LEGACY_NAMES if names.nil?
+
+        names
+      end
+
+      def eval_args
+        base_args
+      end
+
+      def build_args
+        base_args
+      end
+
+      private
+
+      def base_args
+        args = []
+        args << '--impure' if impure?
+        args << '--no-write-lock-file'
+        args << '--no-update-lock-file' if @no_update_lock_file
+        args
+      end
+    end
+  end
+end

data/lib/confctl/nix.rb

@@ -1,450 +1,43 @@
-require 'confctl/utils/file'
-require 'digest'
-require 'etc'
-require 'json'
-require 'securerandom'
-require 'tempfile'
+require 'forwardable'
+require_relative 'config_type'
+require_relative 'nix_legacy'
+require_relative 'nix_flake'
 
 module ConfCtl
   class Nix
+    extend Forwardable
+
     # Create a new instance without access to {ConfCtl::Settings}, i.e. when
     # called outside of cluster configuration directory.
     # @return [Nix]
     def self.stateless(show_trace: false, max_jobs: 'auto')
-      new(show_trace:, max_jobs:)
+      new(show_trace: show_trace, max_jobs: max_jobs)
     end
 
-    include Utils::File
-
     def initialize(conf_dir: nil, show_trace: false, max_jobs: nil, cores: nil)
       @conf_dir = conf_dir || ConfDir.path
-      @show_trace = show_trace
-      @max_jobs = max_jobs || Settings.instance.max_jobs
-      @cores = cores
-      @cmd = SystemCommand.new
-    end
-
-    def confctl_settings
-      out_link = File.join(
-        cache_dir,
-        'build',
-        'settings.json'
-      )
-
-      with_cache(out_link) do
-        with_argument({
-          confDir: conf_dir,
-          build: :confctl
-        }) do |arg|
-          cmd_args = [
-            'nix-build',
-            '--arg', 'jsonArg', arg,
-            '--out-link', out_link,
-            (show_trace ? '--show-trace' : nil),
-            (max_jobs ? ['--max-jobs', max_jobs.to_s] : nil),
-            (cores ? ['--cores', cores.to_s] : nil),
-            ConfCtl.nix_asset('evaluator.nix')
-          ].flatten.compact
-
-          cmd.run(*cmd_args)
-        end
-      end
-
-      demodulify(JSON.parse(File.read(out_link))['confctl'])
-    end
-
-    # Returns an array with options from all confctl modules
-    # @return [Array]
-    def module_options
-      options = nix_instantiate({
-        confDir: conf_dir,
-        build: :moduleOptions
-      })
-    end
-
-    # Returns an array with machine fqdns
-    # @return [Array<String>]
-    def list_machine_fqdns
-      nix_instantiate({
-        confDir: conf_dir,
-        build: :list
-      })['machines']
-    end
-
-    # Return machines and their config in a hash
-    # @return [Hash]
-    def list_machines
-      out_link = File.join(
-        cache_dir,
-        'build',
-        'machine-list.json'
-      )
-
-      with_cache(out_link) do
-        with_argument({
-          confDir: conf_dir,
-          build: :info
-        }, core_swpins: true) do |arg|
-          cmd_args = [
-            'nix-build',
-            '--arg', 'jsonArg', arg,
-            '--out-link', out_link,
-            (show_trace ? '--show-trace' : nil),
-            (max_jobs ? ['--max-jobs', max_jobs.to_s] : nil),
-            (cores ? ['--cores', cores.to_s] : nil),
-            ConfCtl.nix_asset('evaluator.nix')
-          ].flatten.compact
-
-          cmd.run(*cmd_args)
-        end
-      end
-
-      demodulify(JSON.parse(File.read(out_link)))
-    end
-
-    def list_swpins_channels
-      nix_instantiate({
-        confDir: conf_dir,
-        build: :listSwpinsChannels
-      })
-    end
-
-    # Evaluate swpins for host
-    # @return [Hash]
-    def eval_core_swpins
-      with_argument({
-        confDir: conf_dir,
-        build: :evalCoreSwpins
-      }) do |arg|
-        out_link = File.join(
-          cache_dir,
-          'build',
-          'core.swpins'
-        )
-
-        cmd_args = [
-          'nix-build',
-          '--arg', 'jsonArg', arg,
-          '--out-link', out_link,
-          (show_trace ? '--show-trace' : nil),
-          (max_jobs ? ['--max-jobs', max_jobs.to_s] : nil),
-          (cores ? ['--cores', cores.to_s] : nil),
-          ConfCtl.nix_asset('evaluator.nix')
-        ].flatten.compact
-
-        out, = cmd.run(*cmd_args).stdout
-
-        JSON.parse(File.read(out.strip))
-      end
-    end
-
-    # Evaluate swpins for hosts
-    # @param hosts [Array<String>]
-    # @return [Hash] host => swpins
-    def eval_host_swpins(hosts)
-      with_argument({
-        confDir: conf_dir,
-        build: :evalHostSwpins,
-        machines: hosts
-      }, core_swpins: true) do |arg|
-        out_link = File.join(
-          cache_dir,
-          'build',
-          "#{Digest::SHA256.hexdigest(hosts.join(','))[0..11]}.swpins"
-        )
-
-        cmd_args = [
-          'nix-build',
-          '--arg', 'jsonArg', arg,
-          '--out-link', out_link,
-          (show_trace ? '--show-trace' : nil),
-          (max_jobs ? ['--max-jobs', max_jobs.to_s] : nil),
-          (cores ? ['--cores', cores.to_s] : nil),
-          ConfCtl.nix_asset('evaluator.nix')
-        ].flatten.compact
-
-        out, = cmd.run(*cmd_args)
-
-        JSON.parse(File.read(out.strip))
-      end
-    end
-
-    # Build config.system.build.toplevel for selected hosts
-    #
-    # @param hosts [Array<Machine>]
-    # @param swpin_paths [Hash]
-    # @param host_swpin_specs [Hash]
-    # @param time [Time]
-    #
-    # @yieldparam type [:build, :fetch]
-    # @yieldparam progress [Integer]
-    # @yieldparam total [Integer]
-    # @yieldparam path [String]
-    #
-    # @return [Hash<String, Generation::Build>]
-    def build_attributes(hosts: [], swpin_paths: {}, host_swpin_specs: {}, time: nil, &block)
-      with_argument({
-        confDir: conf_dir,
-        build: :toplevel,
-        machines: hosts
-      }) do |arg|
-        time ||= Time.now
-        ret_generations = {}
-        out_link = File.join(cache_dir, 'build', "#{SecureRandom.hex(4)}.build")
-
-        cmd_args = [
-          '--arg', 'jsonArg', arg,
-          '--out-link', out_link,
-          (show_trace ? '--show-trace' : nil),
-          (max_jobs ? ['--max-jobs', max_jobs.to_s] : nil),
-          (cores ? ['--cores', cores.to_s] : nil),
-          ConfCtl.nix_asset('evaluator.nix')
-        ].flatten.compact
-
-        nb = NixBuild.new(cmd_args, swpin_paths)
-        nb.run(&block)
-
-        begin
-          host_results = JSON.parse(File.read(out_link))
-          host_results.each do |host, result|
-            host_generations = Generation::BuildList.new(host)
-            generation = host_generations.find(result['attribute'], swpin_paths)
-
-            if generation.nil?
-              generation = Generation::Build.new(host)
-              generation.create(
-                result['attribute'],
-                result['autoRollback'],
-                swpin_paths,
-                host_swpin_specs[host],
-                date: time
-              )
-              generation.save
-            end
-
-            host_generations.current = generation
-            ret_generations[host] = generation
-          end
-        ensure
-          unlink_if_exists(out_link)
-        end
-
-        ret_generations
-      end
-    end
-
-    # @param machine [Machine]
-    # @param paths [Array<String>]
-    #
-    # @yieldparam progress [Integer]
-    # @yieldparam total [Integer]
-    # @yieldparam path [String]
-    #
-    # @return [Boolean]
-    def copy(machine, paths, &)
-      if machine.localhost?
-        true
-      elsif machine.carried?
-        cp = NixCopy.new(machine.carrier_machine.target_host, paths)
-        cp.run!(&).success?
-      else
-        cp = NixCopy.new(machine.target_host, paths)
-        cp.run!(&).success?
-      end
-    end
-
-    # @param machine [Machine]
-    # @param generation [Generation::Build]
-    # @param action [String]
-    # @return [Boolean]
-    def activate(machine, generation, action)
-      args = [File.join(generation.toplevel, 'bin/switch-to-configuration'), action]
-
-      MachineControl.new(machine).execute!(*args).success?
-    end
-
-    # @param machine [Machine]
-    # @param generation [Generation::Build]
-    # @param action [String]
-    # @return [Boolean]
-    def activate_with_rollback(machine, generation, action)
-      check_file = File.join('/run', "confctl-confirm-#{SecureRandom.hex(3)}")
-      timeout = machine['autoRollback']['timeout']
-      logger = NullLogger.new
-
-      args = [
-        generation.auto_rollback,
-        '-t', timeout,
-        generation.toplevel,
-        action,
-        check_file
-      ]
-
-      activation_success = nil
-
-      activation_thread = Thread.new do
-        activation_success = MachineControl.new(machine).execute!(*args).success?
-      end
-
-      # Wait for the configuration to be switched
-      t = Time.now
-
-      loop do
-        out, = MachineControl.new(machine, logger:).execute!('cat', check_file, '2>/dev/null')
-        stripped = out.strip
-        break if stripped == 'switched' || ((t + timeout + 10) < Time.now && stripped != 'switching')
-
-        sleep(1)
-      end
-
-      # Confirm it
-      10.times do
-        break if MachineControl.new(machine, logger:).execute!('sh', '-c', "'echo confirmed > #{check_file}'").success?
-      end
-
-      activation_thread.join
-      activation_success
-    end
-
-    # @param machine [Machine]
-    # @param toplevel [String]
-    # @return [Boolean]
-    def set_profile(machine, toplevel)
-      args = [
-        'nix-env',
-        '-p', machine.profile,
-        '--set', toplevel
-      ]
-
-      MachineControl.new(machine).execute!(*args).success?
-    end
-
-    # @param machine [Machine]
-    # @param toplevel [String]
-    # @return [Boolean]
-    def set_carried_profile(machine, toplevel)
-      args = [
-        'carrier-env',
-        '-p', machine.profile,
-        '--set', toplevel
-      ]
-
-      MachineControl.new(machine.carrier_machine).execute!(*args).success?
-    end
-
-    # @param packages [Array<String>]
-    # @param command [String]
-    # @return [Boolean]
-    def run_command_in_shell(packages: [], command: nil)
-      args = ['nix-shell']
-
-      if packages.any?
-        args << '-p'
-        args.concat(packages)
-      end
-
-      args << '--command'
-      args << command
-
-      cmd.run!(*args, env: { 'shellHook' => nil }).success?
-    end
-
-    # @param machine [Machine]
-    # @yieldparam progress [NixCollectGarbage::Progress]
-    # @return [Boolean]
-    def collect_garbage(machine, &)
-      gc = NixCollectGarbage.new(machine)
-      gc.run!(&).success?
-    end
-
-    protected
-
-    attr_reader :conf_dir, :show_trace, :max_jobs, :cores, :cmd
-
-    # Execute block only if `out_link` does not exist or conf dir has changed
-    # @param out_link [String] out link path
-    def with_cache(out_link)
-      unchanged = false
-
-      if File.exist?(out_link)
-        unchanged = ConfDir.unchanged?
-
-        if unchanged
-          cache_mtime = ConfDir.state_mtime
-
-          if cache_mtime
-            begin
-              st = File.lstat(out_link)
-            rescue Errno::ENOENT
-              # pass
-            else
-              if st.mtime > cache_mtime
-                Logger.instance << "Using #{out_link}\n"
-                return
-              end
-            end
-          end
-        end
-      end
-
-      Logger.instance << "Building #{out_link}\n"
-
-      unless unchanged
-        Logger.instance << "Updating configuration cache\n"
-        ConfDir.update_state
-      end
-      yield
-    end
-
-    # @param hash [Hash]
-    # @param core_swpins [Boolean]
-    # @yieldparam file [String]
-    def with_argument(hash, core_swpins: false)
-      if core_swpins
-        paths = Swpins::Core.get.pre_evaluated_store_paths
-        hash[:coreSwpins] = paths if paths
-      end
-
-      f = Tempfile.new('confctl')
-      f.puts(hash.to_json)
-      f.close
-      yield(f.path)
-    ensure
-      f.unlink
-    end
-
-    def nix_instantiate(hash, **opts)
-      with_argument(hash, **opts) do |arg|
-        cmd_args = [
-          'nix-instantiate',
-          '--eval',
-          '--json',
-          '--strict',
-          '--read-write-mode',
-          '--arg', 'jsonArg', arg,
-          (show_trace ? '--show-trace' : nil),
-          (max_jobs ? ['--max-jobs', max_jobs.to_s] : nil),
-          (cores ? ['--cores', cores.to_s] : nil),
-          ConfCtl.nix_asset('evaluator.nix')
-        ].flatten.compact
-
-        out, = cmd.run(*cmd_args).stdout
-
-        demodulify(JSON.parse(out))
-      end
-    end
-
-    def demodulify(value)
-      if value.is_a?(Array)
-        value.each { |item| demodulify(item) }
-      elsif value.is_a?(Hash)
-        value.delete('_module')
-        value.each_value { |v| demodulify(v) }
-      end
-    end
-
-    def cache_dir
-      ConfDir.cache_dir
-    end
+      impl_klass = ConfigType.flake?(@conf_dir) ? NixFlake : NixLegacy
+      @impl = impl_klass.new(conf_dir: @conf_dir, show_trace: show_trace, max_jobs: max_jobs, cores: cores)
+    end
+
+    def_delegators :@impl,
+                   :confctl_settings,
+                   :module_options,
+                   :list_machine_fqdns,
+                   :list_machines,
+                   :build_attributes,
+                   :copy,
+                   :activate,
+                   :activate_with_rollback,
+                   :set_profile,
+                   :set_carried_profile,
+                   :run_command_in_shell,
+                   :collect_garbage,
+                   :list_swpins_channels,
+                   :eval_core_swpins,
+                   :eval_host_swpins,
+                   :eval_inputs_info,
+                   :eval_inputs,
+                   :eval_json
   end
 end