foreman_hyperv 0.0.4 → 0.1.0

data/app/models/foreman_hyperv/hyperv.rb

@@ -1,119 +1,222 @@
 module ForemanHyperv
   class Hyperv < ::ComputeResource
-    validates :url, :user, :password, presence: true
+    include ComputeResourceCaching
 
-    def capabilities
-      [:build]
-    end
+    validates :url, :user, :password, presence: true
+    after_validation :validate_connectivity unless Rails.env.test?
 
     def self.provider_friendly_name
       'Hyper-V'
     end
 
+    def to_label
+      "#{name} (#{provider_friendly_name})"
+    end
+
+    def self.available?
+      Fog::Compute.providers.include?(:hyperv)
+    end
+
     def self.model_name
       ComputeResource.model_name
     end
 
+    def supports_update?
+      true
+    end
+
+    def editable_network_interfaces?
+      true
+    end
+
+    def capabilities
+      [:build]
+    end
+
     def test_connection(options = {})
-      super
+      validate_connectivity(options)
+    end
+
+    def validate_connectivity(options = {})
+      return unless connection_properties_valid?
+      return false if errors.any?
+
       client.valid?
     rescue Fog::Hyperv::Errors::ServiceError, ArgumentError, WinRM::WinRMAuthorizationError => e
-      errors[:base] << e.message
+      errors.add(:base, e.message)
+    end
+
+    def connection_valid?
+      return false if url.blank? || user.blank? || password.blank?
+
+      client&.valid?
+    rescue StandardError
+      false
+    end
+
+    def connection_properties_valid?
+      errors[:url].empty? && errors[:user].empty? && errors[:password].empty?
+    end
+
+    def caching_enabled
+      true
     end
 
     def provided_attributes
       super.merge(mac: :mac)
     end
 
-    # TODO
-    def max_cpu_count
-      hypervisor.logical_processor_count
+    def editable_network_interfaces?
+      true
     end
 
-    def max_memory
-      hypervisor.memory_capacity
+    # TODO
+    def max_cpu_count(host = nil)
+      (host || hypervisor).logical_processor_count
     end
 
-    def associated_host(vm)
-      associate_by('mac', vm.clean_mac_addresses)
+    def max_memory(host = nil)
+      (host || hypervisor).memory_capacity
     end
 
-    def new_vm(attr = {})
-      vm = super
-      interfaces = nested_attributes_for :interfaces, attr[:interfaces_attributes]
-      interfaces.map { |i| vm.interfaces << new_interface(i) }
-      volumes = nested_attributes_for :volumes, attr[:volumes_attributes]
-      volumes.map { |v| vm.volumes << new_volume(v) }
-      vm
+    def available_hypervisors
+      client.hosts.load(
+        cache.cache(:available_hypervisor) do
+          client.hosts.all.map(&:attributes)
+        end
+      )
     end
+    alias hosts available_hypervisors
+
+    def cluster(name)
+      return nil unless name
 
-    def stop_vm(uuid)
-      find_vm_by_uuid(uuid).stop force: true
+      client.clusters.get name
     end
 
-    def create_vm(args = {})
-      args = vm_instance_defaults.merge(args.to_hash.deep_symbolize_keys)
-      client.logger.debug "Creating a VM with arguments; #{args}"
+    def clusters
+      client.clusters.load(
+        cache.cache(:clusters) do
+          _clusters.map(&:attributes)
+        end
+      )
+    end
 
-      args[:computer_name] = args[:computer_name].presence || '.'
+    def hypervisor
+      client.hosts.new(
+        cache.cache(:hypervisor) do
+          client.hosts.first.attributes
+        end
+      )
+    end
 
-      pre_create = {
-        boot_device: 'NetworkAdapter',
-        computer_name: args[:computer_name],
-        generation: args[:generation].to_i,
-        memory_startup: args[:memory_startup].presence.to_i,
-        name: args[:name],
-        no_vhd: true
-      }
+    delegate :servers, to: :client
 
-      vm = client.servers.create pre_create
+    def switches(host)
+      host ||= hosts.first
+      client.switches.load(
+        cache.cache(:"#{host.name}-switches") do
+          host.switches.all.map(&:attributes)
+        end
+      )
+    end
 
-      post_save = {
-        dynamic_memory_enabled: Foreman::Cast.to_bool(args[:dynamic_memory_enabled]),
-        memory_minimum: args[:memory_minimum].presence.to_i,
-        memory_maximum: args[:memory_maximum].presence.to_i,
-        notes: args[:notes].presence,
-        processor_count: args[:processor_count].to_i
-      }
-      post_save.each do |k, v|
-        vm.send("#{k}=".to_sym, v)
+    def new_vm(attr = {})
+      attr.delete :id
+      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|
+          attr.select { |_, v| v.present? }.each do |k, v|
+            nic.send(:"#{k}=", v)
+          end
+        end
       end
+      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|
+          attr.select { |_, v| v.present? }.each do |k, v|
+            hdd.send(:"#{k}=", v)
+          end
+        end
+      end
+      vm.id = nil
+      vm
+    end
 
-      vm.save if vm.dirty?
+    def create_vm(attr = {})
+      attr = vm_instance_defaults.merge(attr.to_hash.deep_symbolize_keys)
+      attr.delete :computer_name if attr[:computer_name].blank?
+      attr.delete :start
+
+      validate_vm(attr, new: true)
+      validate_interfaces(attr)
+      validate_volumes(attr)
+
+      vm = client.servers.new(
+        name: attr[:name],
+        computer_name: attr[:computer_name],
+        generation: attr[:generation],
+        dynamic_memory_enabled: Foreman::Cast.to_bool(attr[:dynamic_memory_enabled]),
+        memory_startup: attr[:memory_startup].to_i,
+        memory_minimum: attr[:memory_minimum].to_i,
+        memory_maximum: attr[:memory_maximum].to_i,
+        processor_count: attr[:processor_count].to_i,
+        notes: attr[:notes]
+      )
+      # TODO: Allow configuring boot device?
+      vm.create boot_device: :NetworkAdapter
 
-      if vm.generation == 2 && args[:secure_boot_enabled].present?
+      if vm.generation == :UEFI && attr[:secure_boot_enabled].present?
         f = vm.firmware
-        f.secure_boot = Foreman::Cast.to_bool(args[:secure_boot_enabled]) ? :On : :Off
+        f.secure_boot = Foreman::Cast.to_bool(attr[:secure_boot_enabled]) ? :On : :Off
         f.save if f.dirty?
       end
 
-      create_interfaces(vm, args[:interfaces_attributes])
-      create_volumes(vm, args[:volumes_attributes])
-
-      vm.set_vlan(args[:vlan].to_i) if args[:vlan].presence && vm.respond_to?(:set_vlan)
+      create_interfaces(vm, attr)
+      create_volumes(vm, attr)
 
+      vm.start if attr[:start] == '1'
       vm
     rescue StandardError => e
-      vm.stop turn_off: true
+      if vm
+        vm.stop
+        vm.hard_drives.each { |hdd| hdd.destroy(underlying: true) }
+        vm.destroy
+      end
 
       raise e
     end
 
-    def save_vm(uuid, attr)
+    def save_vm(uuid, web_attr)
+      attr = web_attr.deep_symbolize_keys
+
+      validate_vm(attr)
+      validate_interfaces(attr)
+      validate_volumes(attr)
+
+      attr.delete :start
+
       vm = find_vm_by_uuid(uuid)
-      client.logger.debug "Saving a VM with arguments; #{attr}"
-      attr.each do |k, v|
-        vm.send("#{k}=".to_sym, v) if vm.respond_to?("#{k}=".to_sym)
+      logger.debug "Updating VM #{vm} with arguments; #{attr}"
+
+      vm.processor_count = attr[:processor_count].to_i
+      vm.notes = attr[:notes].presence
+      vm.dynamic_memory_enabled = Foreman::Cast.to_bool(attr[:dynamic_memory_enabled])
+      if vm.dynamic_memory_enabled
+        vm.memory_minimum = attr[:memory_minimum].to_i
+        vm.memory_maximum = attr[:memory_maximum].to_i
       end
-
-      if vm.generation == 2 && attr[:secure_boot_enabled].present?
+      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?
       end
 
-      update_interfaces(vm, attr[:interfaces_attributes])
-      update_volumes(vm, attr[:volumes_attributes])
+      update_interfaces(vm, attr)
+      update_volumes(vm, attr)
 
       vm.save if vm.dirty?
       vm
@@ -121,10 +224,8 @@ module ForemanHyperv
 
     def destroy_vm(uuid)
       vm = find_vm_by_uuid(uuid)
-      vm.stop force: true if vm.ready?
-      vm.hard_drives.each do |hd|
-        hd.vhd.destroy if hd.path
-      end
+      vm.stop turn_off: true
+      vm.hard_drives.each { |hdd| hdd.destroy(underlying: true) }
       # TODO: Remove the empty VM folder
       vm.destroy
     rescue ActiveRecord::RecordNotFound, Fog::Errors::NotFound
@@ -132,51 +233,103 @@ module ForemanHyperv
       true
     end
 
-    def new_interface(attr = {})
-      client.network_adapters.new attr
-    end
+    def update_required?(old_attrs, new_attrs)
+      new_attrs.deep_symbolize_keys[:volumes_attributes]&.each do |_, hdd|
+        if hdd[:id].present? && hdd[:_delete] == '1'
+          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"
+          return true
+        end
+      end
+      new_attrs.deep_symbolize_keys[:interfaces_attributes]&.each do |_, iface|
+        if iface[:id].present? && iface[:_destroy] == '1'
+          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"
+          return true
+        end
+      end
 
-    def new_volume(attr = {})
-      client.vhds.new attr
-    end
+      deep_update_required = proc do |old, new|
+        old.merge(new) do |k, old_v, new_v|
+          if k == :allowed_vlan_ids || k == :secondary_vlan_ids
+            tmp = Fog::Hyperv::Compute::NetworkAdapter.new
 
-    def new_cdrom(attr = {})
-      client.dvd_drives.new attr
+            old_v = Fog::Hyperv::Compute::NetworkAdapterVlan.render_vlan_list(tmp.send(:parse_vlan_list, old_v.to_s))
+            new_v = Fog::Hyperv::Compute::NetworkAdapterVlan.render_vlan_list(tmp.send(:parse_vlan_list, new_v.to_s))
+          end
+
+          if old_v.is_a?(Hash) && new_v.is_a?(Hash)
+            deep_update_required.call(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})"
+            return true
+          end
+          new_v
+        end
+      end
+      deep_update_required.call(old_attrs.deep_symbolize_keys, new_attrs.deep_symbolize_keys)
+
+      false
     end
 
-    def editable_network_interfaces?
-      true
+    # def console(uuid)
+    #   vm = find_vm_by_uuid(uuid)
+    #
+    #   {
+    #     type: 'rdp',
+    #     host: vm.computer.fully_qualified_domain_name,
+    #   }
+    # end
+
+    def new_interface(attr = {})
+      Fog::Hyperv::Compute::NetworkAdapter.new attr
     end
 
-    def switches
-      client.switches.all # _quick_query: true
+    def new_volume(attr = {})
+      basename = attr.delete(:basename) { 'Disk' }
+      size = attr.delete(:size)
+
+      vhd = client.vhds.new({ basename:, size: }.compact)
+      Fog::Hyperv::Compute::HardDrive.new vhd:, **attr
     end
 
-    def supports_update?
-      true
+    def new_cdrom(attr = {})
+      Fog::Hyperv::Compute::DvdDrive.new attr
     end
 
-    def available_hypervisors
-      client.hosts
+    def vm_instance_defaults
+      super.merge(
+        generation:      2,
+        memory_startup:  1024.megabytes,
+        processor_count: 1,
+        interfaces:      [new_interface]
+      )
     end
-    alias hosts available_hypervisors
 
-    def clusters
-      if client.respond_to? :supports_clusters?
-        return [] unless client.supports_clusters?
+    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|
+        [index.to_s, volume.compute_attributes]
       end
-
-      client.clusters
-    rescue
-      []
+      vm_attrs
     end
 
-    def hypervisor
-      client.hosts.first
+    def set_vm_interfaces_attributes(vm, vm_attrs)
+      interfaces = vm.interfaces || []
+      vm_attrs[:interfaces_attributes] = interfaces.each_with_index.to_h do |interface, index|
+        interface_attrs = {
+          mac: interface.mac,
+          compute_attributes: interface.compute_attributes
+        }
+        [index.to_s, interface_attrs]
+      end
+      vm_attrs
     end
 
-    delegate :servers, to: :client
-
     protected
 
     def client
@@ -188,85 +341,154 @@ module ForemanHyperv
       )
     end
 
-    def vm_instance_defaults
-      super.merge(
-        generation:      1,
-        memory_startup:  512.megabytes,
-        processor_count: 1,
-        boot_device:     'NetworkAdapter'
-      )
+    private
+
+    def _clusters
+      if client.respond_to? :supports_clusters?
+        return [] unless client.supports_clusters?
+      end
+
+      client.clusters.all
+    rescue
+      []
     end
 
-    def create_interfaces(vm, attrs)
-      vm.network_adapters.each(&:destroy)
+    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
 
-      interfaces = nested_attributes_for :interfaces, attrs
-      client.logger.debug "Building interfaces with: #{interfaces}"
+      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
+    end
+
+    def validate_interfaces(attr)
+      interfaces = nested_attributes_for :interfaces, attr[:interfaces_attributes]
+      interfaces.reject! { |iface| iface[:_destroy] == '1' }
+      # logger.debug "Validate NIC #{interfaces.inspect}"
       interfaces.each do |iface|
-        nic = vm.network_adapters.new name: iface[:name], switch_name: iface[:network]
-        if iface[:mac]
-          nic.mac = iface[:mac]
-          nic.dynamic_mac_address_enabled = false
+        compute = iface[:compute_attributes] || iface
+        case compute[:vlan_operation_mode].to_s
+        when 'Untagged'
+        when 'Access'
+          raise Foreman::Exception, 'Interface is missing access VLAN' unless compute[:access_vlan_id].to_i > 0
+        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?
+        when 'Private'
+          raise Foreman::Exception, 'Interface is missing primary VLAN' unless compute[:primary_vlan_id].to_i > 0
+          case compute[:vlan_private_mode].to_s
+          when 'Promiscuous'
+            raise Foreman::Exception, 'Interface is missing secondary VLANs' unless compute[:secondary_vlan_ids].present?
+          else
+            raise Foreman::Exception, 'Interface is missing secondary VLAN' unless compute[:secondary_vlan_id].to_i > 0
+          end
+        else
+          raise Foreman::Exception, 'Interface has unknown VLAN mode'
         end
-        if vm.generation == 1 && iface[:type].present?
-          nic.is_legacy = Foreman::Cast.to_bool(iface[:type])
+      end
+    end
+
+    def create_interfaces(vm, attr)
+      interfaces = nested_attributes_for :interfaces, attr[:interfaces_attributes]
+      logger.debug "Creating interfaces with: #{interfaces}"
+
+      first_provisioned = false
+      interfaces.each do |iface|
+        # The VM is pre-created with one NIC regardless of given creation options, so configure that one first
+        nic = vm.network_adapters.first unless first_provisioned
+        first_provisioned = true
+
+        nic ||= vm.network_adapters.new
+        iface.except(:identity, :ip, :ip6).each do |k, v|
+          nic.send(:"#{k}=", v.presence)
         end
+        # nic.is_legacy = Foreman::Cast.to_bool(iface[:is_legacy]) if vm.generation == :BIOS && iface[:is_legacy].present?
+        # logger.debug "Creating interface with #{iface.inspect} - #{nic.inspect}\n#{nic.vlan_setting.inspect}"
         nic.save
       end
 
-      # Populate the MAC addresses
+      return unless vm.network_adapters.all(_return_fields: %i[dynamic_mac_address_enabled]).any?(&:dynamic_mac_address_enabled)
+
+      # Populate all non-populated MAC addresses
       vm.start
       vm.stop turn_off: true
 
-      vm.network_adapters.reload
-      vm.network_adapters.each do |nic|
+      vm.network_adapters.reload.each do |nic|
         nic.dynamic_mac_address_enabled = false
         nic.save if nic.dirty?
       end
     end
 
-    def create_volumes(vm, attrs)
-      volumes = nested_attributes_for :volumes, attrs
-      client.logger.debug "Building volumes with: #{volumes}"
-      volumes.each do |vol|
-        vhd = vm.vhds.create path: vm.folder_name + '\\' + vol[:path], size: vol[:size]
-        vm.hard_drives.create path: vhd.path
-      end
-      vm.hard_drives.reload
-    end
+    def update_interfaces(vm, attr)
+      interfaces = nested_attributes_for :interfaces, attr[:interfaces_attributes]
+      logger.debug "Updating interfaces with: #{interfaces}"
 
-    def update_interfaces(vm, attrs)
-      interfaces = nested_attributes_for :interfaces, attrs
-      client.logger.debug "Updating interfaces with: #{interfaces}"
       interfaces.each do |interface|
-        if interface[:id].blank? && interface[:_delete] != '1'
-          nic = vm.network_adapters.create interface
-          nic.dynamic_mac_address_enabled = false if nic.mac
-          nic.save
-        elsif interface[:id].present?
-          nic = vm.network_adapters.find { |n| n.id == interface[:id] }
-          if interface[:_delete] == '1'
-            nic.delete
+        compute = interface[:compute_attributes]
+        if compute[:identity].present?
+          nic = vm.network_adapters.get compute[:identity]
+          if interface[:_destroy] == '1'
+            nic.destroy
           else
-            interface.each do |k, v|
-              nic.send("#{k}=".to_sym, v)
+            compute.each do |k, v|
+              nic.send(:"#{k}=", v.presence)
             end
-            nic.save if nic.dirty?
+            nic.mac ||= interface[:mac].presence
+            nic.save
           end
+        elsif interface[:_destroy] != '1'
+          nic = vm.network_adapters.new
+          compute.each do |k, v|
+            nic.send(:"#{k}=", v.presence)
+          end
+          nic.mac ||= interface[:mac].presence
+          nic.save
         end
       end
     end
 
-    def update_volumes(vm, attrs)
-      volumes = nested_attributes_for :volumes, attrs
-      client.logger.debug "Updating volumes with: #{volumes}"
+    def validate_volumes(attr)
+      volumes = nested_attributes_for :volumes, attr[:volumes_attributes]
+      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 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
+      end
+      raise Foreman::Exception, 'Volume names need to be unique' if volumes.group_by { |vol| vol[:basename].downcase }.any? { |k, v| v.count > 1 }
+    end
+
+    def create_volumes(vm, attr)
+      volumes = nested_attributes_for :volumes, attr[:volumes_attributes]
+      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:
+      end
+    end
+
+    def update_volumes(vm, attr)
+      volumes = nested_attributes_for :volumes, attr[:volumes_attributes]
+      logger.debug "Updating volumes with: #{volumes}"
       volumes.each do |volume|
-        if volume[:_delete] == '1' && volume[:id].present?
-          hd = vm.hard_drives.find { |h| h.id == volume[:id] }
-          hd.vhd.destroy
-          hd.destroy
+        if volume[:id].present?
+          hd = vm.hard_drives.get volume[:id]
+          if volume[:_delete] == '1'
+            hd.destroy(underlying: true)
+          else
+            vhd = hd.vhd
+            vhd.size = volume[:size_bytes].to_i
+            vhd.save if vhd.dirty?
+          end
+        elsif volume[:_delete] != '1'
+          vhd = vm.vhds.create basename: volume[:basename], size: volume[:size_bytes].to_i
+          vm.hard_drives.create path: vhd.path
         end
-        vm.hard_drives.create(path: volume[:path], size: volume[:size]) if volume[:id].blank? && volume[:_delete] != '1'
       end
     end
   end

data/app/views/compute_resources/form/_hyperv.html.erb

@@ -2,6 +2,10 @@
 <%= text_f f, :user, label: _('User') %>
 <%= password_f f, :password, label: _('Password') %>
 
-<%= link_to_function _("Test Connection"), "testConnection(this)", :class => "btn + #{@compute_resource.test_connection.is_a?(FalseClass) ? "btn-default" : "btn-success"}", :'data-url' => test_connection_compute_resources_path %>
+<%# Currently not working due to marshaling errors %>
+<%#= checkbox_f f, :caching_enabled, :label => _("Enable Caching"),
+                  :help_inline => _("Cache slow calls to Hyper-V to speed up page rendering") %>
 
-<%= hidden_spinner('', :id => 'test_connection_indicator') %>
+<div class="col-md-offset-2">
+  <%= test_connection_button_f(f, f.object.connection_valid?) %>
+</div>