foreman_fog_proxmox 0.25.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 329a340fdfd2b5e117a05a227477e29108df61d303a5ce5a5a2dc148ae41ec7c
-  data.tar.gz: '08b9aa3dca59fb2b7a80c2f1e6b0b59c9931f0d974e8d9849a720d6d37a819be'
+  metadata.gz: 9dcd1a0e6c90d8847b0e31986425ab3354e4659676994ea6ab84ec9648b0d17d
+  data.tar.gz: 8dc424df461ebfe7f7cf07f11e7fecebf56fa75c3bdb4c52b51ef2fdcda01fa5
 SHA512:
-  metadata.gz: '094a19a8592b2ed3ad7a88c637c7859f3bbc631a4f08f2fb781ec21a8b9620789fb701dbab917973ee122fb2ead5a44d6af12a28fe6dd2d99dad2267c8d051a7'
-  data.tar.gz: ce956eaac9a5faf92f2decd8721910dd72fd9a0e7f0ccfbeab40462c1cfc7892897235e7d2fef925405abf993b85f902edac0f4afcb1ec685649d27df0e61168
+  metadata.gz: a99138711e3912f07dfe3c875106745d543db41e466fbf50460a3fd9abab1476e1da72620f2233d4455984698c64763b849c87f317131d6021b458f1150ea2f5
+  data.tar.gz: 852428fd8ed987daca7f45d0908a8b9d71ecbacb9affe3bd65fdc9ecff12b7be80859ea3071d59bd00d8182d5bd75eac1510f922e9c3977be6fd638a879e8187

data/app/assets/javascripts/foreman_fog_proxmox/proxmox_network_interface_modal.js

@@ -0,0 +1,11 @@
+$(document)
+  .on('show.bs.modal', '#interfaceModal', function () {
+    var modal = $(this);
+    modal.toggleClass(
+      'proxmox-interface-modal',
+      modal.find('.proxmox-interface-form').length > 0
+    );
+  })
+  .on('hidden.bs.modal', '#interfaceModal', function () {
+    $(this).removeClass('proxmox-interface-modal');
+  });

data/app/assets/stylesheets/foreman_fog_proxmox/network_interface_modal.css

@@ -0,0 +1,17 @@
+#interfaceModal.proxmox-interface-modal {
+  overflow-y: hidden;
+}
+
+#interfaceModal.proxmox-interface-modal .modal-content {
+  display: flex;
+  flex-direction: column;
+  max-height: 90vh;
+  overflow: hidden;
+}
+
+#interfaceModal.proxmox-interface-modal .modal-body {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
+}

data/app/controllers/foreman_fog_proxmox/compute_resources_controller.rb

@@ -95,20 +95,21 @@ module ForemanFogProxmox
     # GET foreman_fog_proxmox/metadata/:compute_resource_id
     def metadata
       cr = ComputeResource.find(params[:compute_resource_id])
+      nodes = Array(cr.nodes)
 
       render json: {
-        nodes: extract_nodes(cr),
+        nodes: extract_nodes(nodes),
         pools: extract_pools(cr),
-        storages: extract_storages(cr),
-        bridges: extract_bridges(cr),
+        storages: extract_storages(cr, nodes),
+        bridges: extract_bridges(cr, nodes),
         images: extract_images(cr),
       }
     end
 
     private
 
-    def extract_nodes(compute_resource)
-      Array(compute_resource.nodes).map { |n| { node: n.node } }
+    def extract_nodes(nodes)
+      nodes.map { |n| { node: n.node } }
     end
 
     def extract_pools(compute_resource)
@@ -118,27 +119,34 @@ module ForemanFogProxmox
       end
     end
 
-    def extract_storages(compute_resource)
-      Array(compute_resource.storages).map do |s|
-        h = s.respond_to?(:as_json) ? s.as_json : s
-        {
-          storage: (h[:storage] || h['storage']),
-          node_id: (h[:node_id] || h['node_id']),
-          content: (h[:content] || h['content']),
-          avail: (h[:avail] || h['avail']),
-          used: (h[:used] || h['used']),
-          total: (h[:total] || h['total']),
-        }
+    def extract_storages(compute_resource, nodes)
+      nodes.flat_map do |node|
+        node_id = node.node
+        Array(compute_resource.storages(node_id)).map do |storage|
+          h = storage.respond_to?(:as_json) ? storage.as_json : storage
+          {
+            storage: (h[:storage] || h['storage']),
+            node_id: node_id,
+            content: (h[:content] || h['content']),
+            avail: (h[:avail] || h['avail']),
+            used: (h[:used] || h['used']),
+            total: (h[:total] || h['total']),
+            shared: (h[:shared] || h['shared']),
+          }
+        end
       end
     end
 
-    def extract_bridges(compute_resource)
-      Array(compute_resource.bridges).map do |b|
-        h = b.respond_to?(:as_json) ? b.as_json : b
-        {
-          node_id: (h[:node_id] || h['node_id']),
-          iface: (h[:iface] || h['iface']),
-        }
+    def extract_bridges(compute_resource, nodes)
+      nodes.flat_map do |node|
+        node_id = node.node
+        Array(compute_resource.bridges(node_id)).map do |bridge|
+          h = bridge.respond_to?(:as_json) ? bridge.as_json : bridge
+          {
+            node_id: node_id,
+            iface: (h[:iface] || h['iface']),
+          }
+        end
       end
     end
 

data/app/helpers/proxmox_compute_controllers_helper.rb

@@ -18,15 +18,17 @@
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
 module ProxmoxComputeControllersHelper
+  CONTROLLER_LIMITS = { 'ide' => 3, 'sata' => 5, 'scsi' => 30, 'virtio' => 15 }.freeze
+
   def proxmox_controllers_map
     proxmox_controllers_cloudinit_map << ForemanFogProxmox::OptionsSelect.new(name: 'VirtIO Block', id: 'virtio',
-      range: 15)
+      range: CONTROLLER_LIMITS['virtio'])
   end
 
   def proxmox_controllers_cloudinit_map
-    [ForemanFogProxmox::OptionsSelect.new(id: 'ide', name: 'IDE', range: 3),
-     ForemanFogProxmox::OptionsSelect.new(id: 'sata', name: 'SATA', range: 5),
-     ForemanFogProxmox::OptionsSelect.new(id: 'scsi', name: 'SCSI', range: 13)]
+    [ForemanFogProxmox::OptionsSelect.new(id: 'ide', name: 'IDE', range: CONTROLLER_LIMITS['ide']),
+     ForemanFogProxmox::OptionsSelect.new(id: 'sata', name: 'SATA', range: CONTROLLER_LIMITS['sata']),
+     ForemanFogProxmox::OptionsSelect.new(id: 'scsi', name: 'SCSI', range: CONTROLLER_LIMITS['scsi'])]
   end
 
   def proxmox_scsi_controllers_map

data/app/helpers/proxmox_compute_selectors_helper.rb

@@ -141,6 +141,7 @@ module ProxmoxComputeSelectorsHelper
 
   def proxmox_bios_map
     [OpenStruct.new(id: 'seabios', name: '(Default) Seabios'),
-     OpenStruct.new(id: 'ovmf', name: 'OVMF (UEFI)')]
+     OpenStruct.new(id: 'ovmf', name: 'OVMF (UEFI)'),
+     OpenStruct.new(id: 'uefi_secure_boot', name: 'OVMF (UEFI Secure Boot)')]
   end
 end

data/app/helpers/proxmox_vm_attrs_helper.rb

@@ -130,10 +130,12 @@ module ProxmoxVMAttrsHelper
       hostname: vms.config.hostname,
       ostemplate_storage: vms.ostemplate_storage,
       ostemplate_file: vms.ostemplate_file,
+      iso_upload_storage: vms.iso_upload_storage,
       start_after_create: vms.start_after_create,
       templated: vms.templated,
+      is_secure_boot: vms.config.secure_boot?,
     }
-    vms_keys = [:cpu_type, :nameserver, :searchdomain, :hostname]
+    vms_keys = [:cpu_type, :nameserver, :searchdomain, :hostname, :is_secure_boot]
     extra_attrs = ActiveSupport::HashWithIndifferentAccess.new
     attributes.each do |key, value|
       camel_key = key.to_s.include?('_') ? snake_to_camel(key.to_s).to_sym : key

data/app/helpers/proxmox_vm_cloudinit_helper.rb

@@ -21,6 +21,9 @@ require 'fog/proxmox/helpers/disk_helper'
 require 'fog/proxmox/helpers/nic_helper'
 require 'foreman_fog_proxmox/value'
 require 'foreman_fog_proxmox/hash_collection'
+require 'fileutils'
+require 'open3'
+require 'tmpdir'
 
 # Convert a foreman form server hash into a fog-proxmox server attributes hash
 module ProxmoxVMCloudinitHelper
@@ -42,54 +45,59 @@ module ProxmoxVMCloudinitHelper
     cloudinit_h
   end
 
-  def create_cloudinit_iso(vm_name, configs, ssh)
-    iso = File.join(default_iso_path, "#{vm_name.tr('.', '_')}_cloudinit.iso")
+  def create_cloudinit_iso(vm_name, configs)
+    wd = create_temp_directory
+    iso = File.join(wd, "#{vm_name.tr('.', '_')}_cloudinit.iso")
     files = []
-    wd = create_temp_directory(ssh)
 
     configs.each do |config|
-      config_file = ssh.run("cat <<'EOF' > '#{wd}/#{config[0]}'\n#{config[1]}\nEOF")
-      unless config_file.first.status.zero?
-        delete_temp_dir(ssh, wd)
-        raise ::Foreman::Exception, "Failed to create file #{config[0]}: #{config_file.first.stdout}"
-      end
-      files.append(File.join(wd, config[0]))
+      config_file = File.join(wd, config[0])
+      File.write(config_file, config[1])
+      files.append(config_file)
     end
-    generated_iso = ssh.run(generate_iso_command(iso, files))
-    unless generated_iso.first.status.zero?
-      delete_temp_dir(ssh, wd)
-      raise Foreman::Exception, N_("ISO build failed: #{generated_iso.first.stdout}")
-    end
-    delete_temp_dir(ssh, wd)
-    iso
+    logger.debug("Generating cloud-init ISO at #{iso}")
+    stdout, stderr, status = Open3.capture3(*generate_iso_command(iso, files))
+    raise Foreman::Exception, N_("ISO build failed: #{stderr.presence || stdout}") unless status.success?
+
+    yield iso
+  ensure
+    delete_temp_dir(wd) if wd && Dir.exist?(wd)
   end
 
   def generate_iso_command(iso_file, config_files)
-    arguments = ["genisoimage", "-output #{iso_file}", '-volid', 'cidata', '-joliet', '-rock']
-    iso_command = arguments.concat(config_files).join(' ')
-    logger.debug("iso image generation args: #{iso_command}")
-    iso_command
+    arguments = ["genisoimage", '-output', iso_file, '-volid', 'cidata', '-joliet', '-rock']
+    arguments.concat(config_files)
+    logger.debug("iso image generation args: #{arguments.join(' ')}")
+    arguments
   end
 
-  def create_temp_directory(ssh)
-    res = ssh.run("mktemp -d")
-    raise ::Foreman::Exception, "Could not create working directory to store cloudinit config data: #{res.first.stdout}." unless res.first.status.zero?
-    res.first.stdout.chomp
+  def create_temp_directory
+    Dir.mktmpdir
+  rescue StandardError => e
+    raise ::Foreman::Exception, "Could not create working directory to store cloudinit config data: #{e}."
   end
 
-  def delete_temp_dir(ssh, working_dir)
-    ssh.run("rm -rf #{working_dir}")
-  rescue Foreman::Exception => e
+  def delete_temp_dir(working_dir)
+    FileUtils.remove_entry(working_dir)
+  rescue StandardError => e
     logger.warn("Could not delete directory for config files: #{e}. Please delete it manually at #{working_dir}")
   end
 
-  def parse_cloudinit_config(args)
+  def cloudinit_clone_args(args, vm_instance)
+    return args unless args[:user_data]
+
+    actual_node = vm_instance.node_id
+    logger.info("Cloud-init ISO storage will be validated for cloned VM node #{actual_node} instead of selected node #{args[:node_id]}") if args[:node_id] != actual_node
+
+    parse_cloudinit_config(args, vm_node: actual_node)
+  end
+
+  def parse_cloudinit_config(args, vm_node: args[:node_id])
     filenames = ["meta-data"]
     config_data = ["instance-id: #{args[:name]}"]
     user_data = args.delete(:user_data)
     return args if user_data == ''
     check_template_format(user_data)
-    ssh = vm_ssh
 
     if user_data.include?('#network-config') && user_data.include?('#cloud-config')
       config_data.concat(user_data.split('#network-config'))
@@ -105,40 +113,39 @@ module ProxmoxVMCloudinitHelper
     return args if config_data.length == 1
     configs = filenames.zip(config_data).to_h
 
-    iso = create_cloudinit_iso(args[:name], configs, ssh)
-    args[:config_attributes]&.merge!(update_boot_order(args[:image_id]))
-    args.merge!(attach_cloudinit_iso(args[:node_id], iso))
+    create_cloudinit_iso(args[:name], configs) do |iso|
+      storage = upload_iso(args[:node_id], args[:iso_upload_storage], iso, vm_node: vm_node)
+      args.merge!(attach_cloudinit_iso(vm_node, storage, iso))
+    end
   end
 
-  def attach_cloudinit_iso(node, iso)
-    volume = nil
-    storages(node, 'iso').each do |storage|
-      volume = storage.volumes.detect { |v| v.volid.include? File.basename(iso) }
-      break if volume
-    end
+  def upload_iso(node, storage_id, iso, vm_node: node)
+    raise ::Foreman::Exception, _('ISO upload storage must be selected') if storage_id.blank?
 
-    raise ::Foreman::Exception, "Could not find generated cloud-init ISO #{File.basename(iso)} on any ISO storage for node #{node}" unless volume
+    iso_storages = storages(node, 'iso')
+    storage = iso_storages.find { |s| s.identity == storage_id }
+    raise ::Foreman::Exception, "Could not find selected ISO upload storage #{storage_id} for node #{node}" unless storage
 
-    { ide2: "#{volume.volid},media=cdrom" }
-  end
+    if node != vm_node
+      vm_storage = storages(vm_node, 'iso').find { |s| s.identity == storage_id }
+      raise ::Foreman::Exception, "Selected ISO upload storage #{storage_id} is not accessible from cloned VM node #{vm_node}" unless vm_storage
 
-  def default_iso_path
-    "/var/lib/vz/template/iso"
-  end
+      storage = vm_storage
+    end
 
-  def update_boot_order(image_id)
-    vm = find_vm_by_uuid(image_id)
-    return if vm.disks.nil?
-    disks = vm.disks.map { |disk| disk.split(":")[0] }.join(";")
-    { boot: "order=" + disks }
+    storage.upload_iso(iso)
+    storage.identity
   end
 
-  def vm_ssh
-    ssh = Fog::SSH.new(URI.parse(fog_credentials[:proxmox_url]).host, fog_credentials[:proxmox_username].split('@')[0], { password: fog_credentials[:proxmox_password] })
-    ssh.run('ls') # test if ssh is successful
-    ssh
-  rescue StandardError => e
-    raise ::Foreman::Exception, "Unable to ssh into proxmox server: #{e}"
+  def attach_cloudinit_iso(node, storage_id, iso)
+    storage = client.nodes.get(node).storages.get(storage_id)
+    volume = storage&.volumes&.all&.detect do |v|
+      File.basename(v.volid) == File.basename(iso)
+    end
+
+    raise ::Foreman::Exception, "Could not find generated cloud-init ISO #{File.basename(iso)} on storage #{storage_id} for node #{node}" unless volume
+
+    { ide2: "#{volume.volid},media=cdrom" }
   end
 
   def check_template_format(user_data)

data/app/helpers/proxmox_vm_config_helper.rb

@@ -41,7 +41,7 @@ module ProxmoxVMConfigHelper
 
   def general_a(type)
     general_a = ['node_id', 'type', 'config_attributes', 'efidisk_attributes', 'volumes_attributes', 'interfaces_attributes', 'image_id']
-    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
+    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create', 'iso_upload_storage']
     general_a += ['name'] if type == 'lxc'
     general_a
   end
@@ -60,7 +60,9 @@ module ProxmoxVMConfigHelper
       cpu_a += ForemanFogProxmox::HashCollection.stringify_keys(Fog::Proxmox::CpuHelper.flags).keys
       memory_a = ['memory', 'balloon', 'shares']
       cloud_init_a = ['ciuser', 'cipassword', 'searchdomain', 'nameserver']
+      firmware_a = ['is_secure_boot']
       keys.store(:cloud_init, cloud_init_a)
+      keys.store(:firmware, firmware_a)
     end
     keys.store(:main, main_a)
     keys.store(:cpu, cpu_a)
@@ -76,7 +78,7 @@ module ProxmoxVMConfigHelper
     config_a = []
     case type
     when 'qemu'
-      [:cpu, :memory, :general, :cloud_init].each { |key| config_a += config_typed_keys(type)[key] }
+      [:cpu, :memory, :general, :cloud_init, :firmware].each { |key| config_a += config_typed_keys(type)[key] }
     when 'lxc'
       [:main].each { |key| config_a += config_typed_keys(type)[key] }
     end

data/app/helpers/proxmox_vm_efidisk_helper.rb

@@ -23,6 +23,70 @@ require 'foreman_fog_proxmox/hash_collection'
 
 # Convert a foreman form server hash into a fog-proxmox server attributes hash
 module ProxmoxVMEfidiskHelper
+  def process_firmware_attributes(args, type)
+    return args unless type == 'qemu'
+    return args unless args
+
+    normalized_args = ActiveSupport::HashWithIndifferentAccess.new(args)
+    config = normalized_args[:config_attributes] || normalized_args
+    return args unless config.key?(:bios) || config.key?(:is_secure_boot)
+
+    args = normalized_args
+
+    bios = config[:bios]
+    secure_boot_value = config[:is_secure_boot]
+    secure_boot = bios == 'uefi_secure_boot' ||
+                  (bios == 'ovmf' && Foreman::Cast.to_bool(secure_boot_value))
+    config[:is_secure_boot] = secure_boot ? '1' : '0'
+
+    unless secure_boot
+      normalize_pre_enrolled_keys(args)
+      return args
+    end
+
+    config[:bios] = 'ovmf'
+    process_secure_boot_efidisk(args, config)
+  end
+
+  def normalize_pre_enrolled_keys(args)
+    efidisk = args[:efidisk_attributes]
+    return args if ForemanFogProxmox::Value.empty?(efidisk)
+
+    efidisk[:pre_enrolled_keys] = '0'
+    args
+  end
+
+  def process_secure_boot_efidisk(args, config)
+    efidisk = args[:efidisk_attributes]
+    unless ForemanFogProxmox::Value.empty?(efidisk)
+      args[:efidisk_attributes] = secure_boot_efidisk_attributes(
+        efidisk.merge('efitype' => '4m', 'pre_enrolled_keys' => '1')
+      )
+      return args
+    end
+
+    volumes = args[:volumes_attributes] || config[:volumes_attributes]
+    storage = volumes&.each_value&.filter_map { |volume| volume[:storage] }&.find(&:present?)
+    return args if ForemanFogProxmox::Value.empty?(storage)
+
+    args[:efidisk_attributes] = secure_boot_efidisk_attributes(storage: storage)
+    args
+  end
+
+  def efidisk_defaults(storage)
+    {
+      'id' => '0',
+      'volid' => "#{storage}:0",
+      'efitype' => '4m',
+      'pre_enrolled_keys' => '1',
+    }
+  end
+
+  def secure_boot_efidisk_attributes(attr = {})
+    attr = attr.to_h.stringify_keys
+    efidisk_defaults(attr['storage']).merge(attr)
+  end
+
   def parsed_typed_efidisk(args, type, parsed_vm)
     attrs = args['efidisk_attributes']
 

data/app/helpers/proxmox_vm_helper.rb

@@ -19,11 +19,13 @@
 
 require 'fog/proxmox/helpers/disk_helper'
 require 'fog/proxmox/helpers/nic_helper'
+require 'foreman_fog_proxmox/hash_collection'
 require 'foreman_fog_proxmox/value'
 
 module ProxmoxVMHelper
   include ProxmoxVMInterfacesHelper
   include ProxmoxVMVolumesHelper
+  include ProxmoxVMImageTemplateHelper
   include ProxmoxVMConfigHelper
   include ProxmoxVMOsTemplateHelper
   include ProxmoxVMEfidiskHelper
@@ -34,8 +36,28 @@ module ProxmoxVMHelper
     collection
   end
 
+  def parse_vm_update_attributes(attributes, type)
+    ForemanFogProxmox::HashCollection.new_hash_reject_keys(
+      attributes, ['volumes_attributes']
+    ).merge(type: type)
+  end
+
+  def update_boot_order(instance, exclude_cdrom: false, include_network: false)
+    return {} unless instance
+
+    disks = Array(instance.disks).map { |disk| disk.split(":")[0] }
+    disks.delete("ide2") if exclude_cdrom
+    network_interfaces = include_network ? Array(instance.interfaces).map(&:id) : []
+    boot_devices = network_interfaces + disks
+
+    return {} if boot_devices.empty?
+
+    { boot: "order=" + boot_devices.join(";") }
+  end
+
   # Convert a foreman form server/container vm hash into a fog-proxmox server/container attributes hash
   def parse_typed_vm(args, type)
+    args = process_firmware_attributes(args, type)
     args = ActiveSupport::HashWithIndifferentAccess.new(args)
     return {} unless args
     return {} if args.empty?

data/app/helpers/proxmox_vm_image_template_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
+
+require 'fog/proxmox/helpers/disk_helper'
+
+module ProxmoxVMImageTemplateHelper
+  def validate_image_template_disk_slots!(image, args)
+    reserved_slots = image.config.disks.select(&:hard_disk?).map(&:id)
+    limits = ProxmoxComputeControllersHelper::CONTROLLER_LIMITS
+    volumes = args['volumes_attributes']&.values || []
+    used_slots = reserved_slots + volumes.filter_map { |volume| hard_disk_slot(volume) }
+
+    volumes.each do |volume_attributes|
+      volume = volume_attributes.with_indifferent_access
+      slot = hard_disk_slot(volume_attributes)
+      next unless slot
+
+      controller = volume[:controller]
+      if reserved_slots.include?(slot)
+        device = (0..limits.fetch(controller, -1)).find do |number|
+          !used_slots.include?("#{controller}#{number}")
+        end
+        unless device
+          raise ::Foreman::Exception,
+            format(_('No free disk device is available for the %<controller>s controller.'), controller: controller)
+        end
+
+        volume_attributes['device'] = device.to_s
+        volume_attributes['id'] = slot = "#{controller}#{device}"
+      end
+      used_slots << slot
+    end
+  end
+
+  def hard_disk_slot(attributes)
+    volume = attributes.with_indifferent_access
+    id = volume[:id]
+    id if volume_type?(volume, 'hard_disk') &&
+          Fog::Proxmox::DiskHelper.server_disk?(id)
+  end
+end

data/app/models/concerns/fog_extensions/proxmox/server.rb

@@ -21,7 +21,7 @@ module FogExtensions
   module Proxmox
     module Server
       extend ActiveSupport::Concern
-      attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password, :start_after_create, :compute_resource_id
+      attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :iso_upload_storage, :password, :start_after_create, :compute_resource_id
 
       def unique_cluster_identity(compute_resource)
         compute_resource.id.to_s + '_' + identity.to_s

data/app/models/concerns/fog_extensions/proxmox/server_config.rb

@@ -44,6 +44,15 @@ module FogExtensions
       def cloud_init?
         disks.any?(&:cloud_init?)
       end
+
+      def secure_boot?
+        attrs = attributes.with_indifferent_access
+        secure_boot = attrs[:is_secure_boot]
+        return Foreman::Cast.to_bool(secure_boot) ? '1' : '0' if attrs.key?(:is_secure_boot)
+
+        secure_boot = bios == 'ovmf' && Foreman::Cast.to_bool(efidisk&.pre_enrolled_keys)
+        Foreman::Cast.to_bool(secure_boot) ? '1' : '0'
+      end
     end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox_efidisks.rb

@@ -21,9 +21,17 @@ module ForemanFogProxmox
   module ProxmoxEfidisks
     include ProxmoxVMHelper
 
-    def delete_efidisk(vmobj)
-      logger.info("vm #{vmobj.identity} delete efidisk0")
-      vmobj.detach('efidisk0')
+    def delete_efidisk(vm_obj)
+      logger.info("vm #{vm_obj.identity} delete efidisk0")
+      vm_obj.detach('efidisk0')
+    end
+
+    def process_efidisk_removal(vm_obj, attributes)
+      return if vm_obj.config.efidisk.blank?
+      return if attributes['efidisk_attributes'].present?
+
+      logger.debug("Removing efidisk from VM #{vm_obj}")
+      delete_efidisk(vm_obj)
     end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox_images.rb

@@ -41,7 +41,7 @@ module ForemanFogProxmox
     end
 
     def available_images
-      templates.collect { |template| OpenStruct.new(id: template_uuid(template), name: template_name(template)) }
+      templates.collect { |template| OpenStruct.new(id: template_uuid(template), name: template_name(template)) }.uniq
     end
 
     def templates
@@ -70,9 +70,8 @@ module ForemanFogProxmox
       find_vm_by_uuid(uuid)
     end
 
-    def clone_from_image(image_id, vmid)
-      logger.debug("create_vm(): clone #{image_id} in #{vmid}")
-      image = find_vm_by_uuid(image_id)
+    def clone_from_image(image, vmid)
+      logger.debug("create_vm(): clone #{image.identity} in #{vmid}")
       image.clone(vmid)
       find_vm_by_uuid(id.to_s + '_' + vmid.to_s)
     end