confctl 1.0.0

data/lib/confctl/cli/command.rb

@@ -0,0 +1,206 @@
+require 'gli'
+require 'rainbow'
+
+module ConfCtl::Cli
+  class Command
+    def self.run(gli_cmd, klass, method)
+      proc do |global_opts, opts, args|
+        log = ConfCtl::Logger.instance
+        log.open(gli_cmd.name_for_help.join('-'))
+        log.cli(
+          gli_cmd.name_for_help,
+          global_opts,
+          opts,
+          args
+        )
+
+        cmd = klass.new(global_opts, opts, args)
+        cmd.run_method(method)
+
+        if log.keep?
+          log.close
+        else
+          log.close_and_unlink
+        end
+      end
+    end
+
+    attr_reader :gopts, :opts, :args
+
+    def initialize(global_opts, opts, args)
+      @gopts = global_opts
+      @opts = opts
+      @args = args
+      @use_color = determine_color
+      @use_pager = determine_pager
+    end
+
+    # @param v [Array] list of required arguments
+    # @param optional [Array] list of optional arguments
+    # @param strict [Boolean] do not allow more arguments than specified
+    def require_args!(*required, optional: [], strict: true)
+      if args.count < required.count
+        arg = required[args.count]
+        raise GLI::BadCommandLine, "missing argument <#{arg}>"
+
+      elsif strict && args.count > (required.count + optional.count)
+        unknown = args[(required.count + optional.count)..]
+
+        msg = ''
+
+        msg << if unknown.count > 1
+                 'unknown arguments: '
+               else
+                 'unknown argument: '
+               end
+
+        msg << unknown.join(' ')
+
+        msg << ' (note that options must come before arguments)' if unknown.detect { |v| v.start_with?('-') }
+
+        raise GLI::BadCommandLine, msg
+      end
+    end
+
+    def use_color?
+      @use_color
+    end
+
+    def use_pager?
+      @use_pager
+    end
+
+    def ask_confirmation(always: false)
+      return true if !always && opts[:yes]
+
+      yield if block_given?
+
+      loop do
+        $stdout.write("\nContinue? [y/N]: ")
+        $stdout.flush
+
+        case $stdin.readline.strip.downcase
+        when 'y'
+          puts
+          return true
+        when 'n'
+          puts
+          return false
+        end
+      end
+    end
+
+    def ask_confirmation!(...)
+      raise 'Aborted' unless ask_confirmation(...)
+    end
+
+    # @param options [Hash<String, String>] key => description
+    # @param default [String] default option key
+    # @return [String] selection option key
+    def ask_action(options:, default:)
+      yield if block_given?
+
+      loop do
+        $stdout.puts("\nOptions:\n")
+
+        options.each do |key, desc|
+          $stdout.puts("  [#{key}] #{desc}")
+        end
+
+        keys = options.keys.map do |k|
+          if k == default
+            k.upcase
+          else
+            k
+          end
+        end.join('/')
+
+        $stdout.write("\nAction: [#{keys}]: ")
+        $stdout.flush
+
+        answer = $stdin.readline.strip.downcase
+
+        if options.has_key?(answer)
+          puts
+          return answer
+        end
+      end
+    end
+
+    def run_method(method)
+      self.method(method).call
+    end
+
+    protected
+
+    def run_command(klass, method)
+      c = klass.new(gopts, opts, args)
+      c.run_method(method)
+    end
+
+    def determine_color
+      case gopts[:color]
+      when 'always'
+        Rainbow.enabled = true
+        true
+      when 'never'
+        Rainbow.enabled = false
+        false
+      when 'auto'
+        Rainbow.enabled
+      end
+    end
+
+    def determine_pager
+      ENV.fetch('PAGER', nil) && ENV['PAGER'].strip != ''
+    end
+
+    def select_machines(pattern)
+      machines = ConfCtl::MachineList.new(show_trace: opts['show-trace'])
+
+      attr_filters = AttrFilters.new(opts[:attr])
+      tag_filters = TagFilters.new(opts[:tag])
+
+      machines.select do |host, d|
+        (pattern.nil? || ConfCtl::Pattern.match?(pattern, host)) \
+          && attr_filters.pass?(d) \
+          && tag_filters.pass?(d)
+      end
+    end
+
+    def select_machines_with_managed(pattern)
+      selected = select_machines(pattern)
+
+      case opts[:managed]
+      when 'n', 'no'
+        selected.unmanaged
+      when 'a', 'all'
+        selected
+      else
+        selected.managed
+      end
+    end
+
+    def list_machines(machines, prepend_cols: [])
+      cols =
+        if opts[:output]
+          opts[:output].split(',')
+        else
+          ConfCtl::Settings.instance.list_columns
+        end
+
+      cols = prepend_cols + cols if prepend_cols
+
+      rows = machines.map do |_host, machine|
+        cols.to_h { |c| [c, machine[c]] }
+      end
+
+      OutputFormatter.print(
+        rows,
+        cols,
+        header: !opts['hide-header'],
+        layout: :columns
+      )
+    end
+  end
+end

data/lib/confctl/cli/configuration.rb

@@ -0,0 +1,296 @@
+require 'fileutils'
+require 'securerandom'
+
+module ConfCtl::Cli
+  class Configuration < Command
+    DIR_MODE = 0o755
+    FILE_MODE = 0o644
+
+    def init
+      dir = File.realpath(Dir.pwd)
+
+      Dir.entries(dir).each do |v|
+        raise 'init must be called in an empty directory' unless %w[. .. shell.nix .confctl .gems
+                                                                    .gitignore].include?(v)
+      end
+
+      mkdir('cluster')
+
+      mkfile('cluster/module-list.nix') do |f|
+        f.puts(<<~END
+          (import ./cluster.nix) ++ [
+            # Place for custom modules
+          ]
+        END
+              )
+      end
+
+      mkfile('cluster/cluster.nix') do |f|
+        f.puts(<<~END
+          # This file is generated by confctl, changes will be lost
+          []
+        END
+              )
+      end
+
+      mkdir('configs')
+      mkfile('configs/confctl.nix') do |f|
+        f.puts(<<~END
+          { config, ... }:
+          {
+            confctl = {
+              # listColumns = {
+              #   "name"
+              #   "spin"
+              #   "host.fqdn"
+              # };
+            };
+          }
+        END
+              )
+      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|
+        f.puts(<<~END
+          { lib }:
+          {
+            # Place to load custom data sets
+            sshKeys = import ./ssh-keys.nix;
+          }
+        END
+              )
+      end
+
+      mkfile('data/ssh-keys.nix') do |f|
+        f.puts(<<~END
+          rec {
+            admins = [
+              # someone
+            ];
+
+            someone = "...ssh public key...";
+          }
+        END
+              )
+      end
+
+      mkdir('environments')
+
+      mkfile('environments/base.nix') do |f|
+        f.puts(<<~END
+          { config, pkgs, confData, ... }:
+          {
+            time.timeZone = "Europe/Amsterdam";
+
+            services.openssh.enable = true;
+
+            environment.systemPackages = with pkgs; [
+              vim
+              screen
+            ];
+
+            users.users.root.openssh.authorizedKeys.keys = with confData.sshKeys; admins;
+          }
+        END
+              )
+      end
+
+      mkdir('modules')
+      mkfile('modules/module-list.nix') do |f|
+        f.puts(<<~END
+          rec {
+            shared = [
+              # Modules not dependent on spin
+            ];
+
+            nixos = shared ++ [
+              # Modules only for NixOS
+            ];
+
+            vpsadminos = shared ++ [
+              # Modules only for vpsAdminOS
+            ];
+          }
+        END
+              )
+      end
+
+      mkdir('swpins')
+      mkdir('swpins/channels')
+    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|
+        f.puts(<<~END
+          { config, ... }:
+          {
+            cluster."#{name}" = {
+              spin = "nixos";
+              swpins.channels = [ "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
+    end
+
+    protected
+
+    def discover_dir(dir_path, rel_path = nil)
+      ret = []
+
+      Dir.entries(dir_path).each do |v|
+        entry_abs_path = File.join(dir_path, v)
+        next if %w[. ..].include?(v) || !File.directory?(entry_abs_path)
+
+        entry_rel_path = File.join(*[rel_path, v].compact)
+
+        if File.exist?(File.join(entry_abs_path, 'module.nix')) \
+           && File.exist?(File.join(entry_abs_path, 'config.nix'))
+          ret << entry_rel_path
+        end
+
+        ret.concat(discover_dir(entry_abs_path, entry_rel_path))
+      end
+
+      ret
+    end
+
+    def mkdir(name)
+      puts "mkdir #{name}"
+      Dir.mkdir(name, DIR_MODE)
+    end
+
+    def mkdir_p(name)
+      puts "mkdir #{name}"
+      FileUtils.mkdir_p(name, mode: DIR_MODE)
+    end
+
+    def mkfile(name)
+      puts "mkfile #{name}"
+      f = File.open(name, 'w', FILE_MODE)
+      yield(f)
+      f.close
+    end
+
+    def replace_file(name, &)
+      puts "replace #{name}"
+      replacement = "#{name}.new-#{SecureRandom.hex(3)}"
+
+      File.open(replacement, 'w', FILE_MODE, &)
+
+      File.rename(replacement, name)
+    end
+
+    def mv(old_name, new_name)
+      puts "mv #{old_name} #{new_name}"
+      File.rename(old_name, new_name)
+    end
+  end
+end

data/lib/confctl/cli/gen_data.rb

@@ -0,0 +1,97 @@
+require 'highline/import'
+require 'vpsfree/client'
+require 'confctl/conf_dir'
+
+module ConfCtl::Cli
+  class GenData < Command
+    def vpsadmin_all
+      vpsadmin_containers
+      vpsadmin_network
+    end
+
+    def vpsadmin_containers
+      api = vpsadmin_client
+
+      machines = ConfCtl::MachineList.new
+      data = {}
+
+      machines.each_value do |m|
+        next if m['container'].nil?
+
+        ct = api.vps.show(
+          m['container.id'],
+          meta: { includes: 'node__location__environment' }
+        )
+
+        ct_fqdn = [
+          m['host.name'],
+          m['host.location'],
+          m['host.domain']
+        ].compact.join('.')
+
+        data[ct_fqdn] = {
+          node: {
+            id: ct.node.id,
+            name: ct.node.name,
+            location: ct.node.location.domain,
+            domain: ct.node.location.environment.domain,
+            fqdn: "#{ct.node.domain_name}.#{ct.node.location.environment.domain}"
+          }
+        }
+      end
+
+      update_file('vpsadmin/containers.nix') do |f|
+        f.puts(ConfCtl::NixFormat.to_nix(data))
+      end
+    end
+
+    def vpsadmin_network
+      vpsadmin_network_containers
+    end
+
+    def vpsadmin_network_containers
+      api = vpsadmin_client
+      networks = api.network.list
+      data = {}
+
+      [4, 6].each do |ip_v|
+        data["ipv#{ip_v}"] = networks.select { |net| net.ip_version == ip_v }.map do |net|
+          { address: net.address, prefix: net.prefix }
+        end
+      end
+
+      update_file('vpsadmin/networks/containers.nix') do |f|
+        f.puts(ConfCtl::NixFormat.to_nix(data))
+      end
+    end
+
+    protected
+
+    def vpsadmin_client
+      return @vpsadmin_client if @vpsadmin_client
+
+      @vpsadmin_client = VpsFree::Client.new
+
+      user = ask('User name: ') { |q| q.default = nil }.to_s
+      password = ask('Password: ') do |q|
+        q.default = nil
+        q.echo = false
+      end.to_s
+
+      @vpsadmin_client.authenticate(:basic, user:, password:)
+      @vpsadmin_client
+    end
+
+    def update_file(relpath, &)
+      abs = File.join(data_dir, relpath)
+      tmp = "#{abs}.new"
+
+      File.open(tmp, 'w', &)
+      File.rename(tmp, abs)
+    end
+
+    def data_dir
+      @data_dir ||= File.join(ConfCtl::ConfDir.path, 'data')
+    end
+  end
+end