getch 0.1.3 → 0.3.0

data/lib/getch/helpers.rb

@@ -1,71 +1,151 @@
+# frozen_string_literal: true
+
 require 'open-uri'
 require 'open3'
 require 'fileutils'
+require 'nito'
 
-module Helpers
-  def self.efi?
-    Dir.exist? '/sys/firmware/efi/efivars'
-  end
+module Getch
+  module Helpers
+    def self.efi?
+      Dir.exist? '/sys/firmware/efi/efivars'
+    end
+
+    def self.systemd?
+      Dir.exist? "#{OPTIONS[:mountpoint]}/etc/systemd"
+    end
+
+    def self.openrc?
+      File.exist? "#{OPTIONS[:mountpoint]}/etc/conf.d/keymaps"
+    end
+
+    def self.runit?
+      Dir.exist? "#{OPTIONS[:mountpoint]}/etc/runit"
+    end
+
+    def self.grub?
+      File.exist? "#{OPTIONS[:mountpoint]}/etc/default/grub"
+    end
 
-  def self.get_file_online(url, dest)
-    URI.open(url) do |l|
-      File.open(dest, "wb") do |f|
-        f.write(l.read)
+    def self.get_file_online(url, dest)
+      URI.open(url) do |l|
+        File.open(dest, "wb") { |f| f.write(l.read) }
       end
+    rescue Net::OpenTimeout => e
+      abort "DNS error #{e}"
     end
-  end
 
-  def self.exec_or_die(cmd)
-    _, stderr, status = Open3.capture3(cmd)
-    unless status.success?
-      raise "Problem running #{cmd}, stderr was:\n#{stderr}"
+    def self.exec_or_die(cmd)
+      _, stderr, status = Open3.capture3(cmd)
+      unless status.success?
+        abort "Problem running #{cmd}, stderr was:\n#{stderr}"
+      end
     end
-  end
 
-  def self.create_dir(path, perm = 0755)
-    FileUtils.mkdir_p path, mode: perm if ! Dir.exist?(path)
-  end
+    def self.sys(cmd)
+      system(cmd)
+      $?.success? || abort("Error with #{cmd}")
+    end
 
-  def self.add_file(path, content = '')
-    File.write path, content if ! File.exist? path
-  end
+    def self.partuuid(dev)
+      `lsblk -o PARTUUID #{dev}`.match(/\w+-\w+-\w+-\w+-\w+/)
+    end
 
-  def self.mkdir(dir)
-    FileUtils.mkdir_p dir if ! Dir.exist? dir
-  end
+    def self.uuid(dev)
+      Dir.glob('/dev/disk/by-uuid/*').each do |f|
+        if File.readlink(f).match(/#{dev}/)
+          return f.delete_prefix('/dev/disk/by-uuid/')
+        end
+      end
+      Log.new.fatal("UUID on #{dev} is no found")
+    end
 
-  def self.touch(file)
-    File.write file, '' if ! File.exist? file
-  end
+    def self.get_dm(name)
+      Dir.glob('/dev/mapper/*').each do |f|
+        if f =~ /#{name}/ && f != '/dev/mapper/control'
+          return File.readlink(f).tr('../', '')
+        end
+      end
+      Log.new.fatal("Dm for #{name} is no found")
+    end
 
-  def self.grep?(file, regex)
-    is_found = false
-    return is_found if ! File.exist? file
-    File.open(file) do |f|
-      f.each do |line|
-        is_found = true if line.match(regex)
+    # Used by ZFS for the pool creation
+    # sleep is necessary here at least the first time
+    def self.get_id(dev)
+      sleep 3
+      Dir.glob('/dev/disk/by-id/*').each do |f|
+        if File.readlink(f).match(/#{dev}/)
+          return f.delete_prefix('/dev/disk/by-id/')
+        end
       end
+      Log.new.fatal("ID on #{dev} is no found")
     end
-    is_found
-  end
 
-  def self.sys(cmd)
-    system(cmd)
-    unless $?.success?
-      raise "Error with #{cmd}"
+    # https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Base
+    def self.mount_all
+      dest = OPTIONS[:mountpoint]
+      NiTo.mount '--types proc /proc', "#{dest}/proc"
+      ['dev', 'sys', 'run'].each do |d|
+        NiTo.mount '--rbind', "/#{d}", "#{dest}/#{d}"
+        NiTo.mount '--make-rslave', "#{dest}/#{d}"
+      end
     end
-  end
 
-  def self.partuuid(dev)
-    `lsblk -o PARTUUID #{dev}`.match(/[\w]+-[\w]+-[\w]+-[\w]+-[\w]+/)
-  end
+    def self.get_memory
+      mem = nil
+      File.open('/proc/meminfo').each do |l|
+        t = l.split(' ') if l =~ /memtotal/i
+        t && mem = t[1]
+      end
+      mem || Log.new.fatal('get_memory - failed to get memory')
 
-  def self.uuid(dev)
-    `lsblk -do UUID #{dev}`.match(/[\w]+-[\w]+-[\w]+-[\w]+-[\w]+/)
-  end
+      mem += 'K'
+    end
+
+    # get the sector size of a disk
+    def self.get_bs(path)
+      cmd = Getch::Command.new('blockdev', '--getpbsz', path)
+      cmd.res
+    end
 
-  # Used with ZFS for the pool name
-  def self.pool_id(dev)
-    `lsblk -o PARTUUID #{dev}`.delete("\n").delete("PARTUUID").match(/[\w]{5}/)
+    module Void
+      def command_output(args)
+        print " => Exec: #{args}..."
+        cmd = "chroot #{Getch::MOUNTPOINT} /bin/bash -c \"#{args}\""
+        Open3.popen2e(cmd) do |_, stdout_err, wait_thr|
+          puts
+          stdout_err.each { |l| puts l }
+
+          exit_status = wait_thr.value
+          unless exit_status.success?
+            raise "\n[-] Fail cmd #{args} - #{stdout_err}."
+          end
+        end
+      end
+
+      # Used only when need password
+      def chroot(cmd)
+        unless system('chroot', Getch::MOUNTPOINT, '/bin/bash', '-c', cmd)
+          raise "[-] Error with: #{cmd}"
+        end
+      end
+
+      def s_uuid(dev)
+        device = dev.delete_prefix('/dev/')
+        Dir.glob('/dev/disk/by-partuuid/*').each do |f|
+          link = File.readlink(f)
+          return f.delete_prefix('/dev/disk/by-partuuid/') if link.match(/#{device}$/)
+        end
+      end
+
+      def line_fstab(dev, rest)
+        conf = "#{Getch::MOUNTPOINT}/etc/fstab"
+        device = s_uuid(dev)
+        raise "No partuuid for #{dev} #{device}" unless device
+        raise "Bad partuuid for #{dev} #{device}" if device.kind_of? Array
+
+        add_line(conf, "PARTUUID=#{device} #{rest}")
+      end
+    end
   end
 end

data/lib/getch/log.rb

@@ -1,54 +1,119 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module Getch
   class Log
-    def initialize
+
+    WHITE   = "\033[37m"
+    CYAN    = "\033[36m"
+    MAGENTA = "\033[35m"
+    BLUE    = "\033[34m"
+    YELLOW  = "\033[33m"
+    GREEN   = "\033[32m"
+    RED     = "\033[31m"
+    BLACK   = "\033[30m"
+    BOLD    = "\033[1m"
+    CLEAR   = "\033[0m"
+
+    def initialize(verbose = false)
       @log_file = '/tmp/log_install.txt'
-      check_file
-      init_log
-      init_log_text
+      @verbose = verbose
+      init
     end
 
+    # TODO remove length
     def info(msg)
-      @logger.info(msg)
-      @logger_text.info(msg)
+      tab = msg.match("\n") ? '' : add_tab(msg)
+      l = msg.length
+      @info.info "#{GREEN}#{BOLD} >>> #{CLEAR}#{l} #{WHITE}#{msg}#{CLEAR}" + tab
+      @save.info(msg)
+    end
+
+    def result_ok
+      @result.info "#{GREEN}[ #{WHITE}ok#{GREEN} ]#{CLEAR}\n"
     end
 
     def error(msg)
-      @logger.error(msg)
-      @logger_text.error(msg)
+      @error.error "#{BOLD} > #{CLEAR}#{WHITE}#{msg}#{CLEAR}"
+      @save.error(msg)
     end
 
     def debug(msg)
-      @logger.debug(msg)
-      @logger_text.debug(msg)
+      @debug.debug "#{BOLD} > #{CLEAR}#{WHITE}#{msg}#{CLEAR}"
+      @save.debug(msg)
     end
 
     def fatal(msg)
-      @logger.fatal(msg)
-      @logger_text.fatal(msg)
+      @fatal.fatal "#{BOLD} > #{CLEAR}#{WHITE}#{msg}#{CLEAR}\n"
+      @save.fatal(msg)
+      exit 1
     end
 
-    private
-
-    def check_file
-      puts "Creating log at #{@log_file}" if ! File.exist? @log_file
-    end
+    protected
 
     def init_log
-      @logger = Logger.new(STDOUT)
-      @logger.level = DEFAULT_OPTIONS[:verbose] ? Logger::DEBUG : Logger::INFO
-      @logger.formatter = proc { |severity, datetime, progname, msg|
-        "#{severity}, #{msg}\n" 
+      @info = Logger.new $stdout
+      @info.level = @verbose ? Logger::DEBUG : Logger::INFO
+      @info.formatter = proc { |severity, _, _, msg|
+        "#{BOLD}#{severity[0]}#{CLEAR}#{msg}"
       }
     end
 
-    def init_log_text
-      @logger_text = Logger.new(@log_file, 1)
-      @logger_text.level = Logger::DEBUG
-      @logger_text.formatter = proc { |severity, datetime, progname, msg|
-        "#{severity}, #{datetime}, #{msg}\n" 
+    def init_res
+      @result = Logger.new $stdout, level: 'INFO'
+      @result.formatter = proc do | _, _, _, msg | msg end
+    end
+
+    def init_debug
+      @debug = Logger.new $stdout
+      @debug.formatter = proc do | severity, _, _, msg |
+        "\n#{BLUE}#{BOLD}#{severity[0]}#{CLEAR} [#{Process.pid}]#{CLEAR}#{msg}"
+      end
+    end
+
+    def init_error
+      @error = Logger.new $stdout
+      @error.formatter = proc do | severity, _, _, msg |
+        "#{RED}#{BOLD}#{severity[0]}#{CLEAR}#{msg}\t"
+      end
+    end
+
+    def init_fatal
+      @fatal = Logger.new $stdout
+      @fatal.formatter = proc do | severity, _, _, msg |
+        "\n#{YELLOW}#{BOLD}#{severity[0]}#{CLEAR}#{msg}"
+      end
+    end
+
+    def init_save
+      File.exist? @log_file || puts("Creating log at #{@log_file}")
+      @save = Logger.new(@log_file, 1)
+      @save.level = Logger::DEBUG
+      @save.formatter = proc { |severity, datetime, _, msg|
+        "#{severity}, #{datetime}, #{msg}\n"
       }
     end
+
+    private
+
+    def init
+      init_log
+      init_res
+      init_error
+      init_debug
+      init_fatal
+      init_save
+    end
+
+    def add_tab(text)
+      case text.length
+      when 39..47 then "\t\t"
+      when 31..38 then "\t\t\t"
+      when 23..30 then "\t\t\t\t"
+      when 16..22 then "\t\t\t\t\t"
+      else "\t"
+      end
+    end
   end
 end

data/lib/getch/options.rb

@@ -1,21 +1,13 @@
+# frozen_string_literal: true
+
 require 'optparse'
+require 'nito'
 
 module Getch
   class Options
-    attr_reader :language, :zoneinfo, :keymap, :disk, :fs, :username, :boot_disk, :cache_disk, :home_disk, :encrypt, :verbose
+    include NiTo
 
     def initialize(argv)
-      @language = DEFAULT_OPTIONS[:language]
-      @zoneinfo = DEFAULT_OPTIONS[:zoneinfo]
-      @keymap = DEFAULT_OPTIONS[:keymap]
-      @disk = DEFAULT_OPTIONS[:disk]
-      @fs = DEFAULT_OPTIONS[:fs]
-      @username = DEFAULT_OPTIONS[:username]
-      @boot_disk = DEFAULT_OPTIONS[:boot_disk]
-      @cache_disk = DEFAULT_OPTIONS[:cache_disk]
-      @home_disk = DEFAULT_OPTIONS[:home_disk]
-      @encrypt = DEFAULT_OPTIONS[:encrypt]
-      @verbose = DEFAULT_OPTIONS[:verbose]
       parse(argv)
     end
 
@@ -23,48 +15,95 @@ module Getch
 
     def parse(argv)
       OptionParser.new do |opts|
-        opts.on("-l", "--language LANG", "Default is en_US") do |lang|
-          @language = lang
+        opts.banner = 'Usage: getch [OPTION...] <action>'
+
+        opts.separator "\noptions:"
+
+        opts.on('-l', '--language LANG', 'Default is en_US') do |lang|
+          OPTIONS[:language] = lang
         end
-        opts.on("-z", "--zoneinfo ZONE", "Default is US/Eastern") do |zone|
-          @zoneinfo = zone
+
+        opts.on('-t', '--timezone ZONE', 'Default is UTC') do |zone|
+          OPTIONS[:timezone] = Getch::Guard.zone(zone)
         end
-        opts.on("-k", "--keymap KEY", "Default is us") do |key|
-          @keymap = key
+
+        opts.on('-k', '--keymap KEY', 'Default is us') do |key|
+          OPTIONS[:keymap] = Getch::Guard.keymap(key)
         end
-        opts.on("-d", "--disk DISK", "Disk where install Gentoo (sda,sdb), default use #{@disk}") do |disk|
-          @disk = disk
+
+        opts.on('-d', '--disk DISK',
+                'Root Disk where install the system (sda,sdb)') do |disk|
+          OPTIONS[:disk] = Getch::Guard.disk(disk)
         end
-        opts.on("-f", "--format FS", "Can be ext4, lvm or zfs. Default use ext4") do |fs|
-          @fs = fs
-          DEFAULT_OPTIONS[:fs] = fs # dont known why, but it should be enforce
+
+        opts.on('-f', '--format FS',
+                'Can be ext4, zfs. Default use ext4') do |fs|
+          OPTIONS[:fs] = Getch::Guard.format(fs)
         end
-        opts.on("-u", "--username USERNAME", "Create a new user /home/USERNAME with password.") do |user|
-          @username = user
+
+        opts.on('-u', '--username USERNAME',
+                'Create a new user /home/USERNAME with password.') do |user|
+          OPTIONS[:username] = user
         end
-        opts.on("--separate-boot DISK", "Disk for the boot/efi partition, default use #{@disk}") do |boot|
-          @boot_disk = boot
-          DEFAULT_OPTIONS[:boot_disk] = boot
+
+        opts.on('-o', '--os NAME', /gentoo|void/,
+                'Install distro NAME, can be gentoo or void.') do |name|
+          OPTIONS[:os] = name
         end
-        opts.on("--separate-cache DISK", "Disk for the swap partition, add ZIL/L2ARC for ZFS when set, default use #{@disk}") do |swap|
-          @cache_disk = swap
-          DEFAULT_OPTIONS[:cache_disk] = swap
+
+        opts.on('--separate-boot DISK',
+                'Use a different DISK for the /boot or /efi partition.') do |boot|
+          OPTIONS[:boot_disk] = Getch::Guard.disk(boot)
         end
-        opts.on("--separate-home DISK", "Disk for the /home partition, default is nil") do |home|
-          @home_disk = home
-          DEFAULT_OPTIONS[:home_disk] = home
+
+        opts.on('--separate-cache DISK',
+                'Use a different DISK for the swap partition, add ZIL/L2ARC for ZFS when set.') do |swap|
+          OPTIONS[:cache_disk] = Getch::Guard.disk(swap)
         end
-        opts.on("--encrypt", "Encrypt your system.") do
-          @encrypt = true
+
+        opts.on('--separate-home DISK',
+                'Use a different DISK for the /home partition.') do |home|
+          OPTIONS[:home_disk] = Getch::Guard.disk(home)
         end
-        opts.on("--verbose", "Write more messages to the standard output.") do
-          @verbose = true
+
+        opts.on('--lvm',
+                'System will use LVM, do not work with ZFS.') do
+          OPTIONS[:lvm] = true
         end
-        opts.on("-h", "--help", "Display this") do
+
+        opts.on('--encrypt',
+                'Encrypt your system, use LUKS or native encryption for ZFS.') do
+          OPTIONS[:encrypt] = true
+        end
+
+        opts.on('--musl', 'Prefer to install Musl over Glibc.') do
+          OPTIONS[:musl] = true
+        end
+
+        opts.on('--verbose', 'Write more messages to the standard output.') do
+          OPTIONS[:verbose] = true
+        end
+
+        opts.on('-h', '--help', 'Display this') do
           puts opts
           exit
         end
-      end.parse!(into: DEFAULT_OPTIONS)
+
+        opts.separator "\n<action> is one of:"
+
+        opts.on('--restart', 'Restart the whole installation') do
+          rm '/tmp/install_gentoo.yaml'
+          rm '/tmp/log_install.txt'
+          rm '/tmp/getch_devs.yaml'
+        end
+
+        begin
+          opts.parse!(argv)
+        rescue OptionParser::ParseError => e
+          warn e.message, "\n", opts
+          exit 1
+        end
+      end
     end
   end
 end

data/lib/getch/states.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module Getch
@@ -22,39 +24,64 @@ module Getch
       save
     end
 
-    def stage3
-      STATES[:gentoo_base] = true
+    def tarball
+      STATES[:tarball] = true
       save
     end
 
-    def config
-      STATES[:gentoo_config] = true
+    def pre_config
+      STATES[:pre_config] = true
       save
     end
 
     def update
-      STATES[:gentoo_update] = true
+      STATES[:update] = true
+      save
+    end
+
+    def post_config
+      STATES[:post_config] = true
+      save
+    end
+
+    def terraform
+      STATES[:terraform] = true
+      save
+    end
+
+    def services
+      STATES[:services] = true
+      save
+    end
+
+    def luks_keys
+      STATES[:luks_keys] = true
+      save
+    end
+
+    def bootloader
+      STATES[:bootloader] = true
       save
     end
 
-    def kernel
-      STATES[:gentoo_kernel] = true
+    def finalize
+      STATES[:finalize] = true
       save
     end
 
     private
 
     def save
-      File.open(@file, 'w') { |f| YAML::dump(STATES, f) }
+      File.open(@file, 'w') { |f| YAML.dump(STATES, f) }
     end
 
-    def load_state()
+    def load_state
       if File.exist? @file
         state_file = YAML.load_file(@file)
         STATES.merge!(state_file)
       else
         save
-        STDERR.puts "Initialize states"
+        warn 'Initialize states'
       end
     end
   end

data/lib/getch/tree.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Getch
+  module Tree
+    class Os
+
+      OS_TREE = {
+        gentoo: Gentoo,
+        void: Void
+      }.freeze
+
+      def initialize
+        @os = OPTIONS[:os]
+        @log = Log.new
+      end
+
+      def select
+        OS_TREE[@os.to_sym] || @log.fatal('OS no found')
+      end
+    end
+    class FS
+
+      FS_TREE = {
+        true => { # + encrypt
+          true => { # + lvm
+            ext4: FileSystem::Ext4::Hybrid,
+          },
+          false => { # - lvm
+            ext4: FileSystem::Ext4::Encrypt,
+            zfs: FileSystem::Zfs::Encrypt
+          },
+        },
+        false => { # - encrypt
+          true => { # + lvm
+            ext4: FileSystem::Ext4::Lvm,
+          },
+          false => { # - lvm
+            ext4: FileSystem::Ext4::Minimal,
+            zfs: FileSystem::Zfs::Minimal,
+          },
+        }
+      }.freeze
+
+      def initialize
+        @encrypt = OPTIONS[:encrypt]
+        @lvm = OPTIONS[:lvm]
+        @fs = OPTIONS[:fs]
+        @log = Log.new
+      end
+
+      def select
+        FS_TREE[@encrypt][@lvm][@fs.to_sym] || @log.fatal('Error in FS_TREE or no comptatible options')
+      end
+    end
+  end
+end

data/lib/getch/version.rb

@@ -1,3 +1,3 @@
 module Getch
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/lib/getch/void/bootloader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Getch
+  module Void
+    class Bootloader
+      def dependencies
+        Helpers.efi? ?
+          Install.new('grub-x86_64-efi') :
+          Install.new('grub')
+      end
+
+      def install
+        Config::Grub.new
+        ChrootOutput.new('xbps-reconfigure -fa') # this command also start grub-mkconfig
+      end
+    end
+  end
+end

data/lib/getch/void/finalize.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Getch
+  module Void
+    class Finalize
+      def initialize
+        x
+      end
+
+      protected
+
+      def x
+        shell
+        accounts
+      end
+
+      private
+
+      # Make the default shell /bin/bash instead of /bin/sh
+      def shell
+        Chroot.new('chsh -s /bin/bash')
+      end
+
+      def accounts
+        account = Config::Account.new
+        account.root
+        account.new_user
+      end
+    end
+  end
+end