VMware image provisioning fails with InvalidVmConfig/InvalidArgument after upgrade to 3.18.1 (firmware not normalized for image-based clone)

Support
1

Hello all,

When provisioning a VM on VMware using image-based provisioning (clone from template) in Foreman 3.18.1, the clone operation fails with two distinct errors depending on the firmware setting selected in the UI:

UEFI or UEFI Secure Boot → InvalidVmConfig: Invalid virtual machine configuration with property=config.bootOptions.efiSecureBootEnabled and message EFI secure boot could be enabled only on EFI firmware.

Problem:
When provisioning a VM on VMware using image-based provisioning (clone from template) in Foreman 3.18.1, the clone operation fails with two distinct errors depending on the firmware setting selected in the UI:

  1. UEFI or UEFI Secure Boot → InvalidVmConfig: Invalid virtual machine configuration with property=config.bootOptions.efiSecureBootEnabled and message EFI secure boot could be enabled only on EFI firmware.
  2. UEFI (without Secure Boot) → InvalidArgument: A specified parameter was not correct (no property detail)

Both errors originate from fog-vsphere vm_clone.rb receiving an invalid firmware value ('uefi' or 'uefi_secure_boot' instead of the vSphere API-expected 'efi').

Root cause analysis:

Foreman 3.18.1 introduced generate_secure_boot_settings and process_firmware_attributes in compute_resource.rb. The normalize_firmware_type method correctly translates 'uefi'/'uefi_secure_boot' → 'efi', but only when firmware_type is present (i.e. when a PXE loader is set). For image-based provisioning, pxe_loader is empty, so firmware_type is blank, normalize_firmware_type is never called, and the raw UI value ('uefi') is passed directly to fog-vsphere and then to the vSphere API — which rejects it as invalid.

Additionally, Foreman 3.18.1 also introduced boot_order in the clone_vm opts (previously absent), which activates the bootOptions block in fog-vsphere vm_clone.rb. This block unconditionally sets efiSecureBootEnabled: options["secure_boot"] || false, causing vSphere to reject the spec even when Secure Boot is disabled, because rbvmomi2 3.8.0 now explicitly serializes false boolean values (previously they were omitted).

Expected outcome:
Image-based VM provisioning on VMware with UEFI, UEFI Secure Boot, or BIOS firmware should work correctly in Foreman 3.18.1 as it did in 3.17.0.

Proposed fixes:

Fix 1 — app/models/compute_resources/foreman/model/vmware.rb in clone_vm:

-        "firmware" => args[:firmware],
+        "firmware" => normalize_firmware_type(args[:firmware]),

Fix 2 — fog-vsphere lib/fog/vsphere/requests/compute/vm_clone.rb (line ~220):

-            virtual_machine_config_spec.bootOptions = { bootOrder: boot_order, efiSecureBootEnabled: options["secure_boot"] || false }
+            boot_options = { bootOrder: boot_order }
+            boot_options[:efiSecureBootEnabled] = true if options["secure_boot"] == true || options["secure_boot"] == "true"
+            virtual_machine_config_spec.bootOptions = boot_options

Foreman and Proxy versions:
Foreman 3.18.1 / Foreman Proxy 3.18.1

Foreman and Proxy plugin versions:

  • katello 4.20.0
  • foreman_remote_execution 16.5.3
  • foreman-tasks 11.1.1
  • foreman_puppet 9.1.0
  • rubygem-fog-vsphere 3.7.2
  • rubygem-rbvmomi2 3.8.0

Distribution and version:
Red Hat Enterprise Linux 9.7 (Plow)

Other relevant data:

  • The issue is a regression introduced in 3.18.1. Provisioning worked correctly in 3.17.x with the same fog-vsphere (3.7.2) and rbvmomi2 (3.8.0) versions.
  • The bug only affects image-based provisioning (clone from template). Network-based (PXE) provisioning is not affected because firmware_type is populated via pxe_loader in that flow, which triggers normalize_firmware_type.
  • Deploying the same template directly from vCenter works without error.
  • Relevant log extract:
vSphere fault detail: InvalidVmConfig @props={:faultMessage=>[{:key=>"msg.hostd.configSpec.efi", :message=>"EFI secure boot could be enabled only on EFI firmware."}], :property=>"config.bootOptions.efiSecureBootEnabled"}
  • Debug logging of vm_clone opts confirmed "firmware"=>"uefi" being sent to fog-vsphere instead of "firmware"=>"efi". After applying Fix 1, opts correctly show "firmware"=>"efi" and provisioning succeeds.
2

@nofaralfasi Some thoughts on this?

3

hi all,

similar problem here:
with foreman 3.18.1 I can not longer deploy VMs (…provisioning a VM on VMware using image-based provisioning (clone from template)…)
I have added the proposed fixes but nothing changed.

Here is my vpxd.log:

2026-04-30T10:49:40.367Z error vpxd\[3417177\] \[Originator@6876 sub=Default opID=14034394\] \[VpxLRO\] – ERROR task-7914930 – 52f2d835-bbec-4a87-edda-fbaa69c92b5e(5298dfb2-18b5-1594-97e4-531be045339c) – vm-2580609 – vim.VirtualMachine.clone: :vmodl.fault.InvalidArgument
 → Result:
 → (vmodl.fault.InvalidArgument) {
 →    faultCause = (vmodl.MethodFault) null,
 →    faultMessage = ,
 →    invalidProperty = 
 →    msg = "A specified parameter was not correct: "
 → }
 → Args:
 → 
 → Arg folder:
 → ‘vim.Folder:group-v397309’
 → Arg name:
 → “sles16test”
 → Arg spec:
 → (vim.vm.CloneSpec) {
 →    location = (vim.vm.RelocateSpec) {
 →       service = (vim.ServiceLocator) null,
 →       folder = ‘vim.Folder:group-v397309’,
 →       datastore = ‘vim.Datastore:datastore-265923’,
 →       diskMoveType = ,
 →       pool = ‘vim.ResourcePool:resgroup-183043’,
 →       host = ,
 →       disk = (vim.vm.RelocateSpec.DiskLocator) \[
 →          (vim.vm.RelocateSpec.DiskLocator) {
 →             diskId = 2000,
 →             datastore = ‘vim.Datastore:datastore-265923’,
 →             diskMoveType = ,
 →             diskBackingInfo = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) {
 →                fileName = “”,
 →                datastore = ,
 →                backingObjectId = ,
 →                diskMode = “persistent”,
 →                split = ,
 →                writeThrough = ,
 →                thinProvisioned = true,
 →                eagerlyScrub = ,
 →                uuid = ,
 →                contentId = ,
 →                changeId = ,
 →                parent = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) null,
 →                deltaDiskFormat = ,
 →                digestEnabled = ,
 →                deltaGrainSize = ,
 →                deltaDiskFormatVariant = ,
 →                sharing = ,
 →                keyId = (vim.encryption.CryptoKeyId) null,
 →                digestFormatVersion = 
 →             },
 →             profile = ,
 →             backing = (vim.vm.RelocateSpec.DiskLocator.BackingSpec) null,
 →             filterSpec = 
 →          }
 →       \],
 →       transform = ,
 →       deviceChange = ,
 →       profile = ,
 →       cryptoSpec = (vim.encryption.CryptoSpec) null
 →    },
 →    template = false,
 →    config = (vim.vm.ConfigSpec) {
 →       changeVersion = ,
 →       name = ,
 →       version = ,
 →       createDate = ,
 →       uuid = ,
 →       instanceUuid = ,
 →       npivNodeWorldWideName = ,
 →       npivPortWorldWideName = ,
 →       npivWorldWideNameType = ,
 →       npivDesiredNodeWwns = ,
 →       npivDesiredPortWwns = ,
 →       npivTemporaryDisabled = ,
 →       npivOnNonRdmDisks = ,
 →       npivWorldWideNameOp = ,
 →       locationId = ,
 →       guestId = ,
 →       alternateGuestName = ,
 →       annotation = “Generate from Katello”,
 →       files = (vim.vm.FileInfo) null,
 →       tools = (vim.vm.ToolsConfigInfo) null,
 →       flags = (vim.vm.FlagInfo) null,
 →       consolePreferences = (vim.vm.ConsolePreferences) null,
 →       powerOpInfo = (vim.vm.DefaultPowerOpInfo) null,
 →       rebootPowerOff = ,
 →       numCPUs = 1,
 →       vcpuConfig = ,
 →       numCoresPerSocket = 1,
 →       memoryMB = 4096,
 →       memoryHotAddEnabled = ,
 →       cpuHotAddEnabled = ,
 →       cpuHotRemoveEnabled = ,
 →       virtualICH7MPresent = ,
 →       virtualSMCPresent = ,
 →       deviceChange = (vim.vm.device.VirtualDeviceSpec) \[
 →          (vim.vm.device.VirtualDeviceSpec) {
 →             operation = “edit”,
 →             fileOperation = ,
 →             device = (vim.vm.device.VirtualVmxnet3) {
 →                dynamicProperty = ,
 →                key = 4000,
 →                deviceInfo = (vim.Description) {
 →                   label = “Network adapter 1”,
 →                   summary = “DVSwitch: 50 24 f6 92 8e 98 66 0a-a5 45 17 46 90 a9 64 0c”
 →                },
 →                backing = (vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo) {
 →                   port = (vim.dvs.PortConnection) {
 →                      switchUuid = “50 24 f6 92 8e 98 66 0a-a5 45 17 46 90 a9 64 0c”,
 →                      portgroupKey = “dvportgroup-183031”,
 →                      portKey = ,
 →                      connectionCookie = 
 →                   }
 →                },
 →                connectable = (vim.vm.device.VirtualDevice.ConnectInfo) {
 →                   migrateConnect = ,
 →                   startConnected = true,
 →                   allowGuestControl = true,
 →                   connected = true,
 →                   status = 
 →                },
 →                slotInfo = (vim.vm.device.VirtualDevice.PciBusSlotInfo) {
 →                   pciSlotNumber = 33
 →                },
 →                controllerKey = 100,
 →                unitNumber = 7,
 →                numaNode = ,
 →                deviceGroupInfo = (vim.vm.device.VirtualDevice.DeviceGroupInfo) null,
 →                addressType = “generated”,
 →                macAddress = ,
 →                wakeOnLanEnabled = true,
 →                resourceAllocation = (vim.vm.device.VirtualEthernetCard.ResourceAllocation) {
 →                   reservation = 0,
 →                   share = (vim.SharesInfo) {
 →                      shares = 50,
 →                      level = “normal”
 →                   },
 →                   limit = -1
 →                },
 →                externalId = ,
 →                uptCompatibilityEnabled = true,
 →                uptv2Enabled = false,
 →                realTimeEnabled = 
 →             },
 →             profile = ,
 →             backing = (vim.vm.device.VirtualDeviceSpec.BackingSpec) null,
 →             filterSpec = ,
 →             changeMode = 
 →          },
 →          (vim.vm.device.VirtualDeviceSpec) {
 →             operation = “edit”,
 →             fileOperation = ,
 →             device = (vim.vm.device.VirtualDisk) {
 →                key = 2000,
 →                deviceInfo = (vim.Description) {
 →                   label = “Hard disk 1”,
 →                   summary = “52,428,800 KB”
 →                },
 →                backing = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) {
 →                   fileName = “\[NFS_DANA19R1CL_Template\] SLES16.0_template_katello_test/SLES16.0_template_katello_test_4.vmdk”,
 →                   datastore = ‘vim.Datastore:datastore-1317869’,
 →                   backingObjectId = “”,
 →                   diskMode = “persistent”,
 →                   split = false,
 →                   writeThrough = false,
 →                   thinProvisioned = true,
 →                   eagerlyScrub = false,
 →                   uuid = “6000C295-3355-9c6a-bf80-39c9acab018e”,
 →                   contentId = “206e76ffef688bf23145dc3885192c4a”,
 →                   changeId = ,
 →                   parent = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) null,
 →                   deltaDiskFormat = ,
 →                   digestEnabled = false,
 →                   deltaGrainSize = ,
 →                   deltaDiskFormatVariant = ,
 →                   sharing = “sharingNone”,
 →                   keyId = (vim.encryption.CryptoKeyId) null,
 →                   digestFormatVersion = 
 →                },
 →                connectable = (vim.vm.device.VirtualDevice.ConnectInfo) null,
 →                slotInfo = (vim.vm.device.VirtualDevice.BusSlotInfo) null,
 →                controllerKey = 1000,
 →                unitNumber = 0,
 →                numaNode = ,
 →                deviceGroupInfo = (vim.vm.device.VirtualDevice.DeviceGroupInfo) null,
 →                capacityInKB = 52428800,
 →                capacityInBytes = 53687091200,
 →                shares = (vim.SharesInfo) {
 →                   shares = 1000,
 →                   level = “normal”
 →                },
 →                storageIOAllocation = (vim.StorageResourceManager.IOAllocationInfo) {
 →                   limit = -1,
 →                   shares = (vim.SharesInfo) {
 →                      shares = 1000,
 →                      level = “normal”
 →                   },
 →                   reservation = 0
 →                },
 →                diskObjectId = “32929-2000”,
 →                vFlashCacheConfigInfo = (vim.vm.device.VirtualDisk.VFlashCacheConfigInfo) null,
 →                iofilter = ,
 →                vDiskId = (vim.vslm.ID) null,
 →                vDiskVersion = 1,
 →                virtualDiskFormat = ,
 →                nativeUnmanagedLinkedClone = false,
 →                independentFilters = ,
 →                guestReadOnly = false
 →             },
 →             profile = ,
 →             backing = (vim.vm.device.VirtualDeviceSpec.BackingSpec) null,
 →             filterSpec = ,
 →             changeMode = 
 →          }
 →       \],
 →       cpuAllocation = (vim.ResourceAllocationInfo) null,
 →       memoryAllocation = (vim.ResourceAllocationInfo) null,
 →       latencySensitivity = (vim.LatencySensitivity) null,
 →       cpuAffinity = (vim.vm.AffinityInfo) null,
 →       memoryAffinity = (vim.vm.AffinityInfo) null,
 →       networkShaper = (vim.vm.NetworkShaperInfo) null,
 →       cpuFeatureMask = ,
 →       extraConfig = ,
 →       swapPlacement = ,
 →       bootOptions = (vim.vm.BootOptions) {
 →          bootDelay = ,
 →          enterBIOSSetup = ,
 →          efiSecureBootEnabled = false,
 →          bootRetryEnabled = ,
 →          bootRetryDelay = ,
 →          bootOrder = (vim.vm.BootOptions.BootableDevice) \[
 →             (vim.vm.BootOptions.BootableDiskDevice) {
 →                deviceKey = 2000
 →             }
 →          \],
 →          networkBootProtocol = 
 →       },
 →       vAppConfig = (vim.vApp.VmConfigSpec) null,
 →       ftInfo = (vim.vm.FaultToleranceConfigInfo) null,
 →       repConfig = (vim.vm.ReplicationConfigSpec) null,
 →       vAppConfigRemoved = ,
 →       vAssertsEnabled = ,
 →       changeTrackingEnabled = ,
 →       firmware = “uefi”,
 →       maxMksConnections = ,
 →       guestAutoLockEnabled = ,
 →       managedBy = (vim.ext.ManagedByInfo) null,
 →       memoryReservationLockedToMax = ,
 →       nestedHVEnabled = ,
 →       vPMCEnabled = ,
 →       scheduledHardwareUpgradeInfo = (vim.vm.ScheduledHardwareUpgradeInfo) null,
 →       vmProfile = ,
 →       messageBusTunnelEnabled = ,
 →       crypto = (vim.encryption.CryptoSpec) null,
 →       migrateEncryption = ,
 →       sgxInfo = (vim.vm.SgxInfo) null,
 →       ftEncryptionMode = ,
 →       guestMonitoringModeInfo = (vim.vm.GuestMonitoringModeInfo) null,
 →       sevEnabled = ,
 →       virtualNuma = (vim.vm.VirtualNuma) null,
 →       motherboardLayout = ,
 →       pmemFailoverEnabled = ,
 →       vmxStatsCollectionEnabled = ,
 →       vmOpNotificationToAppEnabled = ,
 →       vmOpNotificationTimeout = ,
 →       deviceSwap = (vim.vm.VirtualDeviceSwap) null,
 →       simultaneousThreads = ,
 →       pmem = (vim.vm.VirtualPMem) null,
 →       deviceGroups = (vim.vm.VirtualDeviceGroups) null,
 →       fixedPassthruHotPlugEnabled = ,
 →       metroFtEnabled = ,
 →       metroFtHostGroup = ,
 →       tdxEnabled = ,
 →       sevSnpEnabled = 
 →    },
 →    customization = (vim.vm.customization.Specification) {
 →       options = (vim.vm.customization.Options) null,
 →       identity = (vim.vm.customization.LinuxPrep) {
 →          hostName = (vim.vm.customization.FixedName) {
 →             name = “sles16test”
 →          },
 →          domain = “da.doehler.com”,
 →          timeZone = “UTC”,
 →          hwClockUTC = true,
 →          scriptText = ,
 →          compatibleCustomizationMethod = 
 →       },
 →       globalIPSettings = (vim.vm.customization.GlobalIPSettings) {
 →          dnsSuffixList = (string) \[
 →             “da.doehler.com”
 →          \],
 →          dnsServerList = (string) \[
 →             “192.168.175.20”,
 →             “192.168.176.20”
 →          \]
 →       },
 →       nicSettingMap = (vim.vm.customization.AdapterMapping) \[
 →          (vim.vm.customization.AdapterMapping) {
 →             macAddress = ,
 →             adapter = (vim.vm.customization.IPSettings) {
 →                ip = (vim.vm.customization.FixedIp) {
 →                   ipAddress = “192.168.182.92”
 →                },
 →                subnetMask = “255.255.255.128”,
 →                gateway = (string) \[
 →                   “192.168.182.126”
 →                \],
 →                ipV6Spec = (vim.vm.customization.IPSettings.IpV6AddressSpec) null,
 →                dnsServerList = (string) \[
 →                   “192.168.175.20”,
 →                   “192.168.176.20”
 →                \],
 →                dnsDomain = “da.doehler.com”,
 →                primaryWINS = ,
 →                secondaryWINS = ,
 →                netBIOS = 
 →             }
 →          }
 →       \],
 →       encryptionKey = 
 →    },
 →    powerOn = false,
 →    snapshot = ,
 →    memory = ,
 →    tpmProvisionPolicy = 
 → }
4

hi all,

similar problem here:
with foreman 3.18.1 I can not longer deploy VMs (…provisioning a VM on VMware using image-based provisioning (clone from template)…)
I have added the proposed fixes but nothing changed.

Here is my vpxd.log:

2026-04-30T10:49:40.367Z error vpxd\[3417177\] \[Originator@6876 sub=Default opID=14034394\] \[VpxLRO\] – ERROR task-7914930 – 52f2d835-bbec-4a87-edda-fbaa69c92b5e(5298dfb2-18b5-1594-97e4-531be045339c) – vm-2580609 – vim.VirtualMachine.clone: :vmodl.fault.InvalidArgument
→ Result:
→ (vmodl.fault.InvalidArgument) {
→    faultCause = (vmodl.MethodFault) null,
→    faultMessage = ,
→    invalidProperty =
→    msg = "A specified parameter was not correct: "
→ }
→ Args:
→
→ Arg folder:
→ ‘vim.Folder:group-v397309’
→ Arg name:
→ “sles16test”
→ Arg spec:
→ (vim.vm.CloneSpec) {
→    location = (vim.vm.RelocateSpec) {
→       service = (vim.ServiceLocator) null,
→       folder = ‘vim.Folder:group-v397309’,
→       datastore = ‘vim.Datastore:datastore-265923’,
→       diskMoveType = ,
→       pool = ‘vim.ResourcePool:resgroup-183043’,
→       host = ,
→       disk = (vim.vm.RelocateSpec.DiskLocator) \[
→          (vim.vm.RelocateSpec.DiskLocator) {
→             diskId = 2000,
→             datastore = ‘vim.Datastore:datastore-265923’,
→             diskMoveType = ,
→             diskBackingInfo = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) {
→                fileName = “”,
→                datastore = ,
→                backingObjectId = ,
→                diskMode = “persistent”,
→                split = ,
→                writeThrough = ,
→                thinProvisioned = true,
→                eagerlyScrub = ,
→                uuid = ,
→                contentId = ,
→                changeId = ,
→                parent = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) null,
→                deltaDiskFormat = ,
→                digestEnabled = ,
→                deltaGrainSize = ,
→                deltaDiskFormatVariant = ,
→                sharing = ,
→                keyId = (vim.encryption.CryptoKeyId) null,
→                digestFormatVersion =
→             },
→             profile = ,
→             backing = (vim.vm.RelocateSpec.DiskLocator.BackingSpec) null,
→             filterSpec =
→          }
→       \],
→       transform = ,
→       deviceChange = ,
→       profile = ,
→       cryptoSpec = (vim.encryption.CryptoSpec) null
→    },
→    template = false,
→    config = (vim.vm.ConfigSpec) {
→       changeVersion = ,
→       name = ,
→       version = ,
→       createDate = ,
→       uuid = ,
→       instanceUuid = ,
→       npivNodeWorldWideName = ,
→       npivPortWorldWideName = ,
→       npivWorldWideNameType = ,
→       npivDesiredNodeWwns = ,
→       npivDesiredPortWwns = ,
→       npivTemporaryDisabled = ,
→       npivOnNonRdmDisks = ,
→       npivWorldWideNameOp = ,
→       locationId = ,
→       guestId = ,
→       alternateGuestName = ,
→       annotation = “Generate from Katello”,
→       files = (vim.vm.FileInfo) null,
→       tools = (vim.vm.ToolsConfigInfo) null,
→       flags = (vim.vm.FlagInfo) null,
→       consolePreferences = (vim.vm.ConsolePreferences) null,
→       powerOpInfo = (vim.vm.DefaultPowerOpInfo) null,
→       rebootPowerOff = ,
→       numCPUs = 1,
→       vcpuConfig = ,
→       numCoresPerSocket = 1,
→       memoryMB = 4096,
→       memoryHotAddEnabled = ,
→       cpuHotAddEnabled = ,
→       cpuHotRemoveEnabled = ,
→       virtualICH7MPresent = ,
→       virtualSMCPresent = ,
→       deviceChange = (vim.vm.device.VirtualDeviceSpec) \[
→          (vim.vm.device.VirtualDeviceSpec) {
→             operation = “edit”,
→             fileOperation = ,
→             device = (vim.vm.device.VirtualVmxnet3) {
→                dynamicProperty = ,
→                key = 4000,
→                deviceInfo = (vim.Description) {
→                   label = “Network adapter 1”,
→                   summary = “DVSwitch: 50 24 f6 92 8e 98 66 0a-a5 45 17 46 90 a9 64 0c”
→                },
→                backing = (vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo) {
→                   port = (vim.dvs.PortConnection) {
→                      switchUuid = “50 24 f6 92 8e 98 66 0a-a5 45 17 46 90 a9 64 0c”,
→                      portgroupKey = “dvportgroup-183031”,
→                      portKey = ,
→                      connectionCookie =
→                   }
→                },
→                connectable = (vim.vm.device.VirtualDevice.ConnectInfo) {
→                   migrateConnect = ,
→                   startConnected = true,
→                   allowGuestControl = true,
→                   connected = true,
→                   status =
→                },
→                slotInfo = (vim.vm.device.VirtualDevice.PciBusSlotInfo) {
→                   pciSlotNumber = 33
→                },
→                controllerKey = 100,
→                unitNumber = 7,
→                numaNode = ,
→                deviceGroupInfo = (vim.vm.device.VirtualDevice.DeviceGroupInfo) null,
→                addressType = “generated”,
→                macAddress = ,
→                wakeOnLanEnabled = true,
→                resourceAllocation = (vim.vm.device.VirtualEthernetCard.ResourceAllocation) {
→                   reservation = 0,
→                   share = (vim.SharesInfo) {
→                      shares = 50,
→                      level = “normal”
→                   },
→                   limit = -1
→                },
→                externalId = ,
→                uptCompatibilityEnabled = true,
→                uptv2Enabled = false,
→                realTimeEnabled =
→             },
→             profile = ,
→             backing = (vim.vm.device.VirtualDeviceSpec.BackingSpec) null,
→             filterSpec = ,
→             changeMode =
→          },
→          (vim.vm.device.VirtualDeviceSpec) {
→             operation = “edit”,
→             fileOperation = ,
→             device = (vim.vm.device.VirtualDisk) {
→                key = 2000,
→                deviceInfo = (vim.Description) {
→                   label = “Hard disk 1”,
→                   summary = “52,428,800 KB”
→                },
→                backing = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) {
→                   fileName = “\[NFS_DANA19R1CL_Template\] SLES16.0_template_katello_test/SLES16.0_template_katello_test_4.vmdk”,
→                   datastore = ‘vim.Datastore:datastore-1317869’,
→                   backingObjectId = “”,
→                   diskMode = “persistent”,
→                   split = false,
→                   writeThrough = false,
→                   thinProvisioned = true,
→                   eagerlyScrub = false,
→                   uuid = “6000C295-3355-9c6a-bf80-39c9acab018e”,
→                   contentId = “206e76ffef688bf23145dc3885192c4a”,
→                   changeId = ,
→                   parent = (vim.vm.device.VirtualDisk.FlatVer2BackingInfo) null,
→                   deltaDiskFormat = ,
→                   digestEnabled = false,
→                   deltaGrainSize = ,
→                   deltaDiskFormatVariant = ,
→                   sharing = “sharingNone”,
→                   keyId = (vim.encryption.CryptoKeyId) null,
→                   digestFormatVersion =
→                },
→                connectable = (vim.vm.device.VirtualDevice.ConnectInfo) null,
→                slotInfo = (vim.vm.device.VirtualDevice.BusSlotInfo) null,
→                controllerKey = 1000,
→                unitNumber = 0,
→                numaNode = ,
→                deviceGroupInfo = (vim.vm.device.VirtualDevice.DeviceGroupInfo) null,
→                capacityInKB = 52428800,
→                capacityInBytes = 53687091200,
→                shares = (vim.SharesInfo) {
→                   shares = 1000,
→                   level = “normal”
→                },
→                storageIOAllocation = (vim.StorageResourceManager.IOAllocationInfo) {
→                   limit = -1,
→                   shares = (vim.SharesInfo) {
→                      shares = 1000,
→                      level = “normal”
→                   },
→                   reservation = 0
→                },
→                diskObjectId = “32929-2000”,
→                vFlashCacheConfigInfo = (vim.vm.device.VirtualDisk.VFlashCacheConfigInfo) null,
→                iofilter = ,
→                vDiskId = (vim.vslm.ID) null,
→                vDiskVersion = 1,
→                virtualDiskFormat = ,
→                nativeUnmanagedLinkedClone = false,
→                independentFilters = ,
→                guestReadOnly = false
→             },
→             profile = ,
→             backing = (vim.vm.device.VirtualDeviceSpec.BackingSpec) null,
→             filterSpec = ,
→             changeMode =
→          }
→       \],
→       cpuAllocation = (vim.ResourceAllocationInfo) null,
→       memoryAllocation = (vim.ResourceAllocationInfo) null,
→       latencySensitivity = (vim.LatencySensitivity) null,
→       cpuAffinity = (vim.vm.AffinityInfo) null,
→       memoryAffinity = (vim.vm.AffinityInfo) null,
→       networkShaper = (vim.vm.NetworkShaperInfo) null,
→       cpuFeatureMask = ,
→       extraConfig = ,
→       swapPlacement = ,
→       bootOptions = (vim.vm.BootOptions) {
→          bootDelay = ,
→          enterBIOSSetup = ,
→          efiSecureBootEnabled = false,
→          bootRetryEnabled = ,
→          bootRetryDelay = ,
→          bootOrder = (vim.vm.BootOptions.BootableDevice) \[
→             (vim.vm.BootOptions.BootableDiskDevice) {
→                deviceKey = 2000
→             }
→          \],
→          networkBootProtocol =
→       },
→       vAppConfig = (vim.vApp.VmConfigSpec) null,
→       ftInfo = (vim.vm.FaultToleranceConfigInfo) null,
→       repConfig = (vim.vm.ReplicationConfigSpec) null,
→       vAppConfigRemoved = ,
→       vAssertsEnabled = ,
→       changeTrackingEnabled = ,
→       **firmware = “uefi”,**
→       maxMksConnections = ,
→       guestAutoLockEnabled = ,
→       managedBy = (vim.ext.ManagedByInfo) null,
→       memoryReservationLockedToMax = ,
→       nestedHVEnabled = ,
→       vPMCEnabled = ,
→       scheduledHardwareUpgradeInfo = (vim.vm.ScheduledHardwareUpgradeInfo) null,
→       vmProfile = ,
→       messageBusTunnelEnabled = ,
→       crypto = (vim.encryption.CryptoSpec) null,
→       migrateEncryption = ,
→       sgxInfo = (vim.vm.SgxInfo) null,
→       ftEncryptionMode = ,
→       guestMonitoringModeInfo = (vim.vm.GuestMonitoringModeInfo) null,
→       sevEnabled = ,
→       virtualNuma = (vim.vm.VirtualNuma) null,
→       motherboardLayout = ,
→       pmemFailoverEnabled = ,
→       vmxStatsCollectionEnabled = ,
→       vmOpNotificationToAppEnabled = ,
→       vmOpNotificationTimeout = ,
→       deviceSwap = (vim.vm.VirtualDeviceSwap) null,
→       simultaneousThreads = ,
→       pmem = (vim.vm.VirtualPMem) null,
→       deviceGroups = (vim.vm.VirtualDeviceGroups) null,
→       fixedPassthruHotPlugEnabled = ,
→       metroFtEnabled = ,
→       metroFtHostGroup = ,
→       tdxEnabled = ,
→       sevSnpEnabled =
→    },
→    customization = (vim.vm.customization.Specification) {
→       options = (vim.vm.customization.Options) null,
→       identity = (vim.vm.customization.LinuxPrep) {
→          hostName = (vim.vm.customization.FixedName) {
→             name = “sles16test”
→          },
→          domain = “da.doehler.com”,
→          timeZone = “UTC”,
→          hwClockUTC = true,
→          scriptText = ,
→          compatibleCustomizationMethod =
→       },
→       globalIPSettings = (vim.vm.customization.GlobalIPSettings) {
→          dnsSuffixList = (string) \[
→             “da.doehler.com”
→          \],
→          dnsServerList = (string) \[
→             “192.168.175.20”,
→             “192.168.176.20”
→          \]
→       },
→       nicSettingMap = (vim.vm.customization.AdapterMapping) \[
→          (vim.vm.customization.AdapterMapping) {
→             macAddress = ,
→             adapter = (vim.vm.customization.IPSettings) {
→                ip = (vim.vm.customization.FixedIp) {
→                   ipAddress = “192.168.182.92”
→                },
→                subnetMask = “255.255.255.128”,
→                gateway = (string) \[
→                   “192.168.182.126”
→                \],
→                ipV6Spec = (vim.vm.customization.IPSettings.IpV6AddressSpec) null,
→                dnsServerList = (string) \[
→                   “192.168.175.20”,
→                   “192.168.176.20”
→                \],
→                dnsDomain = “da.doehler.com”,
→                primaryWINS = ,
→                secondaryWINS = ,
→                netBIOS =
→             }
→          }
→       \],
→       encryptionKey =
→    },
→    powerOn = false,
→    snapshot = ,
→    memory = ,
→    tpmProvisionPolicy =
→ }
5

ok, firmware = automatic gives the same error

and by the way … with 3.16 everything was fine

6

ok ok, the source of my problem was that I was running an outdated version of vServer (8.0.3.0400). After upgrading to 8.0.3.0900, I’ve been able to deploy my VMs without any issues (so far).

1 Like
7

Hello,

version 8.0.3.00900 released?

8

Hi @orelops95 ,
I was not able to replicate the issue. I’m still working on it, but in the meantime, I pushed PRs with your suggested fixes so the community can use the packit rpms for testing.

Can you please share your GitHub account so I can co-author with you?
The changes look good to me, but it would be great to have some proof of work from other community members.

9

Hi @lstejska,

my account github: orelops95

10

This is what I don’t understand. The explained logic sounds solid, but hosts usually have a PXE loader defined even if using image based provisioning, usually, from the OS.

Could it be that the OS as you have it defined in Foreman has no PXE templates assigned?

11

Okay, I was able to reproduce this issue with the following setup:

  • an operating system that has no PXE-related templates assigned
  • a hostgroup that has no PXE loader defined (not “None”, no at all)
12

btw, is ths a valid scenario?

13

If you only deploy image based, there is no need to have any of the PXE-related stuff configured, I’d say. (Read: yes)

14

We also experienced this issue and are on vSphere Client version 8.0.3.00800. Here is a fix we applied:

Modify the def create_vm(args = {}) block in /usr/share/foreman/app/models/compute_resources/foreman/model/vmware.rb

Should look similar:

    def create_vm(args = { })
      vm = nil
      test_connection
      return unless errors.empty?

      args = parse_networks(args)
      args = args.with_indifferent_access
      # HOTFIX FOR WINDOWS 2022 UEFI VALIDATION
      if args[:firmware] == 'uefi' || args['firmware'] == 'uefi'
        args[:firmware] = 'efi'
      end

After modifying, restart foreman services.

15

FTR, Fixes #39310 - Normalize firmware type for image based provisioning by stejskalleos · Pull Request #10982 · theforeman/foreman · GitHub was merged and Bug #39310: VMware - Normalize firmware type in clone args - Foreman indicates it’s fixed in 3.18.2 and later releases.

The fix does the same args transformation, but in a differently integrated way :slight_smile: