foreman_fog_proxmox 0.24.0 → 0.25.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 494d9e13c53b6e6e1a4821d8c046d145060bac1058f9285763661bd935e5a4ef
-  data.tar.gz: ba0639aa5659316381788213a3d6049ae98a8238a1612dd1dc8db7eed583d11f
+  metadata.gz: d59641775e4da477886d59bf332dadd576426ef079d1c6af43ef2e9f70b9c5a5
+  data.tar.gz: 5e24be7c7881de3c05d5a59a06500bd9d35f7c1f06d4c10390df473ec6ef8b01
 SHA512:
-  metadata.gz: 4d7e5fc3d3bff0e58256217b5f69910dc03d0f08662dcc2ef1af35e242e5115f4e8023c565afa99cd83821dea73018d66b235354106766a4dbed351266c165ce
-  data.tar.gz: 6ec6c8942c3e58cc7b3a05be5f2c0131bc47a0fb3cb9a4948d46cea8b51610ee33b7b6f0cbd8a08eac66818e7e83a2f0f51e3dca2ce8d0a9c051092d84c21c81
+  metadata.gz: e04095637c92c2a341043e96f345d4d9ddcd5a3f86b4285fc1ee5199a0e9c36fd542e40a28e748d66d4da56cec743618d144300b907be7c4d82a0a4daac21d82
+  data.tar.gz: 18a1bb26c3d35273d36826012d35c7e5f21a9c65193e86b7ab9babbde49ae5d15dcea828fa37a024e91740bdfb5a29788047f8ad8cd5829215324e21267e4079

data/app/controllers/concerns/foreman_fog_proxmox/controller/parameters/compute_resource.rb

@@ -27,8 +27,7 @@ module ForemanFogProxmox
           def compute_resource_params_filter
             super.tap do |filter|
               filter.permit :ssl_verify_peer,
-                :ssl_certs, :disable_proxy, :auth_method, :token_id, :token,
-                :caching_enabled
+                :ssl_certs, :disable_proxy, :auth_method, :token_id, :token
             end
           end
 

data/app/controllers/foreman_fog_proxmox/compute_resources_controller.rb

@@ -84,8 +84,7 @@ module ForemanFogProxmox
       node_id = params[:node_id]
       storage = params[:storage]
 
-      node = cr.send(:client).nodes.get(node_id)
-      vols = node&.storages&.get(storage)&.volumes || []
+      vols = cr.storages(node_id).find { |s| s.storage == storage }&.volumes || []
 
       render json: Array(vols).map { |v|
         h = v.respond_to?(:as_json) ? v.as_json : v

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

@@ -132,8 +132,9 @@ module ProxmoxVMAttrsHelper
       ostemplate_file: vms.ostemplate_file,
       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

@@ -106,7 +106,6 @@ module ProxmoxVMCloudinitHelper
     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))
   end
 
@@ -126,13 +125,6 @@ module ProxmoxVMCloudinitHelper
     "/var/lib/vz/template/iso"
   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 }
-  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

data/app/helpers/proxmox_vm_config_helper.rb

@@ -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_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.rb

@@ -36,8 +36,6 @@ module ForemanFogProxmox
     include ProxmoxVersion
     include ProxmoxConsole
     include ComputeAttributesUpdateDetector
-    include ComputeResourceCaching
-
     validates :url, :format => { :with => URI::DEFAULT_PARSER.make_regexp }, :presence => true
     validates :auth_method, :presence => true, :inclusion => { in: ['access_ticket', 'user_token'],
       message: ->(value) do format('%<value>s is not a valid authentication method', { value: value }) end }
@@ -131,14 +129,6 @@ module ForemanFogProxmox
 
     private
 
-    def structs_from_cache(items)
-      Array(items).map { |item| OpenStruct.new(item) }
-    end
-
-    def extract_attributes(resource, fields)
-      slice_vm_attributes(fields.index_with { |field| resource.try(field) }, fields)
-    end
-
     def fog_credentials
       hash = {
         proxmox_url: url,

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

@@ -24,18 +24,11 @@ module ForemanFogProxmox
     end
 
     def images_by_storage(node_id, storage_id, type = 'iso')
-      cached_images = cache.cache(:"images_by_storage-#{node_id}-#{storage_id}-#{type}") do
-        node = client.nodes.get(node_id) || default_node
-        storage = node.storages.get storage_id if storage_id
-        logger.debug("images_by_storage(): node_id #{node_id} storage_id #{storage_id} type #{type}")
-        next [] unless storage
-
-        storage.volumes.list_by_content_type(type).sort_by(&:volid).map do |volume|
-          extract_attributes(volume, [:volid, :content, :format, :size, :used])
-        end
-      end
-
-      structs_from_cache(cached_images)
+      node = client.nodes.get node_id
+      node ||= default_node
+      storage = node.storages.get storage_id if storage_id
+      logger.debug("images_by_storage(): node_id #{node_id} storage_id #{storage_id} type #{type}")
+      storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
     def template_name(template)
@@ -52,40 +45,33 @@ module ForemanFogProxmox
     end
 
     def templates
-      cached_templates = cache.cache(:templates) do
-        volumes = fog_nodes.flat_map do |node|
-          storages = node.storages.list_by_content_type 'images'
-          logger.debug("storages(): node_id #{node.node} type images")
-          storages.reject { |storage| storage.active.to_i.zero? }.sort_by(&:storage).flat_map do |storage|
-            # Skip disabled storages (enabled == 0 or nil)
-            unless storage.enabled.to_i == 1
-              logger.warn("Skipping disabled storage #{storage.identity} on #{node.node}")
-              next []
-            end
-
-            # Fetch QEMU and LXC template images
-            storage.volumes.list_by_content_type('images') + storage.volumes.list_by_content_type('rootdir')
-          rescue StandardError => e
-            logger.error("Failed to fetch volumes for storage #{storage.identity} on #{node.node}: #{e.message}")
-            []
+      volumes = []
+      nodes.each do |node|
+        storages(node.node).each do |storage|
+          # Skip disabled storages (enabled == 0 or nil)
+          unless storage.enabled.to_i == 1
+            logger.warn("Skipping disabled storage #{storage.identity} on #{node.node}")
+            next
           end
-        end
 
-        volumes.select(&:template?).map do |volume|
-          extract_attributes(volume, [:vmid, :name, :volid, :node_id]).merge(template: true)
+          # Fetch QEMU and LXC template images
+          volumes += storage.volumes.list_by_content_type('images')
+          volumes += storage.volumes.list_by_content_type('rootdir')
+        rescue StandardError => e
+          logger.error("Failed to fetch volumes for storage #{storage.identity} on #{node.node}: #{e.message}")
+          next
         end
       end
-
-      structs_from_cache(cached_templates)
+      # for creating image, only list volumes which are templated
+      volumes.select(&:template?)
     end
 
     def template(uuid)
       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

data/app/models/foreman_fog_proxmox/proxmox_pools.rb

@@ -20,25 +20,8 @@
 module ForemanFogProxmox
   module ProxmoxPools
     def pools
-      cached_pools = cache.cache(:pools) do
-        pools = identity_client.pools.all
-        pools.sort_by(&:poolid).map do |pool|
-          extract_attributes(pool, [:poolid, :comment]).merge(
-            members: Array(pool.try(:members)).map do |member|
-              { vmid: member['vmid'] }
-            end
-          )
-        end
-      end
-
-      # Store only serializable hashes in the cache. After retrieval we recreate the pool objects and reattach the `has_server?` helper method.
-      Array(cached_pools).map do |pool|
-        OpenStruct.new(pool).tap do |pool_object|
-          pool_object.define_singleton_method(:has_server?) do |vmid|
-            Array(members).any? { |member| member[:vmid].to_s == vmid.to_s || member['vmid'].to_s == vmid.to_s }
-          end
-        end
-      end
+      pools = identity_client.pools.all
+      pools.sort_by(&:poolid)
     end
 
     def pool_owner(vm)

data/app/models/foreman_fog_proxmox/proxmox_vm_commands.rb

@@ -36,17 +36,21 @@ module ForemanFogProxmox
       type = args[:type]
       node = client.nodes.get(args[:node_id])
       vmid = args[:vmid] = assign_vmid(args[:vmid].to_i, node)
-      raise ::Foreman::Exception, format(N_('invalid vmid=%<vmid>s'), vmid: vmid) unless node.servers.id_valid?(vmid)
-
       image_id = args[:image_id]
       remove_volume_keys(args)
       if image_id
-        vm = clone_from_image(image_id, vmid)
-        vm.update(compute_clone_attributes(args, vm.container?, type))
+        image = find_vm_by_uuid(image_id)
+        validate_image_template_disk_slots!(image, args) if type == 'qemu'
+        vm = clone_from_image(image, vmid)
+        vm.update(compute_clone_attributes(args, vm.container?, type, image: image))
         update_pool(vm, args[:pool]) if args[:pool]
       else
         logger.warn("create vm: args=#{args}")
         vm = node.send(vm_collection(type)).create(parse_typed_vm(args, type))
+        if type == 'qemu' && vm
+          boot_order = update_boot_order(vm, exclude_cdrom: true, include_network: true)
+          vm.update(boot_order) if boot_order
+        end
       end
       start_on_boot(vm, args)
     rescue StandardError => e
@@ -55,12 +59,20 @@ module ForemanFogProxmox
       raise e
     end
 
-    def assign_vmid(vmid, node)
-      (vmid < 1) ? node.servers.next_id : vmid
+    def assign_vmid(vmid, node, log: true)
+      vmid = node.servers.next_id if vmid < 1
+
+      unless node.servers.id_valid?(vmid)
+        logger.warn("Requested VMID #{vmid} is occupied or out of range, requesting a new VMID") if log
+        vmid = node.servers.next_id
+      end
+
+      vmid
     end
 
-    def compute_clone_attributes(args, container, type)
+    def compute_clone_attributes(args, container, type, image: nil)
       args = parse_cloudinit_config(args) if args[:user_data]
+      args[:config_attributes].merge!(update_boot_order(image)) if image && args[:config_attributes]
       parsed_args = parse_typed_vm(args, type)
       if container
         options = { :hostname => args[:name] }
@@ -105,10 +117,9 @@ module ForemanFogProxmox
       elsif vm.node_id != node_id
         vm.migrate(node_id)
       else
-        parsed_attr = parse_typed_vm(
-          ForemanFogProxmox::HashCollection.new_hash_reject_keys(new_attributes,
-            ['volumes_attributes']).merge(type: vm.type), vm.type
-        )
+        processed_attributes = process_firmware_attributes(new_attributes, vm.type)
+        update_attributes = parse_vm_update_attributes(processed_attributes, vm.type)
+        parsed_attr = parse_typed_vm(update_attributes, vm.type)
         config_attributes = compute_config_attributes(parsed_attr)
 
         volumes_attributes = new_attributes['volumes_attributes']
@@ -118,11 +129,7 @@ module ForemanFogProxmox
           save_volume(vm, volume_attributes)
         end
 
-        efidisk_attributes = new_attributes['efidisk_attributes']
-        if vm.config.efidisk.present? && efidisk_attributes.empty?
-          logger.debug("Removing efidisk from VM #{vm}")
-          delete_efidisk(vm)
-        end
+        process_efidisk_removal(vm, processed_attributes)
 
         vm.update(config_attributes[:config_attributes])
         poolid = new_attributes['pool'] if new_attributes.key?('pool')

data/app/models/foreman_fog_proxmox/proxmox_vm_new.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ModuleLength
+
 # Copyright 2019 Tristan Robert
 
 # This file is part of ForemanFogProxmox.
@@ -97,7 +99,7 @@ module ForemanFogProxmox
     end
 
     def default_node
-      fog_nodes.first
+      nodes.first
     end
 
     def default_node_id
@@ -182,18 +184,32 @@ module ForemanFogProxmox
       config_attributes.delete_if { |key, _value| ['disks', 'interfaces'].include?(key) }
     end
 
+    def assign_available_vmid(new_attr, node)
+      return if new_attr['vmid'].blank? || new_attr['node_id'].blank?
+
+      new_attr['vmid'] = assign_vmid(new_attr['vmid'].to_i, node, log: false)
+    end
+
+    def add_secure_boot_attribute(vm_h, options, type)
+      secure_boot = options.dig('config_attributes', 'is_secure_boot')
+      vm_h[:is_secure_boot] = secure_boot if type == 'qemu' && secure_boot
+    end
+
     def new_typed_vm(new_attr, type)
       convert_config_attributes(new_attr) if new_attr.key?(:config_attributes)
       node_id = new_attr['node_id']
       node = node_id ? client.nodes.get(node_id) : default_node
+      assign_available_vmid(new_attr, node)
       new_attr_type = new_attr['type']
       new_attr_type ||= new_attr['config_attributes']['type'] if new_attr.key?('config_attributes')
       new_attr_type ||= type
       logger.debug("new_typed_vm(#{type}): new_attr_type=#{new_attr_type}")
       logger.debug("new_typed_vm(#{type}): new_attr=#{new_attr}'")
       options = (!new_attr.key?('vmid') || ForemanFogProxmox::Value.empty?(new_attr['vmid'])) ? vm_typed_instance_defaults(type).merge(new_attr).merge(type: type) : new_attr
+      options = process_firmware_attributes(options, type)
       logger.debug("new_typed_vm(#{type}): options=#{options}")
       vm_h = parse_typed_vm(options, type).deep_symbolize_keys
+      add_secure_boot_attribute(vm_h, options, type)
       logger.debug("new_typed_vm(#{type}): vm_h=#{vm_h}")
       vm_h = vm_h.merge(vm_typed_instance_defaults(type)) if vm_h.empty?
       logger.debug(format(_('new_typed_vm(%<type>s) with vm_typed_instance_defaults: vm_h=%<vm_h>s'), type: type, vm_h: vm_h))
@@ -201,3 +217,5 @@ module ForemanFogProxmox
     end
   end
 end
+
+# rubocop:enable Metrics/ModuleLength