foreman_bootdisk 13.0.0 → 16.1.0

data/app/lib/foreman_bootdisk/scope/bootdisk.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ForemanBootdisk
   module Scope
     class Bootdisk < ::Foreman::Renderer::Scope::Provisioning

data/app/lib/foreman_bootdisk/scope/full_host_bootdisk.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ForemanBootdisk
+  module Scope
+    class FullHostBootdisk < Bootdisk
+      def kernel(medium_provider)
+        ForemanBootdisk::ISOGenerator.iso9660_filename(super)
+      end
+
+      def initrd(medium_provider)
+        ForemanBootdisk::ISOGenerator.iso9660_filename(super)
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_bootdisk/compute_resources/vmware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ForemanBootdisk
   module ComputeResources
     module Vmware
@@ -6,10 +8,10 @@ module ForemanBootdisk
       end
 
       def parse_args(args = {})
-        args = super
+        args = super(args)
         if args[:provision_method] == 'bootdisk'
           args[:cdroms] = [new_cdrom]
-          args[:boot_order] = ['cdrom', 'disk']
+          args[:boot_order] = %w[cdrom disk]
           args[:boot_retry] = 10
         end
         args

data/app/models/concerns/foreman_bootdisk/host_ext.rb

@@ -1,35 +1,47 @@
-require 'uri'
-
-module ForemanBootdisk::HostExt
-  def bootdisk_template
-    ProvisioningTemplate.unscoped.find_by_name(Setting[:bootdisk_host_template]) || raise(::Foreman::Exception.new(N_('Unable to find template specified by %s setting'), 'bootdisk_host_template'))
-  end
-
-  def bootdisk_template_render
-    ForemanBootdisk::Renderer.new.render_template(template: bootdisk_template, host: self)
-  end
-
-  def bootdisk_build?
-    provision_method == 'bootdisk'
-  end
+# frozen_string_literal: true
 
-  def bootdisk?
-    managed? && bootdisk_build? && SETTINGS[:unattended]
-  end
-
-  def bootdisk_downloadable?
-    architecture.blank? || intel_arch?
-  end
-
-  def intel_arch?
-    /i.86|x86[_-]64/ =~ architecture.name
-  end
+require 'uri'
 
-  def validate_media?
-    super || (managed && bootdisk_build? && build?)
+module ForemanBootdisk
+  module HostExt
+    def bootdisk_template
+      template = ProvisioningTemplate.unscoped.find_by(
+        name: Setting[:bootdisk_host_template]
+      )
+      unless template
+        raise ::Foreman::Exception.new(
+          N_('Unable to find template specified by %s setting'), 'bootdisk_host_template'
+        )
+      end
+      template
+    end
+
+    def bootdisk_template_render
+      ForemanBootdisk::Renderer.new.render_template(template: bootdisk_template, host: self)
+    end
+
+    def bootdisk_build?
+      provision_method == 'bootdisk'
+    end
+
+    def bootdisk?
+      managed? && bootdisk_build? && SETTINGS[:unattended]
+    end
+
+    def bootdisk_downloadable?
+      architecture.blank? || intel_arch?
+    end
+
+    def intel_arch?
+      /i.86|x86[_-]64/ =~ architecture.name
+    end
+
+    def can_be_built?
+      super || (managed? && SETTINGS[:unattended] && bootdisk_build? && !build?)
+    end
   end
+end
 
-  def can_be_built?
-    super || (managed? and SETTINGS[:unattended] and bootdisk_build? and !build?)
-  end
+class Host::Managed::Jail < Safemode::Jail
+  allow :bootdisk_build?
 end

data/app/models/concerns/foreman_bootdisk/orchestration/compute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tmpdir'
 
 module ForemanBootdisk
@@ -21,6 +23,7 @@ module ForemanBootdisk
       def queue_bootdisk_compute
         return unless compute? && errors.empty? && new_record?
         return unless provision_method == 'bootdisk'
+
         queue.create(name: _('Generating ISO image for %s') % self, priority: 5,
                      action: [self, :setGenerateIsoImage])
         queue.create(name: _('Upload ISO image to datastore for %s') % self, priority: 6,
@@ -44,10 +47,10 @@ module ForemanBootdisk
       end
 
       def setGenerateIsoImage
-        logger.info 'Generating ISO image for %s' % name
+        logger.info format('Generating ISO image for %s', name)
         bootdisk_generate_iso_image
-      rescue => e
-        failure _('Failed to generate ISO image for instance %{name}: %{message}') % { name: name, message: e.message }, e
+      rescue StandardError => e
+        failure format(_('Failed to generate ISO image for instance %{name}: %{message}'), name: name, message: e.message), e
       end
 
       def delGenerateIsoImage; end
@@ -55,29 +58,30 @@ module ForemanBootdisk
       def setIsoImage
         logger.info "Uploading ISO image #{bootdisk_isofile} for #{name}"
         bootdisk_upload_iso
-      rescue => e
-        failure _('Failed to upload ISO image for instance %{name}: %{message}') % { name: name, message: e.message }, e
+      rescue StandardError => e
+        failure format(_('Failed to upload ISO image for instance %{name}: %{message}'), name: name, message: e.message), e
       end
 
       def delIsoImage; end
 
       def setAttachIsoImage
-        logger.info 'Attaching ISO image to CDROM drive for %s' % name
+        logger.info format('Attaching ISO image to CDROM drive for %s', name)
         bootdisk_attach_iso
-      rescue => e
-        failure _('Failed to attach ISO image to CDROM drive of instance %{name}: %{message}') % { name: name, message: e.message }, e
+      rescue StandardError => e
+        failure format(_('Failed to attach ISO image to CDROM drive of instance %{name}: %{message}'), name: name, message: e.message), e
       end
 
       def delAttachIsoImage; end
 
       def rebuild_with_bootdisk
         return true unless bootdisk?
+
         begin
           bootdisk_generate_iso_image
           bootdisk_upload_iso
           bootdisk_attach_iso
-        rescue => e
-          Foreman::Logging.exception "Failed to rebuild Bootdisk image for #{name}", e, :level => :error
+        rescue StandardError => e
+          Foreman::Logging.exception "Failed to rebuild Bootdisk image for #{name}", e, level: :error
           return false
         end
       end

data/app/models/setting/bootdisk.rb

@@ -1,30 +1,28 @@
-class Setting::Bootdisk< ::Setting
-  def self.load_defaults
-    return unless ApplicationRecord.connection.table_exists?('settings')
-    return unless super
+# frozen_string_literal: true
 
-    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'
-    templates = -> { Hash[ProvisioningTemplate.where(:template_kind => TemplateKind.where(:name => 'Bootdisk')).map{|temp| [temp[:name], temp[:name]]}] }
+class Setting
+  class Bootdisk < ::Setting
+    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'
+      templates = -> { Hash[ProvisioningTemplate.where(template_kind: TemplateKind.where(name: 'Bootdisk')).map { |temp| [temp[:name], temp[:name]] }] }
 
-    Setting.transaction do
       [
-        self.set('bootdisk_ipxe_dir', N_('Path to directory containing iPXE images'), ipxe, N_('iPXE directory')),
-        self.set('bootdisk_isolinux_dir', N_('Path to directory containing isolinux images'), isolinux, N_('ISOLINUX directory')),
-        self.set('bootdisk_syslinux_dir', N_('Path to directory containing syslinux images'), syslinux, N_('SYSLINUX directory')),
-        self.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),
-        self.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),
-        self.set('bootdisk_mkiso_command', N_('Command to generate ISO image, use genisoimage or mkisofs'), 'genisoimage', N_('ISO generation command')),
-        self.set('bootdisk_cache_media', N_('Installation media files will be cached for full host images'), true, N_('Installation media caching')),
-      ].compact.each { |s| self.create s.update(:category => "Setting::Bootdisk") }
+        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'))
+      ]
     end
 
-    true
-
-  end
-
-  def self.humanized_category
-    N_('Boot disk')
+    def self.humanized_category
+      N_('Boot disk')
+    end
   end
 end

data/app/services/foreman_bootdisk/iso_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'tempfile'
 require 'tmpdir'
@@ -6,137 +8,175 @@ require 'uri'
 # Generates an iPXE ISO hybrid image
 #
 # requires syslinux, ipxe/ipxe-bootimgs, genisoimage, isohybrid
-class ForemanBootdisk::ISOGenerator
-  def self.generate_full_host(host, opts = {}, &block)
-    raise ::Foreman::Exception.new(N_('Host is not in build mode, so the template cannot be rendered')) unless host.build?
-
-    tmpl = host.send(:generate_pxe_template, :PXELinux)
-    unless tmpl
-      err = host.errors.full_messages.to_sentence
-      raise ::Foreman::Exception.new(N_('Unable to generate disk template, PXELinux template not found or: %s'), err)
+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?
+
+      tmpl = render_pxelinux_template(host)
+
+      # 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
+      # and then still ensure that the fetch() process stores them under the same name
+      files = host.operatingsystem.family.constantize::PXEFILES.keys.each_with_object({}) do |type, hash|
+        filename = host.operatingsystem.bootfile(host.medium_provider, type)
+        iso_filename = iso9660_filename(filename)
+        hash[iso_filename] = host.url_for_boot(type)
+      end
+
+      generate(opts.merge(isolinux: tmpl, files: files), &block)
     end
 
-    # pxe_files and filename conversion is utterly bizarre
-    # aim to convert filenames to something usable under ISO 9660, update the template to match
-    # and then still ensure that the fetch() process stores them under the same name
-    files = host.operatingsystem.pxe_files(host.medium, host.architecture, host)
-    files.map! do |bootfile_info|
-      bootfile_info.map do |f|
-        suffix = f[1].split('/').last
-        iso_f0 = iso9660_filename(f[0].to_s + '_' + suffix)
-        tmpl.gsub!(f[0].to_s + '-' + suffix, iso_f0)
-        ForemanBootdisk.logger.debug("Boot file #{iso_f0}, source #{f[1]}")
-        [iso_f0, f[1]]
+    def self.render_pxelinux_template(host)
+      pxelinux_template = host.provisioning_template(kind: :PXELinux)
+
+      raise(Foreman::Exception, N_('Unable to generate disk template, PXELinux template not found.')) unless pxelinux_template
+
+      template = ForemanBootdisk::Renderer.new.render_template(
+        template: pxelinux_template,
+        host: host,
+        scope_class: ForemanBootdisk::Scope::FullHostBootdisk
+      )
+
+      unless template
+        err = host.errors.full_messages.to_sentence
+        raise(::Foreman::Exception.new(N_('Unable to generate disk PXELinux template: %s'), err))
       end
+
+      template
     end
 
-    generate(opts.merge(:isolinux => tmpl, :files => files), &block)
-  end
+    def self.generate(opts = {})
+      opts[:isolinux] = <<~ISOLINUX if opts[:isolinux].nil? && opts[:ipxe]
+        default ipxe
+        label ipxe
+        kernel /ipxe
+        initrd /script
+      ISOLINUX
 
-  def self.generate(opts = {}, &block)
-    opts[:isolinux] = <<-EOS if opts[:isolinux].nil? && opts[:ipxe]
-      default ipxe
-      label ipxe
-      kernel /ipxe
-      initrd /script
-    EOS
+      Dir.mktmpdir('bootdisk') do |wd|
+        Dir.mkdir(File.join(wd, 'build'))
 
-    Dir.mktmpdir('bootdisk') do |wd|
-      Dir.mkdir(File.join(wd, 'build'))
+        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)
 
-      if opts[:isolinux]
-        unless File.exists?(File.join(Setting[:bootdisk_isolinux_dir], 'isolinux.bin'))
-          raise ::Foreman::Exception.new(N_("Please ensure the isolinux/syslinux package(s) are installed."))
-        end
-        FileUtils.cp(File.join(Setting[:bootdisk_isolinux_dir], 'isolinux.bin'), File.join(wd, 'build', 'isolinux.bin'))
-        if File.exist?(File.join(Setting[:bootdisk_syslinux_dir], 'ldlinux.c32'))
-          FileUtils.cp(File.join(Setting[:bootdisk_syslinux_dir], 'ldlinux.c32'), File.join(wd, 'build', 'ldlinux.c32'))
-        end
-        File.open(File.join(wd, 'build', 'isolinux.cfg'), 'w') do |file|
-          file.write(opts[:isolinux])
+          FileUtils.cp(isolinux_source_file, File.join(wd, 'build', 'isolinux.bin'))
+
+          source_files = ['ldlinux.c32', 'menu.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
-      end
 
-      if opts[:ipxe]
-        unless File.exists?(File.join(Setting[:bootdisk_ipxe_dir], 'ipxe.lkrn'))
-          raise ::Foreman::Exception.new(N_("Please ensure the ipxe-bootimgs package is installed."))
+        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(File.join(Setting[:bootdisk_ipxe_dir], 'ipxe.lkrn'), File.join(wd, 'build', 'ipxe'))
-        File.open(File.join(wd, 'build', 'script'), 'w') { |file| file.write(opts[:ipxe]) }
-      end
 
-      if opts[:files]
-        opts[:files].each do |bootfile_info|
-          for file, source in bootfile_info do
-            fetch(File.join(wd, 'build', file), source)
+        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 if opts[:files].respond_to? :each
-      end
+        end
 
-      iso = if opts[:dir]
-              Tempfile.new(['bootdisk', '.iso'], opts[:dir]).path
-            else
-              File.join(wd, 'output.iso')
-            end
-      unless system("#{Setting[:bootdisk_mkiso_command]} -o #{iso} -iso-level 2 -b isolinux.bin -c boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table #{File.join(wd, 'build')}")
-        raise ::Foreman::Exception.new(N_("ISO build failed"))
-      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')))
+
+        # 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
-      unless system("isohybrid", iso)
-        raise ::Foreman::Exception.new(N_("ISO hybrid conversion failed"))
+        yield iso
       end
+    end
 
-      yield iso
+    def self.build_mkiso_command(output_file:, source_directory:)
+      arguments = [
+        "-o #{output_file}",
+        '-iso-level 2',
+        '-b isolinux.bin',
+        '-c boot.cat',
+        '-no-emul-boot',
+        '-boot-load-size 4',
+        '-boot-info-table'
+      ]
+      [Setting[:bootdisk_mkiso_command], arguments, source_directory].flatten.join(' ')
     end
-  end
 
-  def self.token_expiry(host)
-    expiry = host.token.try(:expires)
-    return '' if Setting[:token_duration] == 0 || expiry.blank?
-    '_' + expiry.strftime('%Y%m%d_%H%M')
-  end
+    def self.token_expiry(host)
+      expiry = host.token.try(:expires)
+      return '' if Setting[:token_duration].zero? || expiry.blank?
+
+      '_' + expiry.strftime('%Y%m%d_%H%M')
+    end
 
-  private
-
-  def self.fetch(path, uri)
-    dir = File.dirname(path)
-    FileUtils.mkdir_p(dir) unless File.exist?(dir)
-
-    use_cache = !!Setting[:bootdisk_cache_media]
-    write_cache = false
-    File.open(path, 'w') do |file|
-      file.binmode
-
-      if use_cache && !(contents = Rails.cache.fetch(uri, :raw => true)).nil?
-        ForemanBootdisk.logger.info("Retrieved #{uri} from local cache (use foreman-rake tmp:cache:clear to empty)")
-        file.write(contents)
-      else
-        ForemanBootdisk.logger.info("Fetching #{uri}")
-        write_cache = use_cache
-        uri = URI(uri)
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          request = Net::HTTP::Get.new uri.request_uri
-
-          http.request request do |response|
-            response.read_body do |chunk|
-              file.write chunk
+    def self.fetch(path, uri, limit = 10)
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+
+      use_cache = !!Setting[:bootdisk_cache_media]
+      write_cache = false
+      File.open(path, 'w') do |file|
+        file.binmode
+
+        if use_cache && !(contents = Rails.cache.fetch(uri, raw: true)).nil?
+          ForemanBootdisk.logger.info("Retrieved #{uri} from local cache (use foreman-rake tmp:cache:clear to empty)")
+          file.write(contents)
+        else
+          ForemanBootdisk.logger.info("Fetching #{uri}")
+          write_cache = use_cache
+          uri = URI(uri)
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            request = Net::HTTP::Get.new(uri.request_uri, 'Accept-Encoding' => 'plain')
+
+            http.request(request) do |response|
+              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
         end
       end
-    end
 
-    if write_cache
+      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
-  end
 
-  # isolinux supports up to ISO 9660 level 2 filenames
-  def self.iso9660_filename(name)
-    dir  = File.dirname(name)
-    file = File.basename(name).upcase.tr_s('^A-Z0-9_', '_').last(28)
-    dir == '.' ? file : File.join(dir.upcase.tr_s('^A-Z0-9_', '_').last(28), file)
+    # isolinux supports up to ISO 9660 level 2 filenames
+    def self.iso9660_filename(name)
+      dir  = File.dirname(name)
+      file = File.basename(name).upcase.tr_s('^A-Z0-9_', '_').last(28)
+      dir == '.' ? file : File.join(dir.upcase.tr_s('^A-Z0-9_', '_').last(28), file)
+    end
   end
 end