foreman_fog_proxmox 0.21.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b24eea105cd6eae85d7c04d8f3e17e76ea4354722bb8eef4c85242fc62196b6b
-  data.tar.gz: 7217844296cc0beb945a356b2ad05ae435795e59cee74871be09a8351c91576b
+  metadata.gz: a437699869ae38137e94761791e2a01d741e9dd36f924c286bfaa9afc139f9e7
+  data.tar.gz: 5698645c6f2a3a3278959989e5214357263f3ba7c0091830d1f41205033582ea
 SHA512:
-  metadata.gz: 202536e1272df6cb0440bd8c538f6e15a2753cda3aba3a0e726e49264fdeb82a90491c8b225b9001c795a2a52379d574770a79480b6b79e211f8d36b1d122bc8
-  data.tar.gz: a43bf12d2ccd3b0b80fcc939487e7ac5ec2309b0b775620583f99da7aba7ccec8291b28258db55d8a639ff233d289e55a9d0b4aa4ac39983359f61a236603063
+  metadata.gz: 1d29712272ab785a33e4bdc70f345b0da96ff22d020820bbefc27c14302c24c1207d198d6ec742562a4d30a84083b1e081b43bb6a855c432e5a67ce60ca8a5b9
+  data.tar.gz: 9f3c39bbeca9d7364f4ee92cef02cc6fc7c398692cbc12f03a7c581324a9c21ca65ef1af33fcc892b1da02e3378f3f7c214fad2fb79bded7cfb028d55f5e5827

data/app/assets/javascripts/foreman_fog_proxmox/proxmox_vm_container.js

@@ -21,4 +21,39 @@ function storageOstemplateSelected(item) {
   var node_id = $('#host_compute_attributes_node_id').val();
   if (node_id == undefined) node_id = $("#compute_attribute_vm_attrs_node_id").val();
   updateOptions('ostemplates', 'compute_attributes_ostemplate', 'file', undefined, undefined, 'volid', node_id, storage);
-}
+}
+
+function setDisabled($el, disabled) {
+  if (!$el || !$el.length) return;
+  $el.prop('disabled', disabled);
+  $el.toggleClass('disabled', disabled);
+}
+
+function syncDhcpIP(item, suffix) {
+  var $dhcp = $(item);
+  var checked = $dhcp.is(':checked');
+  var $fieldset = $dhcp.closest('fieldset');
+  var $cidr = $fieldset.find('input.proxmox-cidr-' + suffix).first();
+  var $gw = $fieldset.find('input.proxmox-gw-' + suffix).first();
+
+  setDisabled($cidr, checked);
+  setDisabled($gw, checked);
+}
+
+function dhcpIPSelected(item, suffix) {
+  syncDhcpIP(item, suffix);
+}
+
+function syncAllProxmoxDhcpFields() {
+  $('input.proxmox-dhcp-ipv4').each(function() {
+    syncDhcpIP(this, 'ipv4');
+  });
+
+  $('input.proxmox-dhcp-ipv6').each(function() {
+    syncDhcpIP(this, 'ipv6');
+  });
+}
+
+$(document).on('turbolinks:load', function() {
+  syncAllProxmoxDhcpFields();
+});

data/app/controllers/foreman_fog_proxmox/compute_resources_controller.rb

@@ -101,6 +101,7 @@ module ForemanFogProxmox
         pools: extract_pools(cr),
         storages: extract_storages(cr),
         bridges: extract_bridges(cr),
+        images: extract_images(cr),
       }
     end
 
@@ -141,6 +142,39 @@ module ForemanFogProxmox
       end
     end
 
+    def extract_images(compute_resource)
+      images = compute_resource.images
+      images = images.order(:name) if images.respond_to?(:order)
+
+      Array(images).map do |image|
+        data = image.respond_to?(:as_json) ? image.as_json : image
+        uuid = image_value(image, data, :uuid, :id)
+
+        {
+          uuid: uuid,
+          name: image_value(image, data, :name),
+          disks: image_disks(compute_resource, uuid),
+        }
+      end
+    end
+
+    def image_disks(compute_resource, uuid)
+      return nil unless uuid && compute_resource.respond_to?(:find_vm_by_uuid)
+
+      compute_resource.find_vm_by_uuid(uuid)&.disks
+    rescue ActiveRecord::RecordNotFound, StandardError
+      nil
+    end
+
+    def image_value(image, data, *keys)
+      keys.each do |key|
+        value = [image.try(key), data.try(:[], key), data.try(:[], key.to_s)].find(&:present?)
+        return value if value.present?
+      end
+
+      nil
+    end
+
     def load_compute_resource(compute_resource_id)
       ComputeResource.find(compute_resource_id)
     end

data/app/helpers/proxmox_form_helper.rb

@@ -18,6 +18,47 @@
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
 module ProxmoxFormHelper
+  include ProxmoxVMInterfacesHelper
+
+  def proxmox_vm_type_and_node_id(host, form_object, params)
+    compute_attributes = form_object.compute_attributes || {}
+    host_compute_attrs = host.respond_to?(:compute_attributes) ? (host.compute_attributes || {}) : {}
+    host_vm_type = extract_attr(host_compute_attrs, :type)
+
+    profile_attrs = profile_compute_attributes(host)
+    profile_vm_type = extract_attr(profile_attrs, :type)
+
+    vm_type = [
+      params.dig(:host, :compute_attributes, :type).presence,
+      params.dig(:compute_attribute, :vm_attrs, :type).presence,
+      host_vm_type,
+      profile_vm_type,
+      'qemu',
+    ].find(&:present?)
+
+    compute_attributes = proxmox_default_interface_compute_attributes(host, vm_type) unless proxmox_valid_interface_compute_attributes?(compute_attributes, vm_type)
+
+    compute_node_id = extract_attr(compute_attributes, :node_id)
+    object_node_id = form_object.respond_to?(:node_id) ? form_object.node_id : nil
+    host_node_id = extract_attr(host_compute_attrs, :node_id)
+    profile_node_id = extract_attr(profile_attrs, :node_id)
+
+    node_id = [
+      params.dig(:host, :compute_attributes, :node_id).presence,
+      params.dig(:compute_attribute, :vm_attrs, :node_id).presence,
+      object_node_id,
+      compute_node_id,
+      host_node_id,
+      profile_node_id,
+    ].find(&:present?)
+
+    {
+      compute_attributes: compute_attributes,
+      vm_type: vm_type,
+      node_id: node_id,
+    }
+  end
+
   def password_proxmox_f(f, attr, options = {})
     unset_button = options.delete(:unset)
     value = f.object[attr] if options.delete(:keep_value)
@@ -79,4 +120,32 @@ module ProxmoxFormHelper
     hide += '$("[data-association=' + type + '_volumes]").show();' unless ['hard_disk', 'mp'].include?(type)
     f.hidden_field(opts[:method] || :_destroy) + link_to_function(name, 'remove_child_node(this);' + hide, opts)
   end
+
+  private
+
+  def proxmox_default_interface_compute_attributes(host, vm_type)
+    host.compute_resource.interface_typed_defaults(vm_type).fetch(:compute_attributes).deep_dup
+  end
+
+  def proxmox_valid_interface_compute_attributes?(compute_attributes, vm_type)
+    return false unless compute_attributes.respond_to?(:keys)
+
+    valid_keys = interface_compute_attributes_typed_keys(vm_type)
+    compute_attributes.keys.map(&:to_s).all? { |key| valid_keys.include?(key) }
+  end
+
+  def extract_attr(attrs, key)
+    return unless attrs.respond_to?(:[])
+
+    attrs[key.to_s] || attrs[key.to_sym]
+  end
+
+  def profile_compute_attributes(host)
+    inherited_profile_id = host.respond_to?(:hostgroup) ? host.hostgroup&.inherited_compute_profile_id : nil
+    profile_id = host.compute_profile_id || inherited_profile_id
+
+    return {} if profile_id.blank?
+
+    host.compute_resource.compute_profile_attributes_for(profile_id) || {}
+  end
 end

data/app/helpers/proxmox_vm_attrs_helper.rb

@@ -49,7 +49,7 @@ module ProxmoxVMAttrsHelper
 
   def cpu_flags_attrs(param_scope, config)
     flag_attrs = ActiveSupport::HashWithIndifferentAccess.new
-    Fog::Proxmox::CpuHelper.flags.each do |key, _val|
+    Fog::Proxmox::CpuHelper.flags.each_key do |key|
       flag_attrs.merge!({ key => { :name => "#{param_scope}[config_attributes][#{key}]", :value => config.public_send(key) } })
     end
     flag_attrs
@@ -73,7 +73,7 @@ module ProxmoxVMAttrsHelper
         keys = ['id', 'volid', 'storage', 'size', 'storage_type']
         type = 'rootfs'
       elsif vol.hard_disk?
-        keys = ['id', 'volid', 'storage_type', 'storage', 'controller', 'device', 'cache', 'size', '_delete']
+        keys = ['id', 'volid', 'storage_type', 'storage', 'controller', 'device', 'cache', 'size', '_delete', 'backup']
         type = 'hard_disk'
       elsif  vol.cdrom?
         keys = ['id', 'storage_type', 'cdrom', 'storage', 'volid']
@@ -82,7 +82,7 @@ module ProxmoxVMAttrsHelper
         keys = ['id', 'volid', 'storage_type', 'storage', 'controller', 'device']
         type = 'cloud_init'
       elsif vol.mount_point?
-        keys = ['id', 'volid', 'storage_type', 'storage', 'device', 'mp', 'size']
+        keys = ['id', 'volid', 'storage_type', 'storage', 'device', 'mp', 'size', 'backup']
         type = 'mount_point'
       end
       vol_attrs << { :name => type, :value => vol_keys(param_scope, keys, vol, id) }
@@ -107,6 +107,14 @@ module ProxmoxVMAttrsHelper
         camel_key = key.to_s.include?('_') ? snake_to_camel(key.to_s).to_sym : key
         attrs[camel_key] = { :name => "#{param_scope}[interfaces_attributes][#{id}][#{key}]", :value => value }
       end
+      if interface.respond_to?(:dhcp)
+        attrs[:dhcp] = { :name => "#{param_scope}[interfaces_attributes][#{id}][dhcp]",
+                         :value => interface.dhcp ? '1' : '0' }
+      end
+      if interface.respond_to?(:dhcp6)
+        attrs[:dhcp6] = { :name => "#{param_scope}[interfaces_attributes][#{id}][dhcp6]",
+                          :value => interface.dhcp6 ? '1' : '0' }
+      end
       networks_attrs << { :name => 'interface', :value => attrs }
     end
     networks_attrs

data/app/helpers/proxmox_vm_interfaces_helper.rb

@@ -60,10 +60,27 @@ module ProxmoxVMInterfacesHelper
   end
 
   def compute_dhcps(interface_attributes_h)
-    interface_attributes_h[:dhcp] = (interface_attributes_h[:ip] == 'dhcp') ? '1' : '0'
-    interface_attributes_h[:ip] = '' if interface_attributes_h[:dhcp] == '1'
-    interface_attributes_h[:dhcp6] = (interface_attributes_h[:ip6] == 'dhcp') ? '1' : '0'
-    interface_attributes_h[:ip6] = '' if interface_attributes_h[:dhcp6] == '1'
+    return if interface_attributes_h.nil?
+
+    sync_dhcp_for_ip(interface_attributes_h, 'ip', 'dhcp')
+    sync_dhcp_for_ip(interface_attributes_h, 'ip6', 'dhcp6')
+  end
+
+  def sync_dhcp_for_ip(attrs, ip_key, dhcp_key)
+    dhcp_value = attrs[dhcp_key] || attrs[dhcp_key.to_sym]
+    if dhcp_value.nil?
+      ip_value = attrs[ip_key] || attrs[ip_key.to_sym]
+      attrs[dhcp_key.to_sym] = (ip_value == 'dhcp') ? '1' : '0'
+      attrs[ip_key.to_sym] = '' if attrs[dhcp_key.to_sym] == '1'
+      return
+    end
+
+    ip_value = attrs[ip_key] || attrs[ip_key.to_sym]
+    if dhcp_value.to_s == '1'
+      attrs[ip_key.to_sym] = 'dhcp' if ip_value.to_s.empty?
+    elsif ip_value.to_s == 'dhcp'
+      attrs[ip_key.to_sym] = ''
+    end
   end
 
   def add_or_delete_typed_interface(interface_attributes, interfaces_to_delete, interfaces_to_add, type)

data/app/helpers/proxmox_vm_volumes_helper.rb

@@ -51,13 +51,35 @@ module ProxmoxVMVolumesHelper
   def parse_hard_disk_volume(args)
     logger.debug(format(_('parse_hard_disk_volume(): args=%<args>s'), args: args))
     disk = {}
+    rootfs_volume = rootfs_volume?(args)
+    set_disk_attributes(disk, args)
+    if rootfs_volume
+      args.delete('backup')
+    elsif args['backup'].nil?
+      args['backup'] = '1'
+    end
+    if args.key?('options')
+      options = args['options']
+      if rootfs_volume && options.respond_to?(:delete)
+        options = options.dup
+        options.delete('backup')
+      end
+      disk[:options] = options
+    else
+      add_disk_options(disk, args)
+    end
+    disk.key?(:storage) ? disk : {}
+  end
+
+  def rootfs_volume?(args)
+    args['storage_type'] == 'rootfs' || args['id'] == 'rootfs'
+  end
+
+  def set_disk_attributes(disk, args)
     disk[:id] = args['id'] if args.key?('id')
     disk[:volid] = args['volid'] if args.key?('volid') && !args['volid'].empty?
     disk[:storage] = args['storage'].to_s if args.key?('storage') && !args['storage'].empty?
     disk[:size] = args['size'].to_i if args.key?('size') && !args['size'].empty?
-    add_disk_options(disk, args) unless args.key?('options')
-    disk[:options] = args['options'] if args.key?('options')
-    disk.key?(:storage) ? disk : {}
   end
 
   def volume_type?(args, type)
@@ -71,6 +93,7 @@ module ProxmoxVMVolumesHelper
   end
 
   def parse_typed_volume(args, type)
+    return if Foreman::Cast.to_bool(args['_delete'])
     logger.debug("parse_typed_volume(#{type}): args=#{args}")
     disk = parse_hard_disk_volume(args) if volume_type?(args,
       'hard_disk') || volume_type?(args, 'mp') || volume_type?(args, 'rootfs')
@@ -94,6 +117,9 @@ module ProxmoxVMVolumesHelper
 
   def remove_volume_keys(args)
     if args.key?('volumes_attributes')
+      args['volumes_attributes'].delete_if do |_index, volume_attributes|
+        Foreman::Cast.to_bool(volume_attributes['_delete'])
+      end
       args['volumes_attributes'].each_value do |volume_attributes|
         ForemanFogProxmox::HashCollection.remove_keys(volume_attributes, ['_delete'])
       end

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

@@ -21,12 +21,18 @@ module FogExtensions
   module Proxmox
     module Server
       extend ActiveSupport::Concern
-      attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password, :start_after_create
+      attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password, :start_after_create, :compute_resource_id
 
       def unique_cluster_identity(compute_resource)
         compute_resource.id.to_s + '_' + identity.to_s
       end
 
+      def foreman_uuid
+        return identity.to_s if compute_resource_id.nil?
+
+        compute_resource_id.to_s + '_' + identity.to_s
+      end
+
       def start
         action('start')
       end

data/app/models/concerns/host_ext/proxmox/interfaces.rb

@@ -49,12 +49,11 @@ module HostExt
 
       def add_interface_to_compute_attributes(index, interface_attributes, compute_attributes)
         compute_attributes[index] = {}
-        compute_attributes[index].store('id', interface_attributes['identifier'])
         compute_attributes[index].store('_delete', interface_attributes['_destroy'])
         compute_attributes[index].store('macaddr', interface_attributes['mac'])
         compute_attributes[index].store('ip', cidr_ip(interface_attributes))
         compute_attributes[index].store('ip6', cidr_ip(interface_attributes, 6))
-        compute_attributes[index].merge!(interface_attributes['compute_attributes'].reject { |k, _v| k == 'id' })
+        compute_attributes[index].merge(interface_attributes['compute_attributes'])
       end
     end
   end

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -45,6 +45,7 @@ module ForemanFogProxmox
 
     def provided_attributes
       super.merge(
+        :uuid => :foreman_uuid,
         :mac => :mac
       )
     end
@@ -62,10 +63,11 @@ module ForemanFogProxmox
     end
 
     def associated_host(vm)
-      associate_by('mac', vm.mac)
+      associate_by('mac', vm&.mac)
     end
 
     def associate_by(name, attributes)
+      return nil if attributes.blank?
       Host.authorized(:view_hosts,
         Host).joins(:primary_interface).where(:nics => { :primary => true }).where("nics.#{name}".downcase => attributes.downcase).readonly(false).first
     end

data/app/models/foreman_fog_proxmox/proxmox_compute_attributes.rb

@@ -19,8 +19,13 @@
 
 module ForemanFogProxmox
   module ProxmoxComputeAttributes
+    FOREMAN_INTERFACE_ATTRIBUTES = [:id, :mac, :ip, :ip6].freeze
+    PROXMOX_MAC_ATTRIBUTES = [:macaddr, :hwaddr].freeze
+    PROXMOX_INTERFACE_METADATA = [:identifier, :compute_attributes].freeze
+
     def host_compute_attrs(host)
-      ostype = host.compute_attributes['config_attributes']['ostype']
+      config = host.compute_attributes['config_attributes'] || {}
+      ostype = config['ostype']
       type = host.compute_attributes['type']
       case type
       when 'lxc'
@@ -41,19 +46,35 @@ module ForemanFogProxmox
     end
 
     def interface_compute_attributes(interface_attributes)
-      vm_attrs = ForemanFogProxmox::HashCollection.new_hash_reject_keys(interface_attributes, [:identifier, :macaddr, :hwaddr])
-      vm_attrs[:dhcp] = (interface_attributes[:ip] == 'dhcp') ? '1' : '0'
-      vm_attrs[:dhcp6] = (interface_attributes[:ip6] == 'dhcp') ? '1' : '0'
+      attrs = interface_attributes.with_indifferent_access
+      provider_attrs = attrs[:compute_attributes].present? ? attrs[:compute_attributes].with_indifferent_access : ActiveSupport::HashWithIndifferentAccess.new
+
+      vm_attrs = FOREMAN_INTERFACE_ATTRIBUTES.index_with do |key|
+        attrs[key] || provider_attrs.delete(key)
+      end.compact
+      vm_attrs[:mac] ||= attrs[:macaddr] || attrs[:hwaddr] || provider_attrs.delete(:macaddr) || provider_attrs.delete(:hwaddr)
+
+      attrs.except(*FOREMAN_INTERFACE_ATTRIBUTES, *PROXMOX_MAC_ATTRIBUTES, *PROXMOX_INTERFACE_METADATA).each do |key, value|
+        provider_attrs[key] = value
+      end
+
+      provider_attrs[:dhcp] = (vm_attrs[:ip] == 'dhcp') ? '1' : '0'
+      provider_attrs[:dhcp6] = (vm_attrs[:ip6] == 'dhcp') ? '1' : '0'
+      vm_attrs[:compute_attributes] = provider_attrs
       vm_attrs
     end
 
+    def volume_compute_attributes(volume_attributes)
+      volume_attributes.merge(_delete: '0')
+    end
+
     def vm_compute_attributes(vm)
       vm_attrs = {}
       vm_attrs = vm_attrs.merge(vmid: vm.identity, node_id: vm.node_id, type: vm.type)
       if vm.respond_to?(:config)
         if vm.config.respond_to?(:disks)
           vm_attrs[:volumes_attributes] = Hash[vm.config.disks.each_with_index.map do |disk, idx|
-                                                 [idx.to_s, disk.attributes]
+                                                 [idx.to_s, volume_compute_attributes(disk.attributes)]
                                                end ]
         end
         if vm.config.respond_to?(:interfaces)

data/app/models/foreman_fog_proxmox/proxmox_operating_systems.rb

@@ -20,16 +20,20 @@
 module ForemanFogProxmox
   module ProxmoxOperatingSystems
     def compute_os_types(host)
-      os_linux_types_mapping(host).empty? ? os_windows_types_mapping(host) : os_linux_types_mapping(host)
+      [os_linux_types_mapping(host), os_windows_types_mapping(host), os_other_types_mapping(host)].find(&:any?) || []
     end
 
     def available_operating_systems
-      operating_systems = ['other', 'solaris']
+      operating_systems = available_other_operating_systems
       operating_systems += available_linux_operating_systems
       operating_systems += available_windows_operating_systems
       operating_systems
     end
 
+    def available_other_operating_systems
+      ['other', 'solaris']
+    end
+
     def available_linux_operating_systems
       ['l24', 'l26', 'debian', 'ubuntu', 'centos', 'fedora', 'opensuse', 'archlinux', 'gentoo', 'alpine']
     end
@@ -50,5 +54,12 @@ module ForemanFogProxmox
     def os_windows_types_mapping(host)
       ['Windows'].include?(host.operatingsystem.type) ? available_windows_operating_systems : []
     end
+
+    def os_other_types_mapping(host)
+      {
+        'Freebsd' => ['other'],
+        'Solaris' => ['solaris'],
+      }.fetch(host.operatingsystem.type, [])
+    end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox_vm_new.rb

@@ -31,18 +31,18 @@ module ForemanFogProxmox
     end
 
     def cloudinit_defaults
-      { storage_type: 'cloud_init', id: 'ide0', storage: storages.first.identity.to_s, media: 'cdrom' }
+      { storage_type: 'cloud_init', id: 'ide0', storage: storages.first&.identity.to_s, media: 'cdrom' }
     end
 
     def hard_disk_typed_defaults(vm_type)
       options = {}
-      volume_attributes_h = { storage: storages.first.identity.to_s, size: '8' }
+      volume_attributes_h = { storage: storages.first&.identity.to_s, size: '8' }
       case vm_type
       when 'qemu'
         controller = 'virtio'
         device = 0
         id = "#{controller}#{device}"
-        options = { cache: 'none' }
+        options = { cache: 'none', backup: '1' }
         volume_attributes_h = volume_attributes_h.merge(controller: controller, device: device)
       when 'lxc'
         id = 'rootfs'
@@ -69,18 +69,18 @@ module ForemanFogProxmox
     end
 
     def interface_defaults(id = 'net0')
-      { id: id, compute_attributes: { model: 'virtio', name: 'eth0', bridge: bridges.first.identity.to_s } }
+      { id: id, compute_attributes: { model: 'virtio', name: 'eth0', bridge: bridges.first&.identity.to_s } }
     end
 
     def interface_typed_defaults(type)
       interface_attributes_h = { id: 'net0', compute_attributes: {} }
       if type == 'qemu'
         interface_attributes_h[:compute_attributes] =
-          { model: 'virtio', bridge: bridges.first.identity.to_s }
+          { model: 'virtio', bridge: bridges.first&.identity.to_s }
       end
       if type == 'lxc'
         interface_attributes_h[:compute_attributes] =
-          { name: 'eth0', bridge: bridges.first.identity.to_s, dhcp: 1, dhcp6: 1 }
+          { name: 'eth0', bridge: bridges.first&.identity.to_s, dhcp: 1, dhcp6: 1 }
       end
       interface_attributes_h
     end

data/app/models/foreman_fog_proxmox/proxmox_vm_queries.rb

@@ -32,7 +32,7 @@ module ForemanFogProxmox
       node ||= default_node
       storages = node.storages.list_by_content_type type
       logger.debug("storages(): node_id #{node_id} type #{type}")
-      storages.sort_by(&:storage)
+      storages.reject { |s| s.enabled.to_i.zero? || s.active.to_i.zero? }.sort_by(&:storage)
     end
 
     def bridges(node_id = default_node_id)
@@ -46,9 +46,10 @@ module ForemanFogProxmox
     def vms(opts = {})
       vms = []
       nodes.each { |node| vms += node.servers.all + node.containers.all }
+      vms.each { |vm| attach_compute_resource_id(vm) }
       if opts.key?(:eager_loading) && opts[:eager_loading]
         vms_eager = []
-        vms.each { |vm| vms_eager << vm.collection.get(vm.identity) }
+        vms.each { |vm| vms_eager << attach_compute_resource_id(vm.collection.get(vm.identity)) }
         vms = vms_eager
       end
       ForemanFogProxmox::Vms.new(vms)
@@ -71,12 +72,21 @@ module ForemanFogProxmox
     def find_vm_in_servers_by_vmid(servers, vmid)
       vm = servers.get(vmid) unless ForemanFogProxmox::Value.empty?(vmid)
       pool_owner(vm) if vm
-      vm
+      attach_compute_resource_id(vm)
     rescue Fog::Errors::NotFound
       nil
     rescue StandardError => e
       Foreman::Logging.exception(format(_('Failed retrieving proxmox server vm by vmid=%<vmid>s'), vmid: vmid), e)
       raise(ActiveRecord::RecordNotFound, e)
     end
+
+    private
+
+    def attach_compute_resource_id(virtual_machine)
+      return virtual_machine if virtual_machine.nil?
+
+      virtual_machine.compute_resource_id = id if virtual_machine.respond_to?(:compute_resource_id=)
+      virtual_machine
+    end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox_volumes.rb

@@ -35,8 +35,12 @@ module ForemanFogProxmox
 
     def volume_options(vm, id, volume_attributes)
       options = {}
+      backup = volume_attributes['backup'].to_s
+      cache = volume_attributes['cache'].to_s
+      backup = '1' if backup.empty? && (!vm.container? || id != 'rootfs')
       options.store(:mp, volume_attributes['mp']) if vm.container? && id != 'rootfs'
-      options.store(:cache, volume_attributes['cache']) unless vm.container? || volume_attributes['cache'].empty?
+      options.store(:cache, cache) unless vm.container? || cache.empty?
+      options.store(:backup, backup) unless backup.empty? || (vm.container? && id == 'rootfs')
       options
     end
 
@@ -87,14 +91,12 @@ module ForemanFogProxmox
           raise ::Foreman::Exception,
             format(_('Unable to shrink %<id>s size. Proxmox allows only increasing size.'), id: id)
         end
-        diff_size = volume_attributes['size'].to_i - disk.size.to_i if volume_attributes['size'] && disk.size
-        raise ::Foreman::Exception, format(_('Unable to shrink %<id>s size. Proxmox allows only increasing size.'), id: id) unless diff_size >= 0
 
-        new_storage = volume_attributes['storage']
+        new_storage = volume_attributes['storage'].presence || disk.storage
 
         if diff_size > 0
           extend_volume(vm, id, diff_size)
-        elsif disk.storage != new_storage
+        elsif new_storage.present? && disk.storage != new_storage
           move_volume(id, vm, new_storage)
         else
           update_options(disk, vm, volume_attributes)
@@ -102,6 +104,13 @@ module ForemanFogProxmox
       end
     end
 
+    def normalize_existing_volume_attributes(disk, volume_attributes)
+      return volume_attributes unless disk.hard_disk?
+      return volume_attributes if volume_attributes['storage'].present?
+
+      volume_attributes.merge('storage' => disk.storage)
+    end
+
     def volume_exists?(vm, volume_attributes)
       disk = vm.config.disks.get(volume_attributes['id'])
       return false unless disk
@@ -154,7 +163,8 @@ module ForemanFogProxmox
           delete_volume(vm, id, volume_attributes)
         else
           disk = vm.config.disks.get(id)
-          update_volume(vm, disk, volume_attributes) if update_volume_required?(disk.attributes, volume_attributes)
+          normalized_volume_attributes = normalize_existing_volume_attributes(disk, volume_attributes)
+          update_volume(vm, disk, normalized_volume_attributes) if update_volume_required?(disk.attributes, normalized_volume_attributes)
         end
       else
         add_volume(vm, id, volume_attributes)

data/app/views/compute_resources_vms/form/proxmox/_add_vm_type_to_nic_provider_specific_form.html.erb

@@ -15,13 +15,12 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>. %>
 <% if @host.compute_resource.class == ForemanFogProxmox::Proxmox %>
-<% compute_attributes = f.object.compute_attributes %>
-<% logger.debug("_add_vm_type_to_nic_provider_specific_form.html compute_attributes=#{compute_attributes}") %>
-<% node_id = f.object.respond_to?('node_id') ? f.object.node_id : nil %>
+<% vm_type_and_node_id = proxmox_vm_type_and_node_id(@host, f.object, params) %>
+<% compute_attributes = vm_type_and_node_id[:compute_attributes] %>
+<% vm_type = vm_type_and_node_id[:vm_type] %>
+<% node_id = vm_type_and_node_id[:node_id] %>
 
-<%= f.fields_for 'compute_attributes', OpenStruct.new(f.object.compute_attributes) do |f| %>
-    <% vm_type = compute_attributes.respond_to?('type') ? compute_attributes.type : 'qemu' %>
-    <% logger.debug("_add_vm_type_to_nic_provider_specific_form.html vm_type=#{vm_type}") %>
+<%= f.fields_for 'compute_attributes', OpenStruct.new(compute_attributes) do |f| %>
     <%= render provider_partial(@host.compute_resource, 'network'), :f => f, :vm_type => vm_type, :node_id => node_id, :disabled => f.object.persisted?, :compute_resource => @host.compute_resource, :new_host => new_vm, :new_vm => new_vm %>
 <% end %>
 <% else %>