confctl 2.2.2 → 3.0.0

data/lib/confctl/cli/command.rb

@@ -139,6 +139,11 @@ module ConfCtl::Cli
     end
 
     def determine_color
+      if gopts[:color] == 'auto' && ConfCtl::Ui.no_color?
+        Rainbow.enabled = false
+        return false
+      end
+
       case gopts[:color]
       when 'always'
         Rainbow.enabled = true
@@ -152,7 +157,7 @@ module ConfCtl::Cli
     end
 
     def determine_pager
-      ENV.fetch('PAGER', nil) && ENV['PAGER'].strip != ''
+      ConfCtl::Ui.tty? && ENV.fetch('PAGER', nil) && ENV['PAGER'].strip != ''
     end
 
     def select_machines(pattern)
@@ -161,8 +166,25 @@ module ConfCtl::Cli
       attr_filters = AttrFilters.new(opts[:attr])
       tag_filters = TagFilters.new(opts[:tag])
 
+      if pattern.nil?
+        return machines.select do |_host, d|
+          attr_filters.pass?(d) && tag_filters.pass?(d)
+        end
+      end
+
+      if machines[pattern]
+        return machines.select do |host, d|
+          host == pattern && attr_filters.pass?(d) && tag_filters.pass?(d)
+        end
+      end
+
+      key_matches = machines.select do |_host, d|
+        d['key'] == pattern && attr_filters.pass?(d) && tag_filters.pass?(d)
+      end
+      return key_matches unless key_matches.empty?
+
       machines.select do |host, d|
-        (pattern.nil? || ConfCtl::Pattern.match?(pattern, host)) \
+        ConfCtl::Pattern.match?(pattern, host) \
           && attr_filters.pass?(d) \
           && tag_filters.pass?(d)
       end

data/lib/confctl/cli/configuration.rb

@@ -17,6 +17,106 @@ module ConfCtl::Cli
                                                                     .gitignore].include?(v)
       end
 
+      init_common
+
+      if swpins_mode?
+        init_swpins
+      else
+        init_flake
+      end
+    end
+
+    def add
+      require_args!('name')
+
+      name = args[0]
+      dir = File.join('cluster', name)
+      depth = name.count('/')
+
+      raise "#{dir} already exists" if Dir.exist?(dir)
+
+      mkdir_p(dir)
+
+      mkfile(File.join(dir, 'module.nix')) do |f|
+        channels_attr = flake_config? ? 'inputs.channels' : 'swpins.channels'
+        f.puts(<<~END
+          { config, ... }:
+          {
+            cluster."#{name}" = {
+              spin = "nixos";
+              #{channels_attr} = [ "nixos-unstable" ];
+              host = { name = "machine"; domain = "example.com"; };
+            };
+          }
+        END
+              )
+      end
+
+      mkfile(File.join(dir, 'config.nix')) do |f|
+        f.puts(<<~END
+          { config, pkgs, lib, ... }:
+          {
+            imports = [
+              #{'../' * (depth + 2)}environments/base.nix
+            ];
+
+            # ... standard NixOS configuration ...
+
+            networking.hostName = "#{name.gsub('/', '-')}";
+          }
+        END
+              )
+      end
+
+      rediscover
+    end
+
+    def rename
+      require_args!('old-name', 'new-name')
+
+      src = args[0]
+      dst = args[1]
+
+      src_path = File.join('cluster', src)
+      dst_path = File.join('cluster', dst)
+
+      if !Dir.exist?(src_path)
+        raise "'#{src}' not found"
+      elsif Dir.exist?(dst_path)
+        raise "'#{dst}' already exists"
+      end
+
+      dst_dir = File.dirname(dst_path)
+      mkdir_p(dst_dir)
+      mv(src_path, dst_path)
+
+      src_swpins = File.join('swpins/cluster', "#{src.gsub('/', ':')}.json")
+      dst_swpins = File.join('swpins/cluster', "#{dst.gsub('/', ':')}.json")
+      mv(src_swpins, dst_swpins) if File.exist?(src_swpins)
+
+      rediscover
+    end
+
+    def rediscover
+      hosts = discover_dir('cluster').sort
+
+      replace_file('cluster/cluster.nix') do |f|
+        f.puts('# This file is generated by confctl, changes will be lost')
+        f.puts('[')
+
+        hosts.each do |host|
+          f.puts("  ./#{host}/module.nix")
+        end
+
+        f.puts(']')
+      end
+
+      ConfCtl::Hook.call(:configuration_rediscover)
+    end
+
+    protected
+
+    def init_common
       mkdir('cluster')
 
       mkfile('cluster/module-list.nix') do |f|
@@ -53,40 +153,6 @@ module ConfCtl::Cli
               )
       end
 
-      mkfile('configs/swpins.nix') do |f|
-        f.puts(<<~END
-          { config, ... }:
-          let
-            nixpkgsBranch = branch: {
-              type = "git-rev";
-
-              git-rev = {
-                url = "https://github.com/NixOS/nixpkgs";
-                update.ref = "refs/heads/${branch}";
-              };
-            };
-
-            vpsadminosBranch = branch: {
-              type = "git-rev";
-
-              git-rev = {
-                url = "https://github.com/vpsfreecz/vpsadminos";
-                update.ref = "refs/heads/${branch}";
-              };
-            };
-          in {
-            confctl.swpins.channels = {
-              nixos-unstable = { nixpkgs = nixpkgsBranch "nixos-unstable"; };
-
-              # nixos-stable = { nixpkgs = nixpkgsBranch "nixos-20.09"; };
-
-              # vpsadminos-staging = { vpsadminos = vpsadminosBranch "staging"; };
-            };
-          }
-        END
-              )
-      end
-
       mkdir('data')
 
       mkfile('data/default.nix') do |f|
@@ -153,100 +219,99 @@ module ConfCtl::Cli
         END
               )
       end
-
-      mkdir('swpins')
-      mkdir('swpins/channels')
     end
 
-    def add
-      require_args!('name')
+    def init_swpins
+      mkfile('configs/swpins.nix') do |f|
+        f.puts(<<~END
+          { config, ... }:
+          let
+            nixpkgsBranch = branch: {
+              type = "git-rev";
 
-      name = args[0]
-      dir = File.join('cluster', name)
-      depth = name.count('/')
+              git-rev = {
+                url = "https://github.com/NixOS/nixpkgs";
+                update.ref = "refs/heads/${branch}";
+              };
+            };
 
-      raise "#{dir} already exists" if Dir.exist?(dir)
+            vpsadminosBranch = branch: {
+              type = "git-rev";
 
-      mkdir_p(dir)
+              git-rev = {
+                url = "https://github.com/vpsfreecz/vpsadminos";
+                update.ref = "refs/heads/${branch}";
+              };
+            };
+          in {
+            confctl.swpins.channels = {
+              nixos-unstable = { nixpkgs = nixpkgsBranch "nixos-unstable"; };
 
-      mkfile(File.join(dir, 'module.nix')) do |f|
-        f.puts(<<~END
-          { config, ... }:
-          {
-            cluster."#{name}" = {
-              spin = "nixos";
-              swpins.channels = [ "nixos-unstable" ];
-              host = { name = "machine"; domain = "example.com"; };
+              # nixos-stable = { nixpkgs = nixpkgsBranch "nixos-20.09"; };
+
+              # vpsadminos-staging = { vpsadminos = vpsadminosBranch "staging"; };
             };
           }
         END
               )
       end
 
-      mkfile(File.join(dir, 'config.nix')) do |f|
+      mkdir('swpins')
+      mkdir('swpins/channels')
+    end
+
+    def init_flake
+      mkfile('flake.nix') do |f|
         f.puts(<<~END
-          { config, pkgs, lib, ... }:
           {
-            imports = [
-              #{'../' * (depth + 2)}environments/base.nix
-            ];
+            description = "confctl configuration (flake)";
 
-            # ... standard NixOS configuration ...
+            inputs = {
+              confctl.url = "github:vpsfreecz/confctl";
+              nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
 
-            networking.hostName = "#{name.gsub('/', '-')}";
+              # vpsadminos.url = "github:vpsfreecz/vpsadminos/staging";
+              # vpsadminos.inputs.nixpkgs.follows = "nixpkgs";
+            };
+
+            outputs = inputs@{ self, confctl, ... }:
+              let
+                channels = {
+                  nixos-unstable = { nixpkgs = "nixpkgs"; };
+
+                  # vpsadminos = {
+                  #   nixpkgs = "nixpkgs";
+                  #   vpsadminos = "vpsadminos";
+                  # };
+                };
+
+                confctlOutputs = confctl.lib.mkConfctlOutputs {
+                  confDir = ./.;
+                  inherit inputs channels;
+                };
+              in
+              {
+                confctl = confctlOutputs;
+
+                devShells.x86_64-linux.default = confctl.lib.mkConfigDevShell {
+                  system = "x86_64-linux";
+                  mode = "minimal";
+                };
+              };
           }
         END
               )
       end
-
-      rediscover
     end
 
-    def rename
-      require_args!('old-name', 'new-name')
-
-      src = args[0]
-      dst = args[1]
-
-      src_path = File.join('cluster', src)
-      dst_path = File.join('cluster', dst)
-
-      if !Dir.exist?(src_path)
-        raise "'#{src}' not found"
-      elsif Dir.exist?(dst_path)
-        raise "'#{dst}' already exists"
-      end
-
-      dst_dir = File.dirname(dst_path)
-      mkdir_p(dst_dir)
-      mv(src_path, dst_path)
-
-      src_swpins = File.join('swpins/cluster', "#{src.gsub('/', ':')}.json")
-      dst_swpins = File.join('swpins/cluster', "#{dst.gsub('/', ':')}.json")
-      mv(src_swpins, dst_swpins) if File.exist?(src_swpins)
-
-      rediscover
+    def swpins_mode?
+      opts[:swpins] || opts[:legacy]
     end
 
-    def rediscover
-      hosts = discover_dir('cluster').sort
-
-      replace_file('cluster/cluster.nix') do |f|
-        f.puts('# This file is generated by confctl, changes will be lost')
-        f.puts('[')
-
-        hosts.each do |host|
-          f.puts("  ./#{host}/module.nix")
-        end
-
-        f.puts(']')
-      end
-
-      ConfCtl::Hook.call(:configuration_rediscover)
+    def flake_config?
+      ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
     end
 
-    protected
-
     def discover_dir(dir_path, rel_path = nil)
       ret = []
 
@@ -277,11 +342,11 @@ module ConfCtl::Cli
       FileUtils.mkdir_p(name, mode: DIR_MODE)
     end
 
-    def mkfile(name)
+    def mkfile(name, &block)
       puts "mkfile #{name}"
-      f = File.open(name, 'w', FILE_MODE)
-      yield(f)
-      f.close
+      File.open(name, 'w', FILE_MODE) do |f|
+        block.call(f)
+      end
     end
 
     def replace_file(name, &)

data/lib/confctl/cli/generation.rb

@@ -273,6 +273,30 @@ module ConfCtl::Cli
           Rainbow('Collecting garbage on ').bright + Rainbow(machines.first.to_s).yellow
         end
 
+      unless ConfCtl::Ui.tty?
+        puts header
+
+        executor = ConfCtl::ParallelExecutor.new(opts['max-concurrent-gc'])
+
+        machines.each do |host, machine|
+          executor.add do
+            end_stats = nil
+            ret = nix.collect_garbage(machine) do |progress|
+              puts "#{host}> #{progress}"
+              end_stats = progress.line if /^\d+ store paths deleted/ =~ progress.line
+            end
+
+            puts(ret ? "#{host}: #{end_stats || 'done'}" : "#{host}: error occurred")
+            ret ? nil : host
+          end
+        end
+
+        failed = executor.run.compact
+        raise "Gargabe collection failed on: #{failed.join(', ')}" if failed.any?
+
+        return
+      end
+
       LogView.open(
         header: "#{header}\n",
         title: Rainbow('Live view').bright,
@@ -331,11 +355,28 @@ module ConfCtl::Cli
 
     def list_generations(gens)
       swpin_names = []
+      input_roles = []
 
       gens.each do |gen|
         gen.swpin_names.each do |name|
           swpin_names << name unless swpin_names.include?(name)
         end
+
+        next unless flake_generation?(gen)
+
+        inputs_info = normalized_inputs_info(gen)
+        next if inputs_info.nil? || inputs_info.empty?
+
+        inputs_info.each_key do |role|
+          input_roles << role unless input_roles.include?(role)
+        end
+      end
+
+      input_column_names = {}
+      input_columns = input_roles.map do |role|
+        name = swpin_names.include?(role) ? "input:#{role}" : role
+        input_column_names[role] = name
+        { name: name, label: role.to_s.upcase }
       end
 
       rows = gens.map do |gen|
@@ -352,15 +393,38 @@ module ConfCtl::Cli
           row[name] = spec.version
         end
 
+        if flake_generation?(gen)
+          inputs_info = normalized_inputs_info(gen) || {}
+          input_roles.each do |role|
+            row[input_column_names[role]] = inputs_short_rev(inputs_info[role])
+          end
+        end
+
         row
       end
 
       OutputFormatter.print(
         rows,
-        %w[host name id presence current kernel] + swpin_names,
+        %w[host name id presence current kernel] + swpin_names + input_columns,
         layout: :columns,
         sort: %w[name host]
       )
     end
+
+    def normalized_inputs_info(gen)
+      return nil unless gen.respond_to?(:inputs_info)
+
+      ConfCtl::InputsInfo.normalize(gen.inputs_info)
+    end
+
+    def inputs_short_rev(info)
+      return nil unless info.is_a?(Hash)
+
+      info['shortRev'] || (info['rev'] && info['rev'][0, 8])
+    end
+
+    def flake_generation?(gen)
+      gen.respond_to?(:flakes_mode?) && gen.flakes_mode?
+    end
   end
 end

data/lib/confctl/cli/inputs/channels.rb

@@ -0,0 +1,190 @@
+require 'confctl/cli/command'
+require 'confctl/config_type'
+require 'confctl/flake_lock'
+require 'confctl/nix'
+require 'confctl/pattern'
+require 'confctl/inputs/setter'
+require 'confctl/inputs/updater'
+
+module ConfCtl::Cli
+  class Inputs::Channels < Command
+    def list
+      ensure_flake_config!
+
+      raise GLI::BadCommandLine, 'usage: confctl inputs channel ls [channel-pattern]' if args.length > 1
+
+      conf_dir = ConfCtl::ConfDir.path
+      lock = ConfCtl::FlakeLock.load(File.join(conf_dir, 'flake.lock'))
+      channels = eval_channels
+
+      selected = select_channels(channels.keys, args[0])
+
+      rows = []
+      selected.each do |ch|
+        (channels[ch] || {}).each do |role, input|
+          info = lock.input_info(input)
+          rows << {
+            channel: ch,
+            role: role,
+            input: input,
+            rev: info[:short_rev] || '-',
+            url: info[:url] || '-'
+          }
+        end
+      end
+
+      OutputFormatter.print(rows, %i[channel role input rev url], layout: :columns)
+    end
+
+    def update
+      ensure_flake_config!
+      require_args!('channels', optional: ['role'])
+
+      selector = args[0]
+      role = args[1]
+      role_name = role&.to_s
+
+      channels = eval_channels
+      selected = select_channels(channels.keys, selector)
+      raise ConfCtl::Error, "no channels matched '#{selector}'" if selected.empty?
+
+      targets = selected.flat_map do |ch|
+        mapping = channels[ch] || {}
+        if role_name
+          input = mapping[role] || mapping[role_name]
+          input ? [{ channel: ch, role: role_name, input: input }] : []
+        else
+          mapping.map { |r, input| { channel: ch, role: r.to_s, input: input } }
+        end
+      end
+
+      inputs = targets.map { |t| t[:input] }.uniq
+
+      raise ConfCtl::Error, 'no inputs selected (check role name?)' if inputs.empty?
+
+      ConfCtl::Inputs::Updater.run!(
+        conf_dir: ConfCtl::ConfDir.path,
+        inputs: inputs,
+        commit: opts[:commit],
+        changelog: opts[:changelog],
+        downgrade: opts[:downgrade],
+        editor: opts[:editor]
+      )
+
+      lock = ConfCtl::FlakeLock.load(File.join(ConfCtl::ConfDir.path, 'flake.lock'))
+      targets.each do |t|
+        info = lock.input_info(t[:input])
+        rev = info[:short_rev] || info[:rev] || '-'
+        puts "Updating #{t[:role]} in #{t[:channel]} -> #{rev}"
+      end
+    end
+
+    def set
+      ensure_flake_config!
+      require_args!('channels', 'role', 'rev')
+
+      selector = args[0]
+      role = args[1]
+      rev = args[2]
+
+      channels = eval_channels
+      selected = select_channels(channels.keys, selector)
+      raise ConfCtl::Error, "no channels matched '#{selector}'" if selected.empty?
+
+      role_name = role.to_s
+      targets = selected.filter_map do |ch|
+        mapping = channels[ch] || {}
+        input = mapping[role] || mapping[role_name]
+        input ? { channel: ch, role: role_name, input: input } : nil
+      end
+
+      raise ConfCtl::Error, 'no inputs selected (check role name?)' if targets.empty?
+
+      inputs = targets.map { |t| t[:input] }.uniq
+
+      shared = shared_input_uses(channels, selected, role_name, inputs)
+      if shared.any?
+        msg = build_shared_input_message(shared)
+        raise ConfCtl::Error, "#{msg} (use --allow-shared to proceed)" unless opts[:allow_shared]
+
+        puts "Warning: #{msg}"
+      end
+
+      ConfCtl::Inputs::Setter.run!(
+        conf_dir: ConfCtl::ConfDir.path,
+        inputs: inputs,
+        rev: rev,
+        commit: opts[:commit],
+        changelog: opts[:changelog],
+        downgrade: opts[:downgrade],
+        editor: opts[:editor]
+      )
+
+      lock = ConfCtl::FlakeLock.load(File.join(ConfCtl::ConfDir.path, 'flake.lock'))
+      targets.each do |t|
+        info = lock.input_info(t[:input])
+        resolved_rev = info[:short_rev] || info[:rev] || '-'
+        puts "Configuring #{t[:role]} in #{t[:channel]} -> #{resolved_rev}"
+      end
+    end
+
+    protected
+
+    def ensure_flake_config!
+      return if ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
+
+      raise ConfCtl::Error, 'confctl inputs channel is available only in flake configs'
+    end
+
+    def eval_channels
+      json = ConfCtl::Nix.new.eval_json('.#confctl.channels')
+      json.is_a?(Hash) ? json : {}
+    end
+
+    def select_channels(all, selector)
+      return all.sort if selector.nil?
+
+      if selector.include?('{') || selector.include?(',')
+        names = parse_channel_selectors(selector)
+        return names.select { |n| all.include?(n) }
+      end
+
+      all.select { |n| ConfCtl::Pattern.match?(selector, n) }.sort
+    end
+
+    def parse_channel_selectors(str)
+      s = str.strip
+      s = s[1..-2] if s.start_with?('{') && s.end_with?('}')
+      s.split(',').map(&:strip).reject(&:empty?)
+    end
+
+    def shared_input_uses(channels, selected, role, inputs)
+      requested = {}
+      selected.each { |ch| requested[[ch, role.to_s]] = true }
+      shared = {}
+
+      channels.each do |ch, mapping|
+        (mapping || {}).each do |r, input|
+          next unless inputs.include?(input)
+
+          key = [ch, r.to_s]
+          next if requested[key]
+
+          shared[input] ||= []
+          shared[input] << { channel: ch, role: r.to_s }
+        end
+      end
+
+      shared
+    end
+
+    def build_shared_input_message(shared)
+      details = shared.sort.map do |input, uses|
+        roles = uses.map { |u| "#{u[:channel]}/#{u[:role]}" }.sort.join(', ')
+        "#{input} (also used by #{roles})"
+      end.join('; ')
+
+      "selected input(s) are shared outside the requested channel/role: #{details}"
+    end
+  end
+end