getch 0.1.2 → 0.1.9

data/lib/getch/helpers.rb

@@ -1,71 +1,203 @@
+# frozen_string_literal: true
+
 require 'open-uri'
 require 'open3'
 require 'fileutils'
 
-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.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
     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?
+        raise "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.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 if ! File.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 if ! Dir.exist? dir
-  end
+    def self.mkdir(dir)
+      FileUtils.mkdir_p dir unless Dir.exist? dir
+    end
 
-  def self.touch(file)
-    File.write file, '' if ! File.exist? file
-  end
+    def self.touch(file)
+      File.write file, '' unless File.exist? file
+    end
+
+    def self.echo(src, content = '')
+      File.write(src, "#{content}\n", mode: 'w')
+    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)
+    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)
+    def self.cp(src, dest)
+      raise "Src file #{src} no found" unless File.exist? src
+
+      FileUtils.cp(src, dest)
+    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) }
       end
+      is_found
     end
-    is_found
-  end
 
-  def self.sys(cmd)
-    system(cmd)
-    unless $?.success?
-      raise "Error with #{cmd}"
+    def self.sys(cmd)
+      system(cmd)
+      raise "Error with #{cmd}" unless $?.success?
     end
-  end
 
-  def self.partuuid(dev)
-    `lsblk -o PARTUUID #{dev}`.match(/[\w]+-[\w]+-[\w]+-[\w]+-[\w]+/)
-  end
+    def self.partuuid(dev)
+      `lsblk -o PARTUUID #{dev}`.match(/\w+-\w+-\w+-\w+-\w+/)
+    end
 
-  def self.uuid(dev)
-    `lsblk -do UUID #{dev}`.match(/[\w]+-[\w]+-[\w]+-[\w]+-[\w]+/)
-  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
+    end
 
-  # Used with ZFS for the pool name
-  def self.pool_id(dev)
-    `lsblk -o PARTUUID #{dev}`.delete("\n").delete("PARTUUID").match(/[\w]{5}/)
+    # 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.'
+        end
+      end
+    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
+        end
+        raise "\n[-] Fail cmd #{args} - #{stderr}."
+      end
+
+      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
+
+      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)
+          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
+
+      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

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module Getch
   class Log
-    def initialize
+    def initialize(verbose = false)
       @log_file = '/tmp/log_install.txt'
+      @verbose = verbose
       check_file
       init_log
       init_log_text
@@ -32,21 +35,21 @@ module Getch
     private
 
     def check_file
-      puts "Creating log at #{@log_file}" if ! File.exist? @log_file
+      puts "Creating log at #{@log_file}" unless File.exist? @log_file
     end
 
     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" 
+      @logger = Logger.new($stdout)
+      @logger.level = @verbose ? Logger::DEBUG : Logger::INFO
+      @logger.formatter = proc { |severity, _, _, msg|
+        "#{severity}, #{msg}\n"
       }
     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|
+      @logger_text.formatter = proc { |severity, datetime, _, msg|
         "#{severity}, #{datetime}, #{msg}\n" 
       }
     end

data/lib/getch/options.rb

@@ -1,21 +1,10 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 module Getch
   class Options
-    attr_reader :language, :zoneinfo, :keymap, :disk, :fs, :username, :boot_disk, :cache_disk, :home_disk, :encrypt, :verbose
-
     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 +12,68 @@ module Getch
 
     def parse(argv)
       OptionParser.new do |opts|
-        opts.on("-l", "--language LANG", "Default is en_US") do |lang|
-          @language = lang
+        opts.version = VERSION
+
+        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('-z', '--zoneinfo ZONE', 'Default is US/Eastern') do |zone|
+          OPTIONS[:zoneinfo] = 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|
+          OPTIONS[:fs] = Getch::Guard.format(fs)
         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('-u', '--username USERNAME', 'Create a new user /home/USERNAME with password.') do |user|
+          OPTIONS[:username] = user
         end
-        opts.on("-u", "--username USERNAME", "Create a new user /home/USERNAME with password.") do |user|
-          @username = user
+
+        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", "Disk for the boot/efi partition, default use #{@disk}") do |boot|
-          @boot_disk = boot
-          DEFAULT_OPTIONS[:boot_disk] = 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", "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-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", "Disk for the /home partition, default is nil") do |home|
-          @home_disk = home
-          DEFAULT_OPTIONS[:home_disk] = 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.") do
-          @encrypt = true
+
+        opts.on('--encrypt', 'Encrypt your system, use LUKS or native encryption for ZFS.') do
+          OPTIONS[:encrypt] = true
         end
-        opts.on("--verbose", "Write more messages to the standard output.") do
-          @verbose = true
+
+        opts.on('--verbose', 'Write more messages to the standard output.') do
+          OPTIONS[:verbose] = true
         end
-        opts.on("-h", "--help", "Display this") do
+
+        opts.on('-h', '--help', 'Display this') do
           puts opts
           exit
         end
-      end.parse!(into: DEFAULT_OPTIONS)
+
+        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
@@ -37,6 +39,11 @@ module Getch
       save
     end
 
+    def bootloader
+      STATES[:gentoo_bootloader] = true
+      save
+    end
+
     def kernel
       STATES[:gentoo_kernel] = true
       save
@@ -45,16 +52,16 @@ module Getch
     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/version.rb

@@ -1,3 +1,3 @@
 module Getch
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.9'.freeze
 end

data/lib/getch/void/boot.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Getch
+  module Void
+    class Boot
+      include Helpers::Void
+
+      def initialize
+        @efi = Helpers.efi?
+        @class_fs = Getch::select_fs
+        @fs = @class_fs::Void.new
+        @user = OPTIONS[:username]
+        @fs.create_key if @class_fs::Void.method_defined? :create_key
+      end
+
+      def new_user
+        puts ' => Add a password for root.'
+        chroot 'passwd'
+        puts
+        return unless @user
+
+        print " => Creating a new user #{@user}..."
+        puts "\s[OK]"
+        command "useradd -m -G users,wheel,audio,video #{@user}"
+        puts " => Add a password for #{@user}."
+        chroot "passwd #{@user}"
+        puts
+      end
+
+      def fstab
+        print ' => Configuring fstab...'
+        @fs.fstab
+        puts "\s[OK]"
+        @fs.crypttab if @class_fs::Void.method_defined? :crypttab
+      end
+
+      # Test dracut in chroot (version in /lib/modules/5.1.7-1):
+      # dracut -H -f --kver 5.1.7-1
+      def dracut
+        print ' => Configuring Dracut...'
+        @fs.config_dracut
+        @fs.kernel_cmdline_dracut
+        puts "\s[OK]"
+      end
+
+      def grub
+        disk = OPTIONS[:boot_disk] ||= OPTIONS[:disk]
+        # https://wiki.archlinux.org/title/Install_Arch_Linux_on_ZFS
+        prefix = OPTIONS[:fs] == 'zfs' ? 'ZPOOL_VDEV_NAME_PATH=1' : ''
+        print " => Installing Grub on #{disk}..."
+        if @efi
+          command_output 'xbps-install -y grub-x86_64-efi'
+          @fs.config_grub if @class_fs::Void.method_defined? :config_grub
+          command_output "#{prefix} grub-install --target=x86_64-efi --efi-directory=/efi --bootloader-id=\"Void\""
+        else
+          command_output 'xbps-install -y grub'
+          @fs.config_grub if @class_fs::Void.method_defined? :config_grub
+          command_output "#{prefix} grub-install /dev/#{disk}"
+        end
+      end
+
+      def initramfs
+        puts ' => Generating an initramfs...'
+        command_output 'xbps-reconfigure -fa' # this command also start grub-mkconfig
+      end
+
+      def finish
+        puts
+        puts '[*!*] Install finished [*!*]'
+        puts
+        @fs.finish
+        puts
+      end
+
+      private
+
+      def chroot(cmd)
+        system('chroot', MOUNTPOINT, '/bin/bash', '-c', cmd)
+      end
+    end
+  end
+end

data/lib/getch/void/chroot.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Getch
+  module Void
+    class Chroot
+      include Helpers::Void
+
+      def initialize
+        @state = Getch::States.new
+        @pkgs = []
+        mount
+      end
+
+      # https://docs.voidlinux.org/installation/guides/chroot.html#install-base-system-rootfs-method-only
+      def update
+        return if STATES[:gentoo_update]
+
+        command_output '/usr/bin/xbps-install -Suy xbps' # y to force (--yes)
+        command_output '/usr/bin/xbps-install -uy'
+        command_output '/usr/bin/xbps-install -y base-system'
+        #command_output '/usr/bin/xbps-remove base-voidstrap'
+        @state.update
+      end
+
+      def extras
+        @pkgs << 'vim'
+        @pkgs << 'iptables'
+        @pkgs << 'iwd'
+      end
+
+      def fs
+        @pkgs << 'lvm2' if OPTIONS[:fs] == 'lvm'
+        @pkgs << 'zfs' if OPTIONS[:fs] == 'zfs'
+        @pkgs << 'cryptsetup' if OPTIONS[:encrypt]
+      end
+
+      def install_pkgs
+        all_pkgs = @pkgs.join(' ')
+        command_output "/usr/bin/xbps-install -y #{all_pkgs}"
+      end
+
+      private
+
+      def mount
+        puts 'Populate /proc, /sys and /dev.'
+        Helpers.exec_or_die("mount --types proc /proc \"#{MOUNTPOINT}/proc\"")
+        Helpers.exec_or_die("mount --rbind /sys \"#{MOUNTPOINT}/sys\"")
+        Helpers.exec_or_die("mount --make-rslave \"#{MOUNTPOINT}/sys\"")
+        Helpers.exec_or_die("mount --rbind /dev \"#{MOUNTPOINT}/dev\"")
+        Helpers.exec_or_die("mount --make-rslave \"#{MOUNTPOINT}/dev\"")
+        # Maybe add /dev/shm like describe here:
+        # https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Base
+      end
+    end
+  end
+end