getch 0.1.9 → 0.3.3

data/lib/getch/helpers.rb

@@ -3,6 +3,7 @@
 require 'open-uri'
 require 'open3'
 require 'fileutils'
+require 'nito'
 
 module Getch
   module Helpers
@@ -10,63 +11,40 @@ module Getch
       Dir.exist? '/sys/firmware/efi/efivars'
     end
 
-    def self.get_file_online(url, dest)
-      URI.open(url) do |l|
-        File.open(dest, "wb") { |f| f.write(l.read) }
-      end
-    end
-
-    def self.exec_or_die(cmd)
-      _, stderr, status = Open3.capture3(cmd)
-      unless status.success?
-        raise "Problem running #{cmd}, stderr was:\n#{stderr}"
-      end
-    end
-
-    def self.create_dir(path, perm = 0755)
-      FileUtils.mkdir_p path, mode: perm unless Dir.exist? path
-    end
-
-    def self.add_file(path, content = '')
-      File.write path, content unless File.exist? path
-    end
-
-    def self.mkdir(dir)
-      FileUtils.mkdir_p dir unless Dir.exist? dir
+    def self.systemd?
+      Dir.exist? "#{OPTIONS[:mountpoint]}/etc/systemd"
     end
 
-    def self.touch(file)
-      File.write file, '' unless File.exist? file
+    def self.openrc?
+      File.exist? "#{OPTIONS[:mountpoint]}/etc/conf.d/keymaps"
     end
 
-    def self.echo(src, content = '')
-      File.write(src, "#{content}\n", mode: 'w')
+    def self.runit?
+      Dir.exist? "#{OPTIONS[:mountpoint]}/etc/runit"
     end
 
-    def self.echo_a(src, content = '')
-      raise "No file #{src} found !" unless File.exist? src
-
-      File.write(src, "#{content}\n", mode: 'a') unless self.grep?(src, content)
+    def self.grub?
+      File.exist? "#{OPTIONS[:mountpoint]}/etc/default/grub"
     end
 
-    def self.cp(src, dest)
-      raise "Src file #{src} no found" unless File.exist? src
-
-      FileUtils.cp(src, dest)
+    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
 
-    def self.grep?(file, regex)
-      is_found = false
-      return is_found unless File.exist? file
-      File.open(file) do |f|
-        f.each { |l| is_found = true if l.match(regex) }
+    def self.exec_or_die(cmd)
+      _, stderr, status = Open3.capture3(cmd)
+      unless status.success?
+        abort "Problem running #{cmd}, stderr was:\n#{stderr}"
       end
-      is_found
     end
 
     def self.sys(cmd)
       system(cmd)
-      raise "Error with #{cmd}" unless $?.success?
+      $?.success? || abort("Error with #{cmd}")
     end
 
     def self.partuuid(dev)
@@ -79,39 +57,58 @@ module Getch
           return f.delete_prefix('/dev/disk/by-uuid/')
         end
       end
+      Log.new.fatal("UUID on #{dev} is no found")
     end
 
-    # Used with ZFS for the pool name
-    def self.pool_id(dev)
-      if dev.match(/[0-9]/)
-        sleep 1
-        `lsblk -o PARTUUID #{dev}`.delete("\n").delete('PARTUUID').match(/\w{5}/)
-      else
-        puts 'Please, enter a pool name'
-        while true
-          print "\n> "
-          value = gets
-          if value.match(/[a-z]{4,20}/)
-            return value
-          end
-          puts "Bad name, you enter: #{value}"
-          puts 'Valid pool name use character only, between 4-20.'
+    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
 
-    module Void
-      def command(args)
-        print " => Exec: #{args}..."
-        cmd = "chroot #{Getch::MOUNTPOINT} /bin/bash -c \"#{args}\""
-        _, stderr, status = Open3.capture3(cmd)
-        if status.success?
-          puts "\s[OK]"
-          return
+    # 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
-        raise "\n[-] Fail cmd #{args} - #{stderr}."
       end
+      Log.new.fatal("ID on #{dev} is no found")
+    end
+
+    # 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
+
+    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')
+
+      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
+
+    module Void
       def command_output(args)
         print " => Exec: #{args}..."
         cmd = "chroot #{Getch::MOUNTPOINT} /bin/bash -c \"#{args}\""
@@ -126,19 +123,6 @@ module Getch
         end
       end
 
-      def add_line(file, line)
-        raise "No file #{file} found !" unless File.exist? file
-
-        File.write(file, "#{line}\n", mode: 'a')
-      end
-
-      def search(file, text)
-        File.open(file).each do |line|
-          return true if line.match(/#{text}/)
-        end
-        false
-      end
-
       # Used only when need password
       def chroot(cmd)
         unless system('chroot', Getch::MOUNTPOINT, '/bin/bash', '-c', cmd)
@@ -162,42 +146,6 @@ module Getch
 
         add_line(conf, "PARTUUID=#{device} #{rest}")
       end
-
-      def grub_cmdline(*args)
-        conf = "#{Getch::MOUNTPOINT}/etc/default/grub"
-        list = args.join(' ')
-        secs = "GRUB_CMDLINE_LINUX=\"#{list} init_on_alloc=1 init_on_free=1"
-        secs += ' slab_nomerge pti=on slub_debug=ZF vsyscall=none"'
-        raise 'No default/grub found' unless File.exist? conf
-
-        unless search(conf, 'GRUB_CMDLINE_LINUX=')
-          File.write(conf, "#{secs}\n", mode: 'a')
-        end
-      end
-    end
-
-    module Cryptsetup
-      def encrypt(dev)
-        raise "No device #{dev}" unless File.exist? dev
-
-        puts " => Encrypting device #{dev}..."
-        if Helpers.efi? && Getch::OPTIONS[:os] == 'gentoo'
-          Helpers.sys("cryptsetup luksFormat --type luks #{dev}")
-        else
-          Helpers.sys("cryptsetup luksFormat --type luks1 #{dev}")
-        end
-      end
-
-      def open_crypt(dev, map_name)
-        raise "No device #{dev}" unless File.exist? dev
-
-        puts " => Opening encrypted device #{dev}..."
-        if Helpers.efi? && Getch::OPTIONS[:os] == 'gentoo'
-          Helpers.sys("cryptsetup open --type luks #{dev} #{map_name}")
-        else
-          Helpers.sys("cryptsetup open --type luks1 #{dev} #{map_name}")
-        end
-      end
     end
   end
 end

data/lib/getch/log.rb

@@ -4,54 +4,116 @@ require 'logger'
 
 module Getch
   class Log
+
+    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'
       @verbose = verbose
-      check_file
-      init_log
-      init_log_text
+      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}" unless File.exist? @log_file
-    end
+    protected
 
     def init_log
-      @logger = Logger.new($stdout)
-      @logger.level = @verbose ? Logger::DEBUG : Logger::INFO
-      @logger.formatter = proc { |severity, _, _, 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, _, 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,9 +1,12 @@
 # frozen_string_literal: true
 
 require 'optparse'
+require 'nito'
 
 module Getch
   class Options
+    include NiTo
+
     def initialize(argv)
       parse(argv)
     end
@@ -12,52 +15,71 @@ module Getch
 
     def parse(argv)
       OptionParser.new do |opts|
-        opts.version = VERSION
+        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|
-          OPTIONS[:zoneinfo] = Getch::Guard.zone(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|
           OPTIONS[:keymap] = Getch::Guard.keymap(key)
         end
 
-        opts.on('-d', '--disk DISK', 'Root Disk where install the system (sda,sdb)') do |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|
+        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|
+        opts.on('-u', '--username USERNAME',
+                'Create a new user /home/USERNAME with password.') do |user|
           OPTIONS[:username] = user
         end
 
-        opts.on('-o', '--os NAME', /gentoo|void/, 'Install distro NAME, can be gentoo or void.') do |name|
+        opts.on('-o', '--os NAME', /gentoo|void/,
+                'Install distro NAME, can be gentoo or void.') do |name|
           OPTIONS[:os] = name
         end
 
-        opts.on('--separate-boot DISK', 'Use a different DISK for the /boot or /efi partition.') do |boot|
+        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-cache DISK', 'Use a different DISK for the swap partition, add ZIL/L2ARC for ZFS when set.') do |swap|
+        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('--separate-home DISK', 'Use a different DISK for the /home partition.') do |home|
+        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('--encrypt', 'Encrypt your system, use LUKS or native encryption for ZFS.') do
+        opts.on('--lvm',
+                'System will use LVM, do not work with ZFS.') do
+          OPTIONS[:lvm] = true
+        end
+
+        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
@@ -67,6 +89,14 @@ module Getch
           exit
         end
 
+        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

data/lib/getch/states.rb

@@ -24,28 +24,48 @@ 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[:gentoo_bootloader] = true
+      STATES[:bootloader] = true
       save
     end
 
-    def kernel
-      STATES[:gentoo_kernel] = true
+    def finalize
+      STATES[:finalize] = true
       save
     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.9'.freeze
+  VERSION = '0.3.3'.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

data/lib/getch/void/post_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Getch
+  module Void
+    class PostConfig
+      def initialize
+        x
+      end
+
+      protected
+
+      def x
+        Getch::Config::Locale.new
+        Getch::Config::Keymap.new
+        Getch::Config::TimeZone.new
+      end
+    end
+  end
+end