foreman_hyperv 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65f805250cc59658795113cc0d201de9c2da857b8dc0868bc5a7450be52619ef
-  data.tar.gz: dfbe2e15421b902d38f2747a07ff83dc68661178914a7b2de992d1d4d905003d
+  metadata.gz: 156c82d3cc4630c1d222fc97370cef6b5f3128da1d97732dcef072f8b4adbbe3
+  data.tar.gz: d812c0f6a6785879bbe4cacff1f943237b24951ea8b5b5f2e2add668d2480b58
 SHA512:
-  metadata.gz: 3487dfa1b123b714d5fc093ff23d85fbc49253a0f7cd24308461b2117436e181c38380e9b2acdf3bc1bae3669eabb5dd87475e7946376c6da79aa1eaae5b982b
-  data.tar.gz: 32dc60ede4f1bd60f7c74e56a7c9e648f58757a4bac64cef8e3d09858380984bdf059093e016fb72de3c2bede1f6c94f39cfb7db4a1c5071e4d846777939f0ea
+  metadata.gz: 89a21ca4968ec5adbc536b7cffde5e2619f4e54f704a259e52ec812ccb25271be31674c5bd0f6f154752c1a80d8b2eef836f497fe838781bd6f923ce1e8aa242
+  data.tar.gz: 16c7a09381db0854437d1620d708eabd7415459fc644577e508b45e94cd51e3c5b8bcd722eafeb049140615f15ea54fedbbf80e2a604dab17ecf82c4ea9395e2

data/app/assets/javascripts/foreman_hyperv/compute_resource_base.js

@@ -1,20 +1,3 @@
-$(document).on('ContentLoad', function() { tfm.numFields.initAll(); });
-
-function hypervGenerationChange(item) {
-  var toIter = ['#host_compute_attributes_secure_boot_enabled', '#compute_attribute_vm_attrs_secure_boot_enabled'];
-  gen = $(item).val();
-
-  if (gen == 'BIOS') {
-    for (var i = 0; i < toIter.length; ++i) {
-      $(toIter[i]).attr('disabled', true);
-    }
-  } else {
-    for (var i = 0; i < toIter.length; ++i) {
-      $(toIter[i]).removeAttr('disabled');
-    }
-  }
-}
-
 function hypervDynamicMemoryChange(item) {
   var toIter = [
     '#host_compute_attributes_memory_maximum',

data/app/helpers/foreman_hyperv/compute_resources_vms_helper.rb

@@ -1,17 +1,35 @@
+# frozen_string_literal: true
+
 module ForemanHyperv
   module ComputeResourcesVmsHelper
     def hyperv_networks(compute_resource)
       compute_resource.switches(nil).map do |sw|
-        [ sw.id, "#{sw.name}#{sw.switch_type ? " (#{sw.switch_type})" : nil}" ]
+        [sw.id, "#{sw.name}#{" (#{sw.switch_type})" if sw.switch_type}"]
+      end
+    end
+
+    def hyperv_boot_devices
+      devices = Fog::Hyperv::BOOT_DEVICE_ENUM_VALUES.dup
+      # devices.delete :Floppy if generation == :UEFI
+      devices.delete :IDE
+      devices.delete :LegacyNetworkAdapter
+      devices.map do |dev|
+        name = dev.to_s
+        name = 'Network Adapter' if dev == :NetworkAdapter
+        name = 'DVD' if dev == :CD
+        name = 'Floppy (Only for BIOS)' if dev == :Floppy
+        [dev, name]
       end
     end
 
     def hyperv_generations
       Fog::Hyperv::Compute::Server::VM_GENERATION_VALUES.map { |gen, num| [gen, "Generation #{num} (#{gen})"] }
     end
+
     def hyperv_vlan_modes
       Fog::Hyperv::Compute::NetworkAdapterVlan::VLAN_OPERATION_MODE.map { |mode| [mode, mode] }
     end
+
     def hyperv_private_vlan_modes
       Fog::Hyperv::Compute::NetworkAdapterVlan::PRIVATE_VLAN_MODE.reject { |mode| mode == :Unknown }.map { |mode| [mode, mode] }
     end

data/app/models/concerns/fog_extensions/hyperv/compute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FogExtensions
   module Hyperv
     module Compute

data/app/models/concerns/fog_extensions/hyperv/hard_drive.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FogExtensions
   module Hyperv
     module HardDrive
@@ -27,8 +29,8 @@ module FogExtensions
           .slice(:id)
           .merge(
             {
-              basename:,
-              size_bytes:
+              basename: basename,
+              size_bytes: size_bytes
             }.compact
           )
       end

data/app/models/concerns/fog_extensions/hyperv/network_adapter.rb

@@ -7,16 +7,17 @@ module FogExtensions
 
       def mac
         return unless mac_address
-        return if mac_address.to_i(16) == 0
+        return if mac_address.to_i(16).zero?
 
         # Downcase and split every 2 chars, join with :
-        mac_address.downcase.scan(%r{.{2}}).join(':')
+        mac_address.downcase.scan(/.{2}/).join(':')
       end
 
       def mac=(m)
         mac_address = m&.upcase&.delete(':')
         mac_address = Fog::Hyperv::Compute::NetworkAdapter::NIC_FALLBACK_MAC if mac_address.nil? || mac_address.blank?
-        dynamic_mac_address_enabled = (mac_address.to_i(16) == 0)
+        mac_address.to_i(16)
+        0
       end
 
       # VLAN settings
@@ -24,6 +25,7 @@ module FogExtensions
       def vlan_operation_mode
         vlan_setting.operation_mode
       end
+
       def vlan_operation_mode=(mode)
         vlan_setting.operation_mode = mode
       end
@@ -33,61 +35,60 @@ module FogExtensions
 
         vlan_setting.private_vlan_mode
       end
+
       def vlan_private_mode=(mode)
         vlan_setting.private_vlan_mode = mode
       end
 
       def access_vlan_id
-        return nil if vlan_setting.access_vlan_id.zero?
+        return nil if (vlan_setting.access_vlan_id || 0).zero?
 
         vlan_setting.access_vlan_id
       end
-      def access_vlan_id=(id)
-        vlan_setting.access_vlan_id = id
-      end
+
+      delegate :access_vlan_id=, to: :vlan_setting
 
       def native_vlan_id
-        return nil if vlan_setting.native_vlan_id.zero?
+        return nil if (vlan_setting.native_vlan_id || 0).zero?
 
         vlan_setting.native_vlan_id
       end
-      def native_vlan_id=(id)
-        vlan_setting.native_vlan_id = id
-      end
+
+      delegate :native_vlan_id=, to: :vlan_setting
 
       def allowed_vlan_ids
         return nil unless vlan_setting.allowed_vlan_id_list&.any?
 
         Fog::Hyperv::Compute::NetworkAdapterVlan.render_vlan_list vlan_setting.allowed_vlan_id_list
       end
+
       def allowed_vlan_ids=(ids)
         ids ||= ''
         vlan_setting.allowed_vlan_id_list = parse_vlan_list(ids)
       end
 
       def primary_vlan_id
-        return nil if vlan_setting.primary_vlan_id.zero?
+        return nil if (vlan_setting.primary_vlan_id || 0).zero?
 
         vlan_setting.primary_vlan_id
       end
-      def primary_vlan_id=(id)
-        vlan_setting.primary_vlan_id = id
-      end
+
+      delegate :primary_vlan_id=, to: :vlan_setting
 
       def secondary_vlan_id
-        return nil if vlan_setting.secondary_vlan_id.zero?
+        return nil if (vlan_setting.secondary_vlan_id || 0).zero?
 
         vlan_setting.secondary_vlan_id
       end
-      def secondary_vlan_id=(id)
-        vlan_setting.secondary_vlan_id = id
-      end
+
+      delegate :secondary_vlan_id=, to: :vlan_setting
 
       def secondary_vlan_ids
         return nil unless vlan_setting.secondary_vlan_id_list&.any?
 
         Fog::Hyperv::Compute::NetworkAdapterVlan.render_vlan_list vlan_setting.secondary_vlan_id_list
       end
+
       def secondary_vlan_ids=(ids)
         ids ||= ''
         vlan_setting.secondary_vlan_id_list = parse_vlan_list(ids)
@@ -100,17 +101,20 @@ module FogExtensions
             :switch_id
           )
           .merge(
-            {
-              vlan_operation_mode:,
-              vlan_private_mode:,
-              access_vlan_id:,
-              native_vlan_id:,
-              allowed_vlan_ids:,
-              primary_vlan_id:,
-              secondary_vlan_id:,
-              secondary_vlan_ids:
-            }.compact
+            vlan_setting.attributes.slice(
+              :vlan_operation_mode,
+              :vlan_private_mode,
+              :access_vlan_id,
+              :native_vlan_id,
+              :primary_vlan_id,
+              :secondary_vlan_id
+            )
+          )
+          .merge(
+            secondary_vlan_ids: secondary_vlan_ids,
+            allowed_vlan_ids: allowed_vlan_ids
           )
+          .compact
       end
 
       private

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FogExtensions
   module Hyperv
     module Server
@@ -9,7 +11,7 @@ module FogExtensions
       end
 
       def folder_name
-        name.gsub(/[^0-9A-Za-z.\-]/, '_')
+        name.gsub(/[^0-9A-Za-z.-]/, '_')
       end
 
       def mac
@@ -40,7 +42,20 @@ module FogExtensions
       def cluster_name=(name)
         @cluster = service.clusters.get(name)
       end
-      #
+
+      def boot_device
+        :NetworkAdapter
+      end
+
+      def foreman_firmware_type
+        return 'bios' if generation_num == 1
+
+        secure_boot_enabled ? 'uefi_secure_boot' : 'uefi'
+      end
+
+      def foreman_firmware
+        generation_num == 1 ? 'bios' : 'efi'
+      end
 
       def vlan
         nic = network_adapters.first
@@ -51,7 +66,7 @@ module FogExtensions
       def vlan=(vlan)
         logger.warn "using vlan=#{vlan.inspect} on Hyper-V VM, this can lead to unexpected results"
         nic = network_adapters.first
-        if vlan.present? && vlan.to_i > 0
+        if vlan.present? && vlan.to_i.positive?
           nic.vlan_operation_mode = :Access if nic.vlan_operation_mode == :Untagged
           case nic.vlan_operation_mode
           when :Access
@@ -68,16 +83,15 @@ module FogExtensions
 
       def secure_boot_enabled=(enabled)
         return if generation != :UEFI
-
-        @secure_boot = enabled
         return unless persisted?
 
         firmware.secure_boot = enabled ? :On : :Off
+        firmware.save
       end
 
       def secure_boot_enabled
         return false if generation != :UEFI
-        return @secure_boot unless persisted?
+        return unless persisted?
 
         firmware.secure_boot == :On
       end
@@ -103,29 +117,35 @@ module FogExtensions
         match ||= fog_nics.detect { |fn| fn.mac == nic.mac }
         # match ||= fog_nics.detect { |fn| fn.name == nic_attrs['name'].presence }
 
-        if !match
+        unless match
           # Match on networking, limit potentials down to identical configuration and then pick the first
           potential = fog_nics.select do |fn|
             fn.switch_id == nic_attrs['switch_id'].presence || fn.switch_name == nic_attrs['switch_name'].presence
           end
           potential.select! { |fn| fn.vlan_operation_mode.to_s == nic_attrs['vlan_operation_mode'] }
-          if nic_attrs['vlan_operation_mode'] == 'Access'
+          case nic_attrs['vlan_operation_mode']
+          when 'Access'
             potential.select! { |fn| fn.access_vlan_id.to_s == nic_attrs['access_vlan_id'] }
-          elsif nic_attrs['vlan_operation_mode'] == 'Trunk'
+          when 'Trunk'
             potential.select! { |fn| fn.native_vlan_id.to_s == nic_attrs['native_vlan_id'] }
-            potential.select! { |fn| fn.allowed_vlan_ids.split(',').map(&:strip) == nic_attrs['allowed_vlan_ids'].split(',').map(&:strip) } \
-              if nic_attrs['allowed_vlan_ids'].present?
-          elsif nic_attrs['vlan_operation_mode'] == 'Private'
+            if nic_attrs['allowed_vlan_ids'].present?
+              potential.select! do |fn|
+                fn.allowed_vlan_ids.split(',').map(&:strip) == nic_attrs['allowed_vlan_ids'].split(',').map(&:strip)
+              end
+            end
+          when 'Private'
             potential.select! { |fn| fn.vlan_private_mode.to_s == nic_attrs['vlan_private_mode'] }
             potential.select! { |fn| fn.primary_vlan_id.to_s == nic_attrs['primary_vlan_id'].to_s } \
               if nic_attrs['primary_vlan_id'].present?
 
             if nic_attrs['vlan_private_mode'] == 'Promiscuous'
-              potential.select! { |fn| fn.secondary_vlan_ids.split(',').map(&:strip) == nic_attrs['secondary_vlan_ids'].split(',').map(&:strip) } \
-                if nic_attrs['secondary_vlan_ids'].present?
-            else
-              potential.select! { |fn| fn.secondary_vlan_id.to_s == nic_attrs['secondary_vlan_id'].to_s } \
-                if nic_attrs['secondary_vlan_id'].present?
+              if nic_attrs['secondary_vlan_ids'].present?
+                potential.select! do |fn|
+                  fn.secondary_vlan_ids.split(',').map(&:strip) == nic_attrs['secondary_vlan_ids'].split(',').map(&:strip)
+                end
+              end
+            elsif nic_attrs['secondary_vlan_id'].present?
+              potential.select! { |fn| fn.secondary_vlan_id.to_s == nic_attrs['secondary_vlan_id'].to_s }
             end
           end
 

data/app/models/concerns/foreman_hyperv/host_managed_extensions.rb

@@ -16,9 +16,9 @@ module ForemanHyperv
 
       begin
         hyperv_sync_interfaces
-      rescue => e
+      rescue StandardError => e
         failure _("Failed to update a compute %{compute_resource} instance %{name}: %{e}") %
-                { compute_resource:, name:, e: }, e
+                { compute_resource: compute_resource, name: name, e: e }, e
       end
       true
     end
@@ -41,8 +41,7 @@ module ForemanHyperv
         selected_nic = vm.select_nic(fog_nics, nic)
         if selected_nic.nil?
           logger.warn "Orchestration::Compute: Could not match network interface #{nic.inspect}"
-          raise ArgumentError, \
-            _("Could not find virtual machine network interface matching %s") %
+          raise ArgumentError, _("Could not find virtual machine network interface matching %s") %
             [nic.identifier, nic.ip, nic.name, nic.type].find(&:present?)
         end
 

data/app/models/foreman_hyperv/hyperv.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ForemanHyperv
   class Hyperv < ::ComputeResource
     include ComputeResourceCaching
@@ -37,7 +39,7 @@ module ForemanHyperv
       validate_connectivity(options)
     end
 
-    def validate_connectivity(options = {})
+    def validate_connectivity(_options = {})
       return unless connection_properties_valid?
       return false if errors.any?
 
@@ -66,10 +68,6 @@ module ForemanHyperv
       super.merge(mac: :mac)
     end
 
-    def editable_network_interfaces?
-      true
-    end
-
     # TODO
     def max_cpu_count(host = nil)
       (host || hypervisor).logical_processor_count
@@ -110,6 +108,10 @@ module ForemanHyperv
       )
     end
 
+    def associated_host(vm)
+      associate_by("mac", vm.network_adapters.map(&:mac))
+    end
+
     delegate :servers, to: :client
 
     def switches(host)
@@ -122,12 +124,16 @@ module ForemanHyperv
     end
 
     def new_vm(attr = {})
+      firmware_type = attr.delete(:firmware_type).to_s
+      attr.merge!(process_firmware_attributes(attr[:foreman_firmware], firmware_type)) #, attr[:provision_method]))
       attr.delete :id
+
+      # logger.debug "New VM with arguments;\n#{attr}"
       vm = super
       iface_nested_attrs = nested_attributes_for :interfaces, attr[:interfaces_attributes]
       vm.network_adapters = iface_nested_attrs.map do |attr|
         attr.delete :id
-        Fog::Hyperv::Compute::NetworkAdapter.new(service: vm.service, vm:).tap do |nic|
+        Fog::Hyperv::Compute::NetworkAdapter.new(service: vm.service, vm: vm).tap do |nic|
           attr.select { |_, v| v.present? }.each do |k, v|
             nic.send(:"#{k}=", v)
           end
@@ -136,7 +142,7 @@ module ForemanHyperv
       volume_nested_attrs = nested_attributes_for :volumes, attr[:volumes_attributes]
       vm.hard_drives = volume_nested_attrs.map do |attr|
         attr.delete :id
-        Fog::Hyperv::Compute::HardDrive.new(service: vm.service, vm:).tap do |hdd|
+        Fog::Hyperv::Compute::HardDrive.new(service: vm.service, vm: vm).tap do |hdd|
           attr.select { |_, v| v.present? }.each do |k, v|
             hdd.send(:"#{k}=", v)
           end
@@ -151,13 +157,17 @@ module ForemanHyperv
       attr.delete :computer_name if attr[:computer_name].blank?
       attr.delete :start
 
+      firmware_type = attr.delete(:firmware_type).to_s
+      attr.merge!(process_firmware_attributes(attr[:foreman_firmware], firmware_type)) #, attr[:provision_method]))
+
       validate_vm(attr, new: true)
       validate_interfaces(attr)
       validate_volumes(attr)
 
+      # logger.debug "Creating VM with arguments; #{attr}"
       vm = client.servers.new(
         name: attr[:name],
-        computer_name: attr[:computer_name],
+        computer_name: attr[:computer_name].presence || hypervisor.name,
         generation: attr[:generation],
         dynamic_memory_enabled: Foreman::Cast.to_bool(attr[:dynamic_memory_enabled]),
         memory_startup: attr[:memory_startup].to_i,
@@ -166,13 +176,20 @@ module ForemanHyperv
         processor_count: attr[:processor_count].to_i,
         notes: attr[:notes]
       )
-      # TODO: Allow configuring boot device?
-      vm.create boot_device: :NetworkAdapter
+      vm.create(
+        # TODO: should be :VHD if image build - when image build support exists
+        boot_device: attr[:boot_device].present? ? attr[:boot_device].to_sym : :NetworkAdapter,
+        path: hypervisor.virtual_machine_path
+      )
 
-      if vm.generation == :UEFI && attr[:secure_boot_enabled].present?
-        f = vm.firmware
-        f.secure_boot = Foreman::Cast.to_bool(attr[:secure_boot_enabled]) ? :On : :Off
-        f.save if f.dirty?
+      if vm.generation == :UEFI
+        vm.secure_boot_enabled = attr[:secure_boot_enabled]
+        if attr[:tpm_enabled] == '1'
+          security = vm.security
+          security.change_key_protector :new
+          security.tpm_enabled = true
+          security.save
+        end
       end
 
       create_interfaces(vm, attr)
@@ -180,27 +197,26 @@ module ForemanHyperv
 
       vm.start if attr[:start] == '1'
       vm
-    rescue StandardError => e
-      if vm
+    rescue StandardError
+      if vm&.persisted?
         vm.stop
         vm.hard_drives.each { |hdd| hdd.destroy(underlying: true) }
-        vm.destroy
+        vm.destroy(vm.path.end_with?(vm.name))
       end
 
-      raise e
+      raise
     end
 
     def save_vm(uuid, web_attr)
       attr = web_attr.deep_symbolize_keys
+      attr.delete :start
 
       validate_vm(attr)
       validate_interfaces(attr)
       validate_volumes(attr)
 
-      attr.delete :start
-
       vm = find_vm_by_uuid(uuid)
-      logger.debug "Updating VM #{vm} with arguments; #{attr}"
+      # logger.debug "Updating VM #{vm} with arguments; #{attr}"
 
       vm.processor_count = attr[:processor_count].to_i
       vm.notes = attr[:notes].presence
@@ -209,10 +225,19 @@ module ForemanHyperv
         vm.memory_minimum = attr[:memory_minimum].to_i
         vm.memory_maximum = attr[:memory_maximum].to_i
       end
-      if vm.generation == :UEFI && attr[:secure_boot_enabled].present?
-        f = vm.firmware
-        f.secure_boot = Foreman::Cast.to_bool(attr[:secure_boot_enabled]) ? :On : :Off
-        f.save if f.dirty?
+      if vm.generation == :UEFI && attr[:tpm_enabled].present?
+        security = vm.security
+        security.tpm_enabled = attr[:tpm_enabled] == '1'
+        if security.tpm_enabled && security.key_protector.nil?
+          security.change_key_protector :new
+        end
+        security.save
+      end
+      if attr[:foreman_firmware].present?
+        firmware_type = attr.delete(:firmware_type).to_s
+        attr.merge!(process_firmware_attributes(attr[:foreman_firmware], firmware_type)) #, attr[:provision_method]))
+
+        vm.secure_boot_enabled = attr[:secure_boot_enabled]
       end
 
       update_interfaces(vm, attr)
@@ -227,35 +252,36 @@ module ForemanHyperv
       vm.stop turn_off: true
       vm.hard_drives.each { |hdd| hdd.destroy(underlying: true) }
       # TODO: Remove the empty VM folder
-      vm.destroy
+      vm.destroy(vm.path.end_with?(vm.name))
     rescue ActiveRecord::RecordNotFound, Fog::Errors::NotFound
       # if the VM does not exists, we don't really care.
       true
     end
 
     def update_required?(old_attrs, new_attrs)
-      new_attrs.deep_symbolize_keys[:volumes_attributes]&.each do |_, hdd|
+      new_attrs.deep_symbolize_keys[:volumes_attributes]&.each_value do |hdd|
         if hdd[:id].present? && hdd[:_delete] == '1'
-          Rails.logger.debug "Scheduling compute instance update because a volume was removed"
+          Rails.logger.debug 'Scheduling compute instance update because a volume was removed'
           return true
-        elsif !hdd[:id].present? && hdd[:_delete] != '1'
-          Rails.logger.debug "Scheduling compute instance update because a new volume was added"
+        elsif hdd[:id].blank? && hdd[:_delete] != '1'
+          Rails.logger.debug 'Scheduling compute instance update because a new volume was added'
           return true
         end
       end
-      new_attrs.deep_symbolize_keys[:interfaces_attributes]&.each do |_, iface|
+      new_attrs.deep_symbolize_keys[:interfaces_attributes]&.each_value do |iface|
         if iface[:id].present? && iface[:_destroy] == '1'
-          Rails.logger.debug "Scheduling compute instance update because an interface was removed"
+          Rails.logger.debug 'Scheduling compute instance update because an interface was removed'
           return true
-        elsif !iface[:id].present? && iface[:_destroy] != '1'
-          Rails.logger.debug "Scheduling compute instance update because a new interface was added"
+        elsif iface[:id].blank? && iface[:_destroy] != '1'
+          Rails.logger.debug 'Scheduling compute instance update because a new interface was added'
           return true
         end
       end
 
-      deep_update_required = proc do |old, new|
+      deep_update_required = proc do |path, old, new|
         old.merge(new) do |k, old_v, new_v|
-          if k == :allowed_vlan_ids || k == :secondary_vlan_ids
+          k_path = path + [k]
+          if %i[allowed_vlan_ids secondary_vlan_ids].include?(k)
             tmp = Fog::Hyperv::Compute::NetworkAdapter.new
 
             old_v = Fog::Hyperv::Compute::NetworkAdapterVlan.render_vlan_list(tmp.send(:parse_vlan_list, old_v.to_s))
@@ -263,15 +289,17 @@ module ForemanHyperv
           end
 
           if old_v.is_a?(Hash) && new_v.is_a?(Hash)
-            deep_update_required.call(old_v, new_v)
+            deep_update_required.call(k_path, old_v, new_v)
           elsif old_v.to_s != new_v.to_s
-            Rails.logger.debug "Scheduling compute instance update because #{k} changed it's value from '#{old_v}' (#{old_v.class}) to '#{new_v}' (#{new_v.class})"
+            Rails.logger.debug do
+              "Scheduling compute instance update because #{k_path.join('.')} changed it's value from '#{old_v}' (#{old_v.class}) to '#{new_v}' (#{new_v.class})"
+            end
             return true
           end
           new_v
         end
       end
-      deep_update_required.call(old_attrs.deep_symbolize_keys, new_attrs.deep_symbolize_keys)
+      deep_update_required.call([], old_attrs.deep_symbolize_keys, new_attrs.deep_symbolize_keys)
 
       false
     end
@@ -293,8 +321,8 @@ module ForemanHyperv
       basename = attr.delete(:basename) { 'Disk' }
       size = attr.delete(:size)
 
-      vhd = client.vhds.new({ basename:, size: }.compact)
-      Fog::Hyperv::Compute::HardDrive.new vhd:, **attr
+      vhd = client.vhds.new({ basename: basename, size: size }.compact)
+      Fog::Hyperv::Compute::HardDrive.new vhd: vhd, **attr
     end
 
     def new_cdrom(attr = {})
@@ -303,13 +331,26 @@ module ForemanHyperv
 
     def vm_instance_defaults
       super.merge(
-        generation:      2,
-        memory_startup:  1024.megabytes,
+        generation: 2,
+        memory_startup: 1024.megabytes,
         processor_count: 1,
-        interfaces:      [new_interface]
+        interfaces: [new_interface]
       )
     end
 
+    def vm_compute_attributes(vm)
+      attr = super.slice(
+        :computer_name, :name, :generation,
+        :dynamic_memory_enabled,
+        :memory_maximum, :memory_minimum, :memory_startup,
+        :notes, :processor_count
+      )
+      attr[:foreman_firmware] = vm.foreman_firmware_type
+      attr[:tpm_enabled] = vm.tpm_enabled
+
+      attr
+    end
+
     def set_vm_volumes_attributes(vm, vm_attrs)
       volumes = vm.hard_drives || []
       vm_attrs[:volumes_attributes] = volumes.each_with_index.to_h do |volume, index|
@@ -344,25 +385,30 @@ module ForemanHyperv
     private
 
     def _clusters
-      if client.respond_to? :supports_clusters?
-        return [] unless client.supports_clusters?
-      end
+      return [] if client.respond_to?(:supports_clusters?) && !client.supports_clusters?
 
       client.clusters.all
-    rescue
+    rescue StandardError
       []
     end
 
     def validate_vm(attr, new: false)
       # logger.debug "Validate VM #{attr.inspect}"
-      raise Foreman::Exception, 'VM lacks generation' if new && !attr[:generation].present?
-      raise Foreman::Exception, 'VM lacks memory' unless attr[:memory_startup].to_i > 0
-      raise Foreman::Exception, 'VM lacks CPUs' unless attr[:processor_count].to_i > 0
+      raise Foreman::Exception, 'VM lacks generation' if new && attr[:generation].blank?
+      raise Foreman::Exception, 'VM lacks memory' unless attr[:memory_startup].to_i.positive?
+      raise Foreman::Exception, 'VM lacks CPUs' unless attr[:processor_count].to_i.positive?
 
-      if Foreman::Cast.to_bool(attr[:dynamic_memory_enabled])
-        raise Foreman::Exception, 'VM lacks memory minimum' unless attr[:memory_minimum].to_i > 0
-        raise Foreman::Exception, 'VM lacks memory maximum' unless attr[:memory_maximum].to_i > 0
-      end
+      return unless Foreman::Cast.to_bool(attr[:dynamic_memory_enabled])
+      raise Foreman::Exception, 'VM lacks memory minimum' unless attr[:memory_minimum].to_i.positive?
+      raise Foreman::Exception, 'VM lacks memory maximum' unless attr[:memory_maximum].to_i.positive?
+    end
+
+    def generate_secure_boot_settings(firmware)
+      return {} unless firmware.to_s.include?('efi')
+
+      {
+        secure_boot_enabled: firmware.to_s.end_with?('secure_boot')
+      }
     end
 
     def validate_interfaces(attr)
@@ -373,18 +419,26 @@ module ForemanHyperv
         compute = iface[:compute_attributes] || iface
         case compute[:vlan_operation_mode].to_s
         when 'Untagged'
+          # No VLAN settings to verify
         when 'Access'
-          raise Foreman::Exception, 'Interface is missing access VLAN' unless compute[:access_vlan_id].to_i > 0
+          raise Foreman::Exception, 'Interface is missing access VLAN' unless compute[:access_vlan_id].to_i.positive?
         when 'Trunk'
-          raise Foreman::Exception, 'Interface is missing native VLAN' unless compute[:native_vlan_id].to_i > 0
-          raise Foreman::Exception, 'Interface is missing allowed VLANs' unless compute[:allowed_vlan_ids].present?
+          raise Foreman::Exception, 'Interface is missing native VLAN' unless compute[:native_vlan_id].to_i.positive?
+          raise Foreman::Exception, 'Interface is missing allowed VLANs' if compute[:allowed_vlan_ids].blank?
         when 'Private'
-          raise Foreman::Exception, 'Interface is missing primary VLAN' unless compute[:primary_vlan_id].to_i > 0
+          raise Foreman::Exception, 'Interface is missing primary VLAN' unless compute[:primary_vlan_id].to_i.positive?
+
           case compute[:vlan_private_mode].to_s
           when 'Promiscuous'
-            raise Foreman::Exception, 'Interface is missing secondary VLANs' unless compute[:secondary_vlan_ids].present?
+            if compute[:secondary_vlan_ids].blank?
+              raise Foreman::Exception,
+                    'Interface is missing secondary VLANs'
+            end
           else
-            raise Foreman::Exception, 'Interface is missing secondary VLAN' unless compute[:secondary_vlan_id].to_i > 0
+            unless compute[:secondary_vlan_id].to_i.positive?
+              raise Foreman::Exception,
+                    'Interface is missing secondary VLAN'
+            end
           end
         else
           raise Foreman::Exception, 'Interface has unknown VLAN mode'
@@ -411,7 +465,9 @@ module ForemanHyperv
         nic.save
       end
 
-      return unless vm.network_adapters.all(_return_fields: %i[dynamic_mac_address_enabled]).any?(&:dynamic_mac_address_enabled)
+      unless vm.network_adapters.all(_return_fields: %i[dynamic_mac_address_enabled]).any?(&:dynamic_mac_address_enabled)
+        return
+      end
 
       # Populate all non-populated MAC addresses
       vm.start
@@ -456,11 +512,13 @@ module ForemanHyperv
       volumes.reject! { |vol| vol[:_delete] == '1' }
       # logger.debug "Validate Volume #{volumes.inspect}"
       volumes.each do |vol|
-        raise Foreman::Exception, 'Volume lacks name' unless vol[:basename].present?
+        raise Foreman::Exception, 'Volume lacks name' if vol[:basename].blank?
         raise Foreman::Exception, 'Volume name should not include a file extension' if vol[:basename] =~ /\.vhd[sx]?$/
-        raise Foreman::Exception, 'Volume lacks size' unless vol[:size_bytes].to_i > 0
+        raise Foreman::Exception, 'Volume lacks size' unless vol[:size_bytes].to_i.positive?
       end
-      raise Foreman::Exception, 'Volume names need to be unique' if volumes.group_by { |vol| vol[:basename].downcase }.any? { |k, v| v.count > 1 }
+      return unless volumes.group_by { |vol| vol[:basename].downcase }.any? { |_k, v| v.many? }
+
+      raise Foreman::Exception, 'Volume names need to be unique'
     end
 
     def create_volumes(vm, attr)
@@ -468,7 +526,7 @@ module ForemanHyperv
       logger.debug "Creating volumes with: #{volumes}"
       volumes.each do |vol|
         vhd = vm.vhds.create basename: vol[:basename], size: vol[:size_bytes].to_i
-        vm.hard_drives.create vhd:
+        vm.hard_drives.create vhd: vhd
       end
     end
 

data/app/views/compute_resources_vms/form/hyperv/_base.html.erb

@@ -14,34 +14,12 @@
     cluster_errors << ex
   end
 -%>
-<% if clusters.any? %>
+<% if clusters.any? -%>
   <%= select_f f, :cluster_name, clusters, :to_s, :to_s, { include_blank: true }, label: _('Cluster'), disabled: !new_host %>
-  <% if computers.count > 1 %>
+  <% if computers.count > 1 -%>
     <%= select_f f, :computer_name, computers, :name, :name, {}, label: _('Computer Name'), disabled: !new_host, onload: 'hypervHostChange(this);', onchange: 'hypervHostChange(this);' %>
   <% end -%>
-<% end %>
-<div class="clearfix">
-  <div class="form-group">
-    <label class="col-md-2 control-label">Available resources</label>
-    <div class="col-md-4 help-block" id="hypervComputerInformation">
-<% computers.each do |host| -%>
-      <table class="hyperv-host-info" style="<%= (host.name == f.object.computer_name) ? '' : 'display: none' %>" data-host="<%= host.name %>">
-        <tbody>
-          <tr>
-            <td>CPU:</td>
-            <td style="padding-left:0.5em;"><%= host.logical_processor_count %></td>
-          </tr>
-          <tr>
-            <td>Memory:</td>
-            <td style="padding-left:0.5em;"><%= number_to_human_size(host.memory_capacity) %></td>
-          </tr>
-        </tbody>
-      </table>
 <% end -%>
-    </div>
-  </div>
-</div>
-
 <% cluster_errors.each do |err| -%>
 <div class="alert alert-warning alert-dismissable">
   <button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
@@ -49,10 +27,22 @@
 </div>
 <% end -%>
 
-<%= select_f f, :generation, hyperv_generations, :first, :last, {}, label: 'Firmware', disabled: !new_host, onchange: 'hypervGenerationChange(this);' %>
-<% if new_host || f.object.generation == :UEFI -%>
-<%= checkbox_f f, :secure_boot_enabled, { label: _('Enable Secure Boot'), disabled: f.object.generation == :BIOS }, 'true', 'false' %>
-<% end -%>
+<%
+  firmware_type = compute_resource.firmware_type(f.object.foreman_firmware, f.object.secure_boot_enabled)
+-%>
+<%= field(f, :foreman_firmware, :label => _('Firmware'), :label_help => _("Choose 'Automatic' to set the firmware based on the PXE loader of the host. If no PXE loader is selected, firmware defaults to BIOS."), :label_size => "col-md-2") do
+  compute_resource.firmware_types.collect do |type, name|
+    enabled = new_vm
+    enabled ||= firmware_type != :bios && type.to_s.start_with?('uefi')
+
+    radio_button_f f, :foreman_firmware, { :checked => (firmware_type == type), :disabled => !enabled, :value => type, :text => _(name) }
+  end.join(' ').html_safe
+end %>
+<%= checkbox_f f, :tpm_enabled, { help_inline: _('Add Virtual TPM module to the VM.'),
+                                  label: _('Virtual TPM'),
+                                  label_help: _('Only compatible with UEFI firmware.'),
+                                  label_size: 'col-md-2' } %>
+<%= select_f f, :boot_device, hyperv_boot_devices, :first, :last, {}, label: _('Boot device'), label_help: _('Has effect only for network based provisioning'), class: 'col-md-2' if new_vm %>
 
 <%= counter_f f, :processor_count, label: _('CPUs'), label_size: 'col-md-2' %>
 <%= byte_size_f f, :memory_startup, label: _('Memory (Startup)'), label_size: 'col-md-2' %>
@@ -61,7 +51,7 @@
 <%= byte_size_f f, :memory_maximum, class: 'col-md-2', label: _('Memory Maximum'), disabled: !f.object.dynamic_memory_enabled %>
 <%= byte_size_f f, :memory_minimum, class: 'col-md-2', label: _('Memory Minimum'), disabled: !f.object.dynamic_memory_enabled %>
 
-<% checked = params[:host] && params[:host][:compute_attributes] && params[:host][:compute_attributes][:start] || '1' %>
+<% checked = params[:host] && params[:host][:compute_attributes] && params[:host][:compute_attributes][:start] || '1' -%>
 <%= checkbox_f f, :start, { checked: (checked == '1'), help_inline: _("Power ON this machine"), label: _('Start'), label_size: "col-md-2"} if new_host && controller_name != "compute_attributes" %>
 
 <%= textarea_f f, :notes, rows: '3', label: _('Notes') %>

data/app/views/compute_resources_vms/form/hyperv/_network.html.erb

@@ -9,26 +9,26 @@
 
 <%# If Access mode %>
 <div data-hyperv-vlan-mode="access" class="<%= 'hide' unless f.object.vlan_operation_mode.to_s == 'Access' %>">
-<%= number_f f, :access_vlan_id, label: _('Access VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Access') %>
+  <%= number_f f, :access_vlan_id, label: _('Access VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Access') %>
 </div>
 <%# If Trunk mode %>
 <div data-hyperv-vlan-mode="trunk" class="<%= 'hide' unless f.object.vlan_operation_mode.to_s == 'Trunk' %>">
-<%= number_f f, :native_vlan_id, label: _('Native VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Trunk') %>
-<%= text_f f, :allowed_vlan_ids, placeholder: '10,20-40,50', label: _('Allowed VLANs'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Trunk') %>
+  <%= number_f f, :native_vlan_id, label: _('Native VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Trunk') %>
+  <%= text_f f, :allowed_vlan_ids, placeholder: '10,20-40,50', label: _('Allowed VLANs'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Trunk') %>
 </div>
 <%# If Private mode %>
 <div data-hyperv-vlan-mode="private" class="<%= 'hide' unless f.object.vlan_operation_mode.to_s == 'Private' %>">
-<%= select_f f, :vlan_private_mode, hyperv_private_vlan_modes, :first, :last, {},
-  label: _('VLAN private mode'), label_size: 'col-md-3', size: 'col-md-8',
-  onchange: 'hypervVLANPrivateModeChange(this);',
-  disabled: (f.object.vlan_operation_mode.to_s != 'Private') %>
-<%= number_f f, :primary_vlan_id, label: _('Primary VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Private') %>
-<%# If Isolated or Community private mode %>
-<div data-hyperv-vlan-private-mode="singular" class="<%= 'hide' if f.object.vlan_private_mode.to_s == 'Promiscuous' %>">
-<%= number_f f, :secondary_vlan_id, label: _('Secondary VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Private' || f.object.vlan_private_mode.to_s == 'Promiscuous') %>
-</div>
-<%# If Promiscuous private mode %>
-<div data-hyperv-vlan-private-mode="plural" class="<%= 'hide' unless f.object.vlan_private_mode.to_s == 'Promiscuous' %>">
-<%= text_f f, :secondary_vlan_ids, placeholder: '10,20-40,50', label: _('Secondary VLANs'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Private' || f.object.vlan_private_mode.to_s != 'Promiscuous') %>
-</div>
+  <%= select_f f, :vlan_private_mode, hyperv_private_vlan_modes, :first, :last, {},
+    label: _('VLAN private mode'), label_size: 'col-md-3', size: 'col-md-8',
+    onchange: 'hypervVLANPrivateModeChange(this);',
+    disabled: (f.object.vlan_operation_mode.to_s != 'Private') %>
+  <%= number_f f, :primary_vlan_id, label: _('Primary VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Private') %>
+  <%# If Isolated or Community private mode %>
+  <div data-hyperv-vlan-private-mode="singular" class="<%= 'hide' if f.object.vlan_private_mode.to_s == 'Promiscuous' %>">
+    <%= number_f f, :secondary_vlan_id, label: _('Secondary VLAN'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Private' || f.object.vlan_private_mode.to_s == 'Promiscuous') %>
+  </div>
+  <%# If Promiscuous private mode %>
+  <div data-hyperv-vlan-private-mode="plural" class="<%= 'hide' unless f.object.vlan_private_mode.to_s == 'Promiscuous' %>">
+    <%= text_f f, :secondary_vlan_ids, placeholder: '10,20-40,50', label: _('Secondary VLANs'), label_size: 'col-md-3', size: 'col-md-8', required: true, disabled: (f.object.vlan_operation_mode.to_s != 'Private' || f.object.vlan_private_mode.to_s != 'Promiscuous') %>
+  </div>
 </div>

data/app/views/compute_resources_vms/form/hyperv/_volume.html.erb

@@ -4,5 +4,5 @@
 <%= f.hidden_field :id %>
 <%= f.hidden_field :basename %>
 <% end -%>
-<%= text_f f, :basename, label: _('Name'), help_inline: _('This is the VHD filename on disk, without extension'), required: true, disabled: f.object.persisted? %>
+<%= text_f f, :basename, label: _('Name'), label_help: _('This is the VHD filename on disk, without extension'), required: true, disabled: f.object.persisted? %>
 <%= byte_size_f f, :size_bytes, label: _('Size') %>

data/lib/foreman_hyperv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanHyperv
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_hyperv
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexander Olofsson
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -51,6 +51,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -105,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="