foreman_bootdisk 14.0.0 → 17.0.2

data/app/models/setting/bootdisk.rb

@@ -2,30 +2,27 @@
 
 class Setting
   class Bootdisk < ::Setting
-    def self.load_defaults
-      return unless ApplicationRecord.connection.table_exists?('settings')
-      return unless super
-
+    def self.default_settings
       ipxe = ['/usr/lib/ipxe'].find { |p| File.exist?(p) } || '/usr/share/ipxe'
       isolinux = ['/usr/lib/ISOLINUX'].find { |p| File.exist?(p) } || '/usr/share/syslinux'
       syslinux = ['/usr/lib/syslinux/modules/bios', '/usr/lib/syslinux'].find { |p| File.exist?(p) } || '/usr/share/syslinux'
+      grub2 = ['/var/lib/tftpboot/grub2'].find { |p| File.exist?(p) } || '/var/lib/foreman/bootdisk'
       templates = -> { Hash[ProvisioningTemplate.where(template_kind: TemplateKind.where(name: 'Bootdisk')).map { |temp| [temp[:name], temp[:name]] }] }
 
-      Setting.transaction do
-        [
-          set('bootdisk_ipxe_dir', N_('Path to directory containing iPXE images'), ipxe, N_('iPXE directory')),
-          set('bootdisk_isolinux_dir', N_('Path to directory containing isolinux images'), isolinux, N_('ISOLINUX directory')),
-          set('bootdisk_syslinux_dir', N_('Path to directory containing syslinux images'), syslinux, N_('SYSLINUX directory')),
-          set('bootdisk_host_template', N_('iPXE template to use for host-specific boot disks'),
-              'Boot disk iPXE - host', N_('Host image template'), nil, collection: templates),
-          set('bootdisk_generic_host_template', N_('iPXE template to use for generic host boot disks'),
-              'Boot disk iPXE - generic host', N_('Generic image template'), nil, collection: templates),
-          set('bootdisk_mkiso_command', N_('Command to generate ISO image, use genisoimage or mkisofs'), 'genisoimage', N_('ISO generation command')),
-          set('bootdisk_cache_media', N_('Installation media files will be cached for full host images'), true, N_('Installation media caching'))
-        ].compact.each { |s| create s.update(category: 'Setting::Bootdisk') }
-      end
-
-      true
+      [
+        set('bootdisk_ipxe_dir', N_('Path to directory containing iPXE images'), ipxe, N_('iPXE directory')),
+        set('bootdisk_isolinux_dir', N_('Path to directory containing isolinux images'), isolinux, N_('ISOLINUX directory')),
+        set('bootdisk_syslinux_dir', N_('Path to directory containing syslinux images'), syslinux, N_('SYSLINUX directory')),
+        set('bootdisk_grub2_dir', N_('Path to directory containing grubx64.efi and shimx64.efi'), grub2, N_('Grub2 directory')),
+        set('bootdisk_host_template', N_('iPXE template to use for host-specific boot disks'),
+            'Boot disk iPXE - host', N_('Host image template'), nil, collection: templates),
+        set('bootdisk_generic_host_template', N_('iPXE template to use for generic host boot disks'),
+            'Boot disk iPXE - generic host', N_('Generic image template'), nil, collection: templates),
+        set('bootdisk_generic_efi_host_template', N_('Grub2 template to use for generic EFI host boot disks'),
+            'Boot disk Grub2 EFI - generic host', N_('Generic Grub2 EFI image template'), nil, collection: templates),
+        set('bootdisk_mkiso_command', N_('Command to generate ISO image, use genisoimage or mkisofs'), 'genisoimage', N_('ISO generation command')),
+        set('bootdisk_cache_media', N_('Installation media files will be cached for full host images'), true, N_('Installation media caching'))
+      ]
     end
 
     def self.humanized_category

data/app/services/foreman_bootdisk/iso_generator.rb

@@ -11,9 +11,10 @@ require 'uri'
 module ForemanBootdisk
   class ISOGenerator
     def self.generate_full_host(host, opts = {}, &block)
-      raise Foreman::Exception, N_('Host is not in build mode, so the template cannot be rendered') unless host.build?
+      raise Foreman::Exception.new(N_('Host is not in build mode, so the template cannot be rendered')) unless host.build?
 
-      tmpl = render_pxelinux_template(host)
+      isolinux_template = render_template(host, :PXELinux, ForemanBootdisk::Scope::FullHostBootdisk)
+      grub_template = render_template(host, :PXEGrub2, ForemanBootdisk::Scope::FullHostBootdiskEfi)
 
       # pxe_files and filename conversion is utterly bizarre
       # aim to convert filenames to something usable under ISO 9660, to match as rendered in the template
@@ -24,84 +25,145 @@ module ForemanBootdisk
         hash[iso_filename] = host.url_for_boot(type)
       end
 
-      generate(opts.merge(isolinux: tmpl, files: files), &block)
+      generate(opts.merge(isolinux: isolinux_template, grub: grub_template, files: files), &block)
+    rescue ::Foreman::Exception => e
+      if e.code == 'ERF42-0067'
+        ForemanBootdisk.logger.warn e
+      else
+        raise e
+      end
     end
 
-    def self.render_pxelinux_template(host)
-      pxelinux_template = host.provisioning_template(kind: :PXELinux)
+    def self.render_template(host, kind, scope_class)
+      template = host.provisioning_template(kind: kind)
 
-      raise Foreman::Exception, N_('Unable to generate disk template, PXELinux template not found.') unless pxelinux_template
+      raise Foreman::Exception.new(N_('Unable to generate disk template, %{kind} template not found.'), kind: kind) unless template
 
       template = ForemanBootdisk::Renderer.new.render_template(
-        template: pxelinux_template,
+        template: template,
         host: host,
-        scope_class: ForemanBootdisk::Scope::FullHostBootdisk
+        scope_class: scope_class
       )
 
       unless template
         err = host.errors.full_messages.to_sentence
-        raise ::Foreman::Exception.new(N_('Unable to generate disk PXELinux template: %s'), err)
+        raise Foreman::Exception.new(N_('Unable to generate disk %{kind} template: %{error}'), kind: kind, error: err)
       end
 
       template
     end
 
+    def self.system_or_exception(command, error)
+      unless system(command)
+        ForemanBootdisk.logger.debug "Bootdisk command failed: #{command}"
+        raise Foreman::Exception.new(N_(error))
+      end
+    end
+
     def self.generate(opts = {})
-      opts[:isolinux] = <<~ISOLINUX if opts[:isolinux].nil? && opts[:ipxe]
-        default ipxe
-        label ipxe
-        kernel /ipxe
-        initrd /script
-      ISOLINUX
+      # isolinux template not provided for generic BIOS bootdisks
+      if opts[:isolinux].nil? && opts[:ipxe]
+        opts[:isolinux] = <<~EOT
+          default ipxe
+          label ipxe
+          kernel /ipxe
+          initrd /script
+        EOT
+      end
 
-      Dir.mktmpdir('bootdisk') do |wd|
-        Dir.mkdir(File.join(wd, 'build'))
+      if opts[:grub].nil? && opts[:ipxe]
+        opts[:grub] = <<~EOT
+          echo "Grub2 template not associated and/or unsupported bootdisk type."
+          echo "The following bootdisks are supported for EFI systems:"
+          echo " * FULL HOST BOOTDISK"
+          echo " * SUBNET GENERIC BOOTDISK"
+          echo "The system will poweroff in few minutes..."
+          sleep 500
+          poweroff
+        EOT
+      end
 
-        if opts[:isolinux]
-          isolinux_source_file = File.join(Setting[:bootdisk_isolinux_dir], 'isolinux.bin')
-          raise Foreman::Exception, N_('Please ensure the isolinux/syslinux package(s) are installed.') unless File.exist?(isolinux_source_file)
+      # Temporary directory cannot be cleaned inprocess due to send_file offloaded to web server
+      wd = Dir.mktmpdir('bootdisk-iso-')
+      Dir.mkdir(File.join(wd, 'build'))
 
-          FileUtils.cp(isolinux_source_file, File.join(wd, 'build', 'isolinux.bin'))
+      if opts[:isolinux]
+        isolinux_source_file = File.join(Setting[:bootdisk_isolinux_dir], 'isolinux.bin')
+        raise Foreman::Exception.new(N_('Please ensure the isolinux/syslinux package(s) are installed.')) unless File.exist?(isolinux_source_file)
 
-          ldlinux_source_file = File.join(Setting[:bootdisk_syslinux_dir], 'ldlinux.c32')
-          FileUtils.cp(ldlinux_source_file, File.join(wd, 'build', 'ldlinux.c32')) if File.exist?(ldlinux_source_file)
+        FileUtils.cp(isolinux_source_file, File.join(wd, 'build', 'isolinux.bin'))
 
-          File.open(File.join(wd, 'build', 'isolinux.cfg'), 'w') do |file|
-            file.write(opts[:isolinux])
-          end
+        source_files = ['ldlinux.c32', 'menu.c32', 'libutil.c32']
+        source_files.each do |source_file|
+          full_path = File.join(Setting[:bootdisk_syslinux_dir], source_file)
+          FileUtils.cp(full_path, File.join(wd, 'build', source_file)) if File.exist?(full_path)
+        end
+
+        File.open(File.join(wd, 'build', 'isolinux.cfg'), 'w') do |file|
+          file.write(opts[:isolinux])
         end
+      end
+
+      if opts[:ipxe]
+        ipxe_source_file = File.join(Setting[:bootdisk_ipxe_dir], 'ipxe.lkrn')
+        raise Foreman::Exception.new(N_('Please ensure the ipxe-bootimgs package is installed.')) unless File.exist?(ipxe_source_file)
 
-        if opts[:ipxe]
-          ipxe_source_file = File.join(Setting[:bootdisk_ipxe_dir], 'ipxe.lkrn')
-          raise Foreman::Exception, N_('Please ensure the ipxe-bootimgs package is installed.') unless File.exist?(ipxe_source_file)
+        FileUtils.cp(ipxe_source_file, File.join(wd, 'build', 'ipxe'))
+        File.open(File.join(wd, 'build', 'script'), 'w') { |file| file.write(opts[:ipxe]) }
+      end
 
-          FileUtils.cp(ipxe_source_file, File.join(wd, 'build', 'ipxe'))
-          File.open(File.join(wd, 'build', 'script'), 'w') { |file| file.write(opts[:ipxe]) }
+      if opts[:grub]
+        FileUtils.mkdir_p(File.join(wd, 'build', 'EFI', 'BOOT'))
+        # a copy when using CDROM directly
+        File.open(File.join(wd, 'build', 'EFI', 'BOOT', 'grub.cfg'), 'w') { |file| file.write(opts[:grub]) }
+        # a copy when using USB/HDD (copied into EFI image as well)
+        File.open(File.join(wd, 'build', 'grub-hdd.cfg'), 'w') do |f|
+          # set root to (cd0) or similar when booting via disk
+          f.write("search --file /ISOLINUX.BIN --set root\n")
+          f.write(opts[:grub])
+        end
+        efibootimg = File.join(wd, 'build', 'efiboot.img')
+        system_or_exception("truncate -s 4M #{efibootimg}", N_('Creating new image failed, install truncate utility'))
+        system_or_exception("mkfs.msdos #{efibootimg}", N_('Failed to format the ESP image via mkfs.msdos'))
+        system_or_exception("mmd -i #{efibootimg} '::/EFI'", N_('Failed to create a directory within the ESP image'))
+        system_or_exception("mmd -i #{efibootimg} '::/EFI/BOOT'", N_('Failed to create a directory within the ESP image'))
+        {
+          File.join(wd, 'build', 'grub-hdd.cfg').to_s => 'GRUB.CFG',
+          File.join(Setting[:bootdisk_grub2_dir], 'grubx64.efi').to_s => 'GRUBX64.EFI',
+          File.join(Setting[:bootdisk_grub2_dir], 'shimx64.efi').to_s => 'BOOTX64.EFI',
+        }.each do |src, dest|
+          raise(Foreman::Exception.new(N_('Ensure %{path} contains grubx64.efi and shimx64.efi: install TFTP module or copy those files into /var/lib/foreman/bootdisk (Grub2 directory setting)'), path: src)) unless File.exist?(src)
+          raise(Foreman::Exception.new(N_('Unable to mcopy %{path}'), path: src)) unless system("mcopy -m -i #{efibootimg} '#{src}' '#{"::/EFI/BOOT/#{dest}"}'")
         end
+        mkiso_args = "-eltorito-alt-boot -e efiboot.img -no-emul-boot"
+        isohybrod_args = ["--uefi"]
+      else
+        mkiso_args = ''
+        isohybrod_args = []
+      end
 
-        if opts[:files]
-          if opts[:files].respond_to?(:each)
-            opts[:files].each do |file, source|
-              fetch(File.join(wd, 'build', file), source)
-            end
+      if opts[:files]
+        if opts[:files].respond_to?(:each)
+          opts[:files].each do |file, source|
+            fetch(File.join(wd, 'build', file), source)
           end
         end
+      end
 
-        iso = if opts[:dir]
-                Tempfile.new(['bootdisk', '.iso'], opts[:dir]).path
-              else
-                File.join(wd, 'output.iso')
-              end
-        raise Foreman::Exception, N_('ISO build failed') unless system(build_mkiso_command(output_file: iso, source_directory: File.join(wd, 'build')))
+      iso = if opts[:dir]
+              Tempfile.new(['bootdisk', '.iso'], opts[:dir]).path
+            else
+              File.join(wd, 'output.iso')
+            end
+      raise Foreman::Exception.new(N_('ISO build failed')) unless system(build_mkiso_command(output_file: iso, extra_commands: mkiso_args, source_directory: File.join(wd, 'build')))
 
-        # Make the ISO bootable as a HDD/USB disk too
-        raise Foreman::Exception, N_('ISO hybrid conversion failed') unless system('isohybrid', iso)
+      # Make the ISO bootable as a HDD/USB disk too
+      raise Foreman::Exception.new(N_('ISO hybrid conversion failed: %s'), $?) unless system(*["isohybrid", isohybrod_args, iso].flatten.compact)
 
-        yield iso
-      end
+      yield iso
     end
 
-    def self.build_mkiso_command(output_file:, source_directory:)
+    def self.build_mkiso_command(output_file:, source_directory:, extra_commands:)
       arguments = [
         "-o #{output_file}",
         '-iso-level 2',
@@ -111,6 +173,7 @@ module ForemanBootdisk
         '-boot-load-size 4',
         '-boot-info-table'
       ]
+      arguments.push(extra_commands) unless extra_commands.nil?
       [Setting[:bootdisk_mkiso_command], arguments, source_directory].flatten.join(' ')
     end
 
@@ -121,7 +184,7 @@ module ForemanBootdisk
       '_' + expiry.strftime('%Y%m%d_%H%M')
     end
 
-    def self.fetch(path, uri)
+    def self.fetch(path, uri, limit = 10)
       dir = File.dirname(path)
       FileUtils.mkdir_p(dir) unless File.exist?(dir)
 
@@ -138,11 +201,22 @@ module ForemanBootdisk
           write_cache = use_cache
           uri = URI(uri)
           Net::HTTP.start(uri.host, uri.port) do |http|
-            request = Net::HTTP::Get.new(uri.request_uri)
+            request = Net::HTTP::Get.new(uri.request_uri, 'Accept-Encoding' => 'plain')
 
             http.request(request) do |response|
-              response.read_body do |chunk|
-                file.write chunk
+              case response
+              when Net::HTTPSuccess then
+                response.read_body do |chunk|
+                  file.write chunk
+                end
+              when Net::HTTPRedirection then
+                raise("Too many HTTP redirects when downloading #{uri}") if limit <= 0
+
+                fetch(path, response['location'], limit - 1)
+                # prevent multiple writes to the cache
+                write_cache = false
+              else
+                raise ::Foreman::Exception, N_(format("Unable to download boot file %{uri}, HTTP return code %{code}", uri: uri, code: response.code))
               end
             end
           end
@@ -151,8 +225,11 @@ module ForemanBootdisk
 
       return unless write_cache
 
+      contents = File.read(path)
+      return if contents.empty?
+
       ForemanBootdisk.logger.debug("Caching contents of #{uri}")
-      Rails.cache.write(uri, File.read(path), raw: true)
+      Rails.cache.write(uri, contents, raw: true)
     end
 
     # isolinux supports up to ISO 9660 level 2 filenames

data/app/services/foreman_bootdisk/renderer.rb

@@ -4,35 +4,46 @@ require 'uri'
 
 module ForemanBootdisk
   class Renderer
-    def generic_template_render(subnet = nil)
-      host = if subnet.present?
-               # rendering a subnet-level bootdisk requires tricking the renderer into thinking it has a
-               # valid host, without a token, but with a tftp proxy
-               Struct.new(:token, :provision_interface).new(
-                 nil,
-                 Struct.new(:subnet).new(subnet)
-               )
-             else
-               Struct.new(:token, :subnet).new(nil, nil)
-             end
-
-      render_template(template: generic_host_template, host: host)
-    end
-
-    def render_template(template:, host:, scope_class: renderer_scope)
+    def render_template(template:, host:, scope_class: renderer_scope, subnet: nil)
       source = Foreman::Renderer.get_source(
         template: template,
-        host: host
       )
       scope = Foreman::Renderer.get_scope(
         host: host,
-        klass: scope_class
+        variables: { subnet: subnet, bootdisk: true },
+        klass: scope_class,
       )
       Foreman::Renderer.render(source, scope)
     end
 
+    def generic_template_render(subnet = nil)
+      render_template(template: generic_host_template, host: stub_host(subnet), subnet: subnet)
+    end
+
+    def generic_efi_template_render(subnet)
+      if subnet.httpboot?
+        render_template(template: generic_efi_host_template, host: stub_host(subnet), subnet: subnet)
+      else
+        ForemanBootdisk.logger.warn('HTTPBOOT feature is not enabled for subnet %s, UEFI may not be available for bootdisk' % subnet.name)
+      end
+    end
+
     private
 
+    def stub_host(subnet)
+      if subnet.present?
+        # rendering a subnet-level bootdisk requires tricking the renderer into thinking it has a
+        # valid host, without a token, but with a tftp proxy
+        Struct.new(:token, :provision_interface, :content_source).new(
+          nil,
+          Struct.new(:subnet).new(subnet),
+          nil
+        )
+      else
+        Struct.new(:token, :subnet, :content_source).new(nil, nil, nil)
+      end
+    end
+
     def renderer_scope
       ForemanBootdisk::Scope::Bootdisk
     end
@@ -43,5 +54,12 @@ module ForemanBootdisk
 
       template
     end
+
+    def generic_efi_host_template
+      template = ProvisioningTemplate.unscoped.find_by(name: Setting[:bootdisk_generic_efi_host_template])
+      raise ::Foreman::Exception.new(N_('Unable to find template specified by %s setting'), 'bootdisk_generic_efi_host_template') unless template
+
+      template
+    end
   end
 end

data/app/views/foreman_bootdisk/generic_efi_host.erb

@@ -0,0 +1,64 @@
+#
+# Boot disk Grub2 EFI - generic host
+#
+#set debug="http,efinet,net"
+#set debug=all
+echo "Foreman Bootdisk: 'Boot disk Grub2 EFI - generic host' template"
+echo
+echo "********************************************************"
+echo " REQUIREMENTS:"
+echo " * SUBNET GENERIC IMAGE ONLY (host image not supported)"
+echo " * HOST PARAM default_grub_install_entry set to efi_http"
+echo " * PROXY WITH HTTPBOOT FEATURE"
+echo " * HTTP UEFI BOOT ONLY (Legacy/PXE not supported)"
+echo " * IPv4 ONLY (IPv6 not tested, change the template)"
+echo " * HTTP ONLY (change the template for HTTPS)"
+echo " * ISC DHCP (other servers not tested)"
+echo " * GRUB FROM RHEL 8.3+/7.9+ (when generating the image)"
+echo " * EFI HTTP or HTTPS grub entry must be selected in menu"
+echo " * DNS must resolve proxy hostname via DNS proxy if set"
+echo "*******************************************************"
+sleep 5
+<%
+# possible values are: "http" or "https"
+proxy_proto = "http"
+
+@subnet || bootdisk_raise("Generic disk not supported for EFI, use subnet disk")
+@subnet.template? || bootdisk_raise("Requires a proxy with template feature")
+proxy_port = if proxy_proto == "http"
+  @subnet.httpboot.httpboot_http_port
+else
+  @subnet.httpboot.httpboot_https_port
+end
+# Workaround for "no DNS server configured" https://bugzilla.redhat.com/show_bug.cgi?id=1842509
+proxy_httpboot_host = dns_lookup(@subnet.httpboot.hostname)
+proxy_template_host = dns_lookup(@subnet.template.hostname)
+-%>
+echo
+net_ls_cards
+echo "Configuring ALL cards via BOOTP/IPv4"
+net_bootp
+# uncomment here for IPv6 support (not tested)
+#echo "Configuring ALL cards via BOOTP/IPv6"
+#net_ipv6_autoconf
+net_ls_addr
+net_ls_routes
+net_ls_dns
+sleep 5
+set root=(<%= proxy_proto %>,<%= proxy_httpboot_host %>:<%= proxy_port %>)
+# The variable will not survive configfile fetch, therefore absolute path
+# must be used in the chainloaded template.
+# https://bugzilla.redhat.com/show_bug.cgi?id=1842893
+set http_path=/httpboot/
+set default=efi_<%= proxy_proto %>
+<% (0..32).each do |i| -%>
+  echo "Trying efinet<%= i %> via <%= proxy_proto %>://<%= proxy_template_host %>:<%= proxy_port %>/unattended/PXEGrub2?mac=$net_efinet<%= i %>_dhcp_mac"
+  set net_default_mac=$net_efinet<%= i %>_dhcp_mac
+  sleep 5
+  configfile (<%= proxy_proto %>,<%= proxy_template_host %>:<%= proxy_port %>)/unattended/PXEGrub2?mac=$net_efinet<%= i %>_dhcp_mac
+<% end -%>
+
+echo "Could not find a host with PXEGrub2 template and one of the MAC addresses!"
+echo "The system will poweroff in few minutes..."
+sleep 500
+poweroff

data/app/views/foreman_bootdisk/generic_static_host.erb

@@ -0,0 +1,34 @@
+#!ipxe
+#
+# Generic host template with interactive static IP configuration. Tokens
+# must be disabled in order to access templates via MAC addresses.
+#
+
+<% (0..32).each do |i| -%>
+:net<%= i %>
+isset ${net<%= i -%>/mac} || goto configure
+echo Found ${net<%= i -%>/mac} as net<%= i -%> on a ${net<%= i -%>/chip}
+goto net<%= i+1 %>
+<% end -%>
+
+:configure
+echo -n Interface (e.g. net0): && read interface
+iseq ${interface} n && goto reboot ||
+iseq ${interface} N && goto reboot ||
+
+ifopen ${interface}
+echo Please enter IPv4 details for ${interface}
+echo
+
+echo -n IP address:  && read ${interface}/ip
+echo -n Subnet mask:  && read ${interface}/netmask
+echo -n Default gateway:  && read ${interface}/gateway
+echo -n DNS server:  && read dns
+
+chain <%= bootdisk_chain_url %>${${interface}/mac} || goto reboot
+exit 0
+
+:reboot
+echo Unable to continue, rebooting...
+sleep 30
+exit 1