foreman_hyperv 0.0.4 → 0.1.1

data/README.md

@@ -10,6 +10,8 @@ Uses the in-development `fog-hyperv` gem found [here](https://github.com/ananace
 
 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
 
 Follow the Foreman manual for [advanced installation from gems](https://theforeman.org/plugins/#2.3AdvancedInstallationfromGems) for `fog-hyperv` and `foreman_hyperv`.

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,23 @@
+# 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})" if sw.switch_type}"]
+      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,8 @@
+# frozen_string_literal: true
+
+module FogExtensions
+  module Hyperv
+    module Compute
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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: basename,
+              size_bytes: size_bytes
+            }.compact
+          )
+      end
+    end
+  end
+end

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

@@ -1,36 +1,135 @@
+# 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).zero?
+
+        # Downcase and split every 2 chars, join with :
+        mac_address.downcase.scan(/.{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?
+        mac_address.to_i(16)
+        0
+      end
+
+      # VLAN settings
+
+      def vlan_operation_mode
+        vlan_setting.operation_mode
       end
 
-      def network
-        switch_name
+      def vlan_operation_mode=(mode)
+        vlan_setting.operation_mode = mode
+      end
+
+      def vlan_private_mode
+        return nil if vlan_setting.private_vlan_mode == :Unknown
+
+        vlan_setting.private_vlan_mode
       end
 
-      def network=(net)
-        self.switch_name = net
+      def vlan_private_mode=(mode)
+        vlan_setting.private_vlan_mode = mode
       end
 
-      def type
-        is_legacy
+      def access_vlan_id
+        return nil if vlan_setting.access_vlan_id.zero?
+
+        vlan_setting.access_vlan_id
+      end
+
+      delegate :access_vlan_id=, to: :vlan_setting
+
+      def native_vlan_id
+        return nil if vlan_setting.native_vlan_id.zero?
+
+        vlan_setting.native_vlan_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 type=(type)
-        self.is_legacy = type
+      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
+
+      delegate :primary_vlan_id=, to: :vlan_setting
+
+      def secondary_vlan_id
+        return nil if vlan_setting.secondary_vlan_id.zero?
+
+        vlan_setting.secondary_vlan_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)
+      end
+
+      def compute_attributes
+        attributes
+          .slice(
+            :id,
+            :switch_id
+          )
+          .merge(
+            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
+
+      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

@@ -1,25 +1,21 @@
+# frozen_string_literal: true
+
 module FogExtensions
   module Hyperv
     module Server
       extend ActiveSupport::Concern
       include ActionView::Helpers::NumberHelper
 
-      attr_accessor :start
-
       def to_s
         name
       end
 
       def folder_name
-        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
+        name.gsub(/[^0-9A-Za-z.-]/, '_')
       end
 
-      def clean_mac_addresses
-        network_adapters.map { |n| mac(n.mac_address) }
+      def mac
+        network_adapters.first.mac
       end
 
       def interfaces
@@ -27,24 +23,53 @@ module FogExtensions
       end
 
       def volumes
-        vhds
+        hard_drives
       end
 
-      def persisted?
-        identity.present?
+      def interfaces_attributes=(_attributes); end
+
+      def volumes_attributes=(_attributes); end
+
+      # Override fog configuration with explicit cluster_name handling
+      def cluster
+        @cluster
       end
 
-      def interfaces_attributes=(_attributes)
-        true
+      def cluster_name
+        cluster&.name
       end
 
-      def volumes_attributes=(_attributes); end
+      def cluster_name=(name)
+        @cluster = service.clusters.get(name)
+      end
+
+      def vlan
+        nic = network_adapters.first
 
-      def vlan; end
+        nic.access_vlan_id || nic.native_vlan_id || nic.primary_vlan_id
+      end
 
-      def vlan=(_vlan); 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.positive?
+          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?
 
@@ -52,41 +77,72 @@ 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 state
-        attributes[:state].to_s.upcase
-      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 }
+
+        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'] }
+          case nic_attrs['vlan_operation_mode']
+          when 'Access'
+            potential.select! { |fn| fn.access_vlan_id.to_s == nic_attrs['access_vlan_id'] }
+          when 'Trunk'
+            potential.select! { |fn| fn.native_vlan_id.to_s == nic_attrs['native_vlan_id'] }
+            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'
+              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
+
+          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,65 @@
+# 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 StandardError => e
+        failure _("Failed to update a compute %{compute_resource} instance %{name}: %{e}") %
+                { compute_resource: compute_resource, name: name, e: 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