foreman_hyperv 0.0.3 → 0.1.0

data/README.md

@@ -4,7 +4,13 @@
 
 Microsoft Hyper-V compute resource for Foreman
 
-Uses the in-development `fog-hyperv` gem found [here](https://github.com/ace13/fog-hyperv).
+Uses the in-development `fog-hyperv` gem found [here](https://github.com/ananace/fog-hyperv).
+
+## Nota Bene
+
+Currently the plugin only supports Hyper-V hosts where the names are well defined in DNS and in connection strings, avoid using IP addresses for now.
+
+If you're using SELinux, you may need to enable the connect_all boolean. For Foreman 2.0 and earlier, run `setsebool -P passenger_can_connect_all 1`. For Foreman 2.1 and later the command would be `setsebool -P foreman_rails_can_connect_all 1`.
 
 ## Testing/Installing
 
@@ -16,7 +22,7 @@ Do bear in mind that this is still very early in development, so plenty of issue
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/ace13/foreman_hyperv.
+Bug reports and pull requests are welcome on GitHub at https://github.com/ananace/foreman_hyperv.
 
 ## License
 

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

@@ -0,0 +1,78 @@
+$(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',
+    '#host_compute_attributes_memory_minimum',
+    '#compute_attribute_vm_attrs_memory_maximum',
+    '#compute_attribute_vm_attrs_memory_minimum',
+  ];
+
+  if (item.checked) {
+    for (var i = 0; i < toIter.length; ++i) {
+      $(toIter[i]).removeAttr('disabled');
+    }
+  } else {
+    for (var i = 0; i < toIter.length; ++i) {
+      $(toIter[i]).attr('disabled', true);
+    }
+  }
+}
+
+function hypervHostChange(item) {
+  console.log('Hyper-V host changed to ' + $(item).val());
+
+  $('table.hyperv-host-info').hide();
+  $('table.hyperv-host-info[data-host="'+$(item).val()+'"]').show();
+
+  // TODO: Reload available switches
+}
+
+function hypervVLANModeChange(item) {
+  var parent = [...document.querySelectorAll('fieldset.compute_attributes')].filter(el => el.contains(item))[0];
+  if (parent == undefined) {
+    parent = [...document.querySelectorAll('div.fields')].filter(el => el.contains(item))[0];
+  }
+
+  $(parent.querySelectorAll('[data-hyperv-vlan-mode]')).hide();
+  $(parent.querySelectorAll('[data-hyperv-vlan-mode] input')).attr('disabled', true);
+  $(parent.querySelectorAll('[data-hyperv-vlan-mode] select')).attr('disabled', true);
+
+  var id = '[data-hyperv-vlan-mode="' + $(item).val().toLowerCase() + '"]';
+  $(parent.querySelectorAll(id)).show();
+  $(parent.querySelectorAll(id + ' input')).removeAttr('disabled');
+  $(parent.querySelectorAll(id + ' select')).removeAttr('disabled');
+}
+
+function hypervVLANPrivateModeChange(item) {
+  var parent = [...document.querySelectorAll('fieldset.compute_attributes')].filter(el => el.contains(item))[0];
+  if (parent == undefined) {
+    parent = [...document.querySelectorAll('div.fields')].filter(el => el.contains(item))[0];
+  }
+
+  $(parent.querySelectorAll('[data-hyperv-vlan-private-mode]')).hide();
+  $(parent.querySelectorAll('[data-hyperv-vlan-private-mode] input')).attr('disabled', true);
+
+  if ($(item).val() == 'Promiscuous') {
+    var id = '[data-hyperv-vlan-private-mode="plural"]';
+  } else {
+    var id = '[data-hyperv-vlan-private-mode="singular"]';
+  }
+  $(parent.querySelectorAll(id)).show();
+  $(parent.querySelectorAll(id + ' input')).removeAttr('disabled');
+}

data/app/helpers/foreman_hyperv/compute_resources_vms_helper.rb

@@ -0,0 +1,19 @@
+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}" ]
+      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
+  end
+end

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

@@ -0,0 +1,6 @@
+module FogExtensions
+  module Hyperv
+    module Compute
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module FogExtensions
+  module Hyperv
+    module HardDrive
+      extend ActiveSupport::Concern
+      include ActionView::Helpers::NumberHelper
+
+      def size_bytes=(new_size)
+        raise ArgumentError, "Can't modify a physical disk" if disk
+
+        self.vhd ||= Fog::Hyperv::Compute::Vhd.new unless persisted?
+        vhd.size = new_size
+      end
+
+      def basename
+        vhd&.basename
+      end
+
+      def basename=(new_basename)
+        raise ArgumentError, "Can't modify a physical disk" if disk
+
+        self.vhd ||= Fog::Hyperv::Compute::Vhd.new unless persisted?
+        vhd.basename = new_basename
+      end
+
+      def compute_attributes
+        attributes
+          .slice(:id)
+          .merge(
+            {
+              basename:,
+              size_bytes:
+            }.compact
+          )
+      end
+    end
+  end
+end

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

@@ -1,28 +1,131 @@
+# frozen_string_literal: true
+
 module FogExtensions
   module Hyperv
     module NetworkAdapter
       extend ActiveSupport::Concern
-      include ActionView::Helpers::NumberHelper
-
-      def to_s
-        name
-      end
 
       def mac
-        m = mac_address
-        "#{m[0, 2]}:#{m[2, 2]}:#{m[4, 2]}:#{m[6, 2]}:#{m[8, 2]}:#{m[10, 2]}"
+        return unless mac_address
+        return if mac_address.to_i(16) == 0
+
+        # Downcase and split every 2 chars, join with :
+        mac_address.downcase.scan(%r{.{2}}).join(':')
       end
 
       def mac=(m)
-        self.mac_address = m.remove ':'
+        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)
+      end
+
+      # VLAN settings
+
+      def vlan_operation_mode
+        vlan_setting.operation_mode
+      end
+      def vlan_operation_mode=(mode)
+        vlan_setting.operation_mode = mode
       end
 
-      def network
-        switch_name
+      def vlan_private_mode
+        return nil if vlan_setting.private_vlan_mode == :Unknown
+
+        vlan_setting.private_vlan_mode
+      end
+      def vlan_private_mode=(mode)
+        vlan_setting.private_vlan_mode = mode
       end
 
-      def network=(net)
-        self.switch_name = net
+      def access_vlan_id
+        return nil if vlan_setting.access_vlan_id.zero?
+
+        vlan_setting.access_vlan_id
+      end
+      def access_vlan_id=(id)
+        vlan_setting.access_vlan_id = id
+      end
+
+      def native_vlan_id
+        return nil if vlan_setting.native_vlan_id.zero?
+
+        vlan_setting.native_vlan_id
+      end
+      def native_vlan_id=(id)
+        vlan_setting.native_vlan_id = id
+      end
+
+      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?
+
+        vlan_setting.primary_vlan_id
+      end
+      def primary_vlan_id=(id)
+        vlan_setting.primary_vlan_id = id
+      end
+
+      def secondary_vlan_id
+        return nil if vlan_setting.secondary_vlan_id.zero?
+
+        vlan_setting.secondary_vlan_id
+      end
+      def secondary_vlan_id=(id)
+        vlan_setting.secondary_vlan_id = id
+      end
+
+      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)
+      end
+
+      def compute_attributes
+        attributes
+          .slice(
+            :id,
+            :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
+          )
+      end
+
+      private
+
+      def parse_vlan_list(list)
+        ret = []
+        list.split(',').map do |num|
+          if num.include? '-'
+            rstart, rend = num.split('-')
+            ret += (rstart.to_i..rend.to_i).to_a
+          else
+            ret << num.to_i
+          end
+        end
+        ret.sort.uniq
       end
     end
   end

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

@@ -4,8 +4,6 @@ module FogExtensions
       extend ActiveSupport::Concern
       include ActionView::Helpers::NumberHelper
 
-      attr_accessor :start
-
       def to_s
         name
       end
@@ -14,12 +12,8 @@ module FogExtensions
         name.gsub(/[^0-9A-Za-z.\-]/, '_')
       end
 
-      def mac(m = mac_addresses.first)
-        "#{m[0, 2]}:#{m[2, 2]}:#{m[4, 2]}:#{m[6, 2]}:#{m[8, 2]}:#{m[10, 2]}".downcase
-      end
-
-      def clean_mac_addresses
-        network_adapters.map { |n| mac(n.mac_address) }
+      def mac
+        network_adapters.first.mac
       end
 
       def interfaces
@@ -27,18 +21,54 @@ module FogExtensions
       end
 
       def volumes
-        vhds
-      end
-
-      def persisted?
-        identity.present?
+        hard_drives
       end
 
       def interfaces_attributes=(_attributes); end
 
       def volumes_attributes=(_attributes); end
 
+      # Override fog configuration with explicit cluster_name handling
+      def cluster
+        @cluster
+      end
+
+      def cluster_name
+        cluster&.name
+      end
+
+      def cluster_name=(name)
+        @cluster = service.clusters.get(name)
+      end
+      #
+
+      def vlan
+        nic = network_adapters.first
+
+        nic.access_vlan_id || nic.native_vlan_id || nic.primary_vlan_id
+      end
+
+      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
+          nic.vlan_operation_mode = :Access if nic.vlan_operation_mode == :Untagged
+          case nic.vlan_operation_mode
+          when :Access
+            nic.access_vlan_id = vlan
+          when :Trunk
+            nic.native_vlan_id = vlan
+          when :Private
+            nic.primary_vlan_id = vlan
+          end
+        else
+          nic.vlan_operation_mode = :Untagged
+        end
+      end
+
       def secure_boot_enabled=(enabled)
+        return if generation != :UEFI
+
         @secure_boot = enabled
         return unless persisted?
 
@@ -46,37 +76,66 @@ module FogExtensions
       end
 
       def secure_boot_enabled
-        return false if generation == 1
+        return false if generation != :UEFI
         return @secure_boot unless persisted?
 
         firmware.secure_boot == :On
       end
 
-      def reset
-        restart(force: true)
-      end
-
-      def stop
-        requires :name, :computer_name
-        service.stop_vm options.merge(
-          name: name,
-          computer_name: computer_name,
-          force: true
-        )
-      end
-
       def vm_description
         format _('%{cpus} CPUs and %{ram} memory'),
                cpus: processor_count,
                ram: number_to_human_size(memory_startup)
       end
 
+      def compute_attributes
+        attributes.merge(
+          interfaces_attributes: vm.network_adapters.each_with_index.to_h { |nic, idx| [idx, nic.compute_attributes] },
+          volumes_attributes: vm.hard_drives.each_with_index.to_h { |hdd, idx| [idx, hdd.compute_attributes] }
+        )
+      end
+
       def select_nic(fog_nics, nic)
         nic_attrs = nic.compute_attributes
-        logger.debug "select_nic(#{fog_nics}, #{nic}[#{nic_attrs}])"
-        match =   fog_nics.detect { |fn| fn.id == nic_attrs['id'] } # Check the id
-        match ||= fog_nics.detect { |fn| fn.name == nic_attrs['name'] } # Check the name
-        match ||= fog_nics.detect { |fn| fn.switch_name == nic_attrs['network'] } # Fall back to the switch
+
+        # Match for exact data
+        match   = fog_nics.detect { |fn| fn.id == nic_attrs['id'].presence }
+        match ||= fog_nics.detect { |fn| fn.mac == nic.mac }
+        # match ||= fog_nics.detect { |fn| fn.name == nic_attrs['name'].presence }
+
+        if !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'
+            potential.select! { |fn| fn.access_vlan_id.to_s == nic_attrs['access_vlan_id'] }
+          elsif nic_attrs['vlan_operation_mode'] == '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'
+            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?
+            end
+          end
+
+          match = potential.first
+        end
+        return unless match
+
+        # Store Hyper-V ID in compute attributes
+        nic.compute_attributes['identity'] = match.id
+
         match
       end
     end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ForemanHyperv
+  module HostManagedExtensions
+    extend ActiveSupport::Concern
+
+    def update(attributes = {})
+      hyperv_add_attributes(attributes) if provider == 'Hyper-V' && attributes.key?('compute_attributes')
+
+      super
+    end
+
+    def setComputeUpdate
+      ret = super
+      return ret unless provider == 'Hyper-V'
+
+      begin
+        hyperv_sync_interfaces
+      rescue => e
+        failure _("Failed to update a compute %{compute_resource} instance %{name}: %{e}") %
+                { compute_resource:, name:, e: }, e
+      end
+      true
+    end
+
+    private
+
+    # Reconcile the mapping between Hyper-V and Foreman interfaces
+    def hyperv_sync_interfaces
+      unmapped_ifaces = interfaces.select { |iface| iface.physical? && !iface.compute_attributes['identity'].present? }
+      return true if unmapped_ifaces.empty?
+
+      logger.info "Mapping #{unmapped_ifaces.count} unknown interfaces for #{name}"
+
+      self.vm = compute_object
+      fog_nics = vm.interfaces.dup
+      interfaces.each { |iface| fog_nics.delete_if { |vmiface| vmiface.id == iface.compute_attributes['identity'] } }
+
+      unmapped_ifaces.each do |nic|
+        logger.debug "Matching #{nic.inspect} against #{fog_nics}"
+        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") %
+            [nic.identifier, nic.ip, nic.name, nic.type].find(&:present?)
+        end
+
+        logger.debug "Orchestration::Compute: nic #{nic.inspect} assigned to #{selected_nic.inspect}"
+        nic.mac ||= selected_nic.mac
+        nic.save
+        fog_nics.delete selected_nic
+      end
+    end
+
+    # Inject interface attributes into the compute values, to allow modifying Hyper-V configuration on hosts
+    def hyperv_add_attributes(attributes)
+      compute = attributes['compute_attributes'] ||= {}
+      compute['interfaces_attributes'] ||= {}
+
+      attributes['interfaces_attributes'].each do |idx, interface|
+        compute['interfaces_attributes'][idx] = interface
+      end
+    end
+  end
+end