foreman_fog_proxmox 0.12.2 → 0.13.3

data/app/models/foreman_fog_proxmox/proxmox_compute_attributes.rb

@@ -20,18 +20,18 @@
 module ForemanFogProxmox
   module ProxmoxComputeAttributes
     def host_compute_attrs(host)
-      super.tap do |_attrs|
-        ostype = host.compute_attributes['config_attributes']['ostype']
-        type = host.compute_attributes['type']
-        case type
-        when 'lxc'
-          host.compute_attributes['config_attributes'].store('hostname', host.name)
-        when 'qemu'
-          unless compute_os_types(host).include?(ostype)
-            raise ::Foreman::Exception, format(_('Operating system family %<type>s is not consistent with %<ostype>s'), type: host.operatingsystem.type, ostype: ostype)
-          end
+      ostype = host.compute_attributes['config_attributes']['ostype']
+      type = host.compute_attributes['type']
+      case type
+      when 'lxc'
+        host.compute_attributes['config_attributes'].store('hostname', host.name)
+      when 'qemu'
+        host.compute_attributes['config_attributes'].store('name', host.name)
+        unless compute_os_types(host).include?(ostype)
+          raise ::Foreman::Exception, format(_('Operating system family %<type>s is not consistent with %<ostype>s'), type: host.operatingsystem.type, ostype: ostype)
         end
       end
+      super
     end
 
     def not_config_key?(vm, key)
@@ -39,20 +39,16 @@ module ForemanFogProxmox
     end
 
     def interface_compute_attributes(interface_attributes)
-      vm_attrs = {}
-      vm_attrs.store(:mac, interface_attributes[:macaddr])
-      vm_attrs.store(:id, interface_attributes[:id])
-      vm_attrs.store(:identifier, interface_attributes[:id])
-      vm_attrs.store(:ip, interface_attributes[:ip])
-      vm_attrs.store(:ip6, interface_attributes[:ip6])
-      vm_attrs[:compute_attributes] = interface_attributes.reject { |k, _v| [:macaddr, :id].include?(k) }
+      vm_attrs = ForemanFogProxmox::HashCollection.new_hash_reject_keys(interface_attributes, [:identifier, :mac])
+      vm_attrs[:dhcp] = interface_attributes[:ip] == 'dhcp' ? '1' : '0'
+      vm_attrs[:dhcp6] = interface_attributes[:ip6] == 'dhcp' ? '1' : '0'
       vm_attrs
     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)
-        vm_attrs = vm_attrs.merge(vmid: vm.identity, node_id: vm.node_id, type: vm.type)
         vm_attrs[:volumes_attributes] = Hash[vm.config.disks.each_with_index.map { |disk, idx| [idx.to_s, disk.attributes] }] if vm.config.respond_to?(:disks)
         if vm.config.respond_to?(:interfaces)
           vm_attrs[:interfaces_attributes] = Hash[vm.config.interfaces.each_with_index.map { |interface, idx| [idx.to_s, interface_compute_attributes(interface.attributes)] }]

data/app/models/foreman_fog_proxmox/proxmox_connection.rb

@@ -28,23 +28,28 @@ module ForemanFogProxmox
       opts
     end
 
-    def fog_credentials
-      credentials = { pve_url: url,
-                      pve_username: user,
-                      pve_password: password,
-                      connection_options: connection_options }
-      ticket = Fog::Proxmox.credentials[:ticket]
-      credentials.store(:pve_ticket, ticket) if renew
-      credentials
+    def access_ticket?
+      auth_method == 'access_ticket'
+    end
+
+    def user_token?
+      auth_method == 'user_token'
     end
 
     def credentials_valid?
-      errors[:url].empty? && errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_id].empty?
+      errors[:url].empty? && errors[:auth_method].empty?
+      errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_id].empty? if access_ticket?
+      errors[:user].empty? && errors[:user].include?('@') && errors[:token_id].empty? && errors[:token].empty? && errors[:node_id].empty? if user_token?
+    end
+
+    def current_user_token_expire
+      identity_client ? identity_client.expires : 0
     end
 
     def test_connection(options = {})
       super
       credentials_valid?
+      identity_client
       version_suitable?
     rescue StandardError => e
       errors[:base] << e.message

data/app/models/foreman_fog_proxmox/proxmox_images.rb

@@ -27,6 +27,7 @@ module ForemanFogProxmox
       node = client.nodes.get node_id
       node ||= default_node
       storage = node.storages.get storage_id if storage_id
+      logger.debug(format(_('images_by_storage(): node_id %<node_id>s storage_id %<storage_id>s type %<type>s'), node_id: node_id, storage_id: storage_id, type: type))
       storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
@@ -40,7 +41,7 @@ module ForemanFogProxmox
         storage = storages(node.node).first
         volumes += storage.volumes.list_by_content_type('images')
       end
-      volumes.select(&:templated?)
+      volumes.select(&:template?)
     end
 
     def template(vmid)

data/app/models/foreman_fog_proxmox/proxmox_interfaces.rb

@@ -30,8 +30,14 @@ module ForemanFogProxmox
       raise ::Foreman::Exception, _(format('Invalid identifier interface[%<index>s]. Must be net[n] with n integer >= 0', index: index)) unless Fog::Proxmox::NicHelper.nic?(nic.identifier)
     end
 
+    def vm_type(host)
+      type = host.compute_attributes['type']
+      type ||= host.compute_attributes[:config_attributes].key?(:arch) ? 'lxc' : 'qemu'
+      type
+    end
+
     def container?(host)
-      host.compute_attributes['type'] == 'lxc'
+      vm_type(host) == 'lxc'
     end
 
     def container_nic_name_valid?(nic)
@@ -44,32 +50,46 @@ module ForemanFogProxmox
     end
 
     def cidr_prefix(nic_compute_attributes, v6 = false)
-      attr_name = 'cidrv'
-      attr_name += v6 ? '6' : '4'
-      attr_name += '_prefix'
-      nic_compute_attributes[attr_name] if nic_compute_attributes[attr_name].presence
+      attr_name = "cidr#{v6_s(v6)}"
+      nic_compute_attributes[attr_name] if nic_compute_attributes.key?(attr_name)
     end
 
-    def set_ip(host, nic, nic_compute_attributes, v6 = false)
-      return 'dhcp' if dhcp?(nic_compute_attributes, v6)
-
-      ip = v6 ? nic.ip6 : nic.ip
-      return ip unless container?(host) || cidr_prefix(nic_compute_attributes, v6)
+    def cidr_prefix_method(v6)
+      "cidr#{v6_s(v6)}_prefix?".to_sym
+    end
 
-      valid = v6 ? Fog::Proxmox::IpHelper.cidr6_prefix?(cidr_prefix(nic_compute_attributes, v6)) : Fog::Proxmox::IpHelper.cidr_prefix?(cidr_prefix(nic_compute_attributes, v6))
-      ipv = v6 ? 'IPv6' : 'IPv4'
+    def check_cidr(nic_compute_attributes, v6, ip)
+      valid = Fog::Proxmox::IpHelper.send(cidr_prefix_method(v6), cidr_prefix(nic_compute_attributes, v6))
+      ipv = "IPv#{v6 ? '6' : '4'}"
       max = v6 ? 128 : 32
-      unless valid
-        raise ::Foreman::Exception, _(format('Invalid Interface Proxmox CIDR %<ip>s. If %<ip>s is not empty, Proxmox CIDR prefix must be an integer between 0 and %<max>i.', ip: ipv, max: max))
-      end
+      checked = valid || ForemanFogProxmox::Value.empty?(ip)
+      message = format('Invalid Interface Proxmox CIDR %<ip>s. If %<ip>s is not empty, Proxmox CIDR prefix must be an integer between 0 and %<max>i.', ip: ipv, max: max)
+      raise ::Foreman::Exception, _(message) unless checked
+    end
 
-      v6 ? Fog::Proxmox::IpHelper.to_cidr6(nic.ip6, cidr_prefix(nic_compute_attributes, v6)) : Fog::Proxmox::IpHelper.to_cidr(nic.ip, cidr_prefix(nic_compute_attributes, v6))
+    def v6_s(v6)
+      v6 ? '6' : ''
     end
 
-    def set_gw(nic_compute_attributes, v6 = false)
-      attr_name = 'gwv'
-      attr_name += v6 ? '6' : '4'
-      nic_compute_attributes[attr_name] if nic_compute_attributes[attr_name].presence
+    def ip_s(v6)
+      "ip#{v6_s(v6)}"
+    end
+
+    def to_cidr_method(v6)
+      "to_cidr#{v6_s(v6)}".to_sym
+    end
+
+    def set_ip(host, nic, nic_compute_attributes, v6 = false)
+      ip = nic.send(ip_s(v6).to_sym)
+      if container?(host)
+        if dhcp?(nic_compute_attributes, v6)
+          ip = 'dhcp'
+        elsif !ForemanFogProxmox::Value.empty?(cidr_prefix(nic_compute_attributes, v6))
+          check_cidr(nic_compute_attributes, v6, ip)
+          ip = Fog::Proxmox::IpHelper.send(to_cidr_method(v6), nic.send(ip_s(v6).to_sym), cidr_prefix(nic_compute_attributes, v6)) if ip
+        end
+      end
+      nic_compute_attributes[ip_s(v6).to_sym] = ip
     end
 
     def to_boolean(value)
@@ -77,9 +97,14 @@ module ForemanFogProxmox
     end
 
     def dhcp?(nic_compute_attributes, v6 = false)
-      attr_name = 'dhcpv'
-      attr_name += v6 ? '6' : '4'
-      to_boolean(nic_compute_attributes[attr_name]) if nic_compute_attributes[attr_name].present?
+      attr_name = "dhcp#{v6_s(v6)}"
+      nic_compute_attributes.key?(attr_name) ? to_boolean(nic_compute_attributes[attr_name]) : false
+    end
+
+    def set_mac(nic_compute_attributes, mac, type)
+      mac_attr_name = { 'qemu' => :macaddr, 'lxc' => :hwaddr }
+      mac_key = mac_attr_name[type] || 'mac'
+      nic_compute_attributes[mac_key] = mac
     end
 
     def host_interfaces_attrs(host)
@@ -87,15 +112,15 @@ module ForemanFogProxmox
         set_nic_identifier(nic, index)
         set_container_interface_name(host, nic, index) if container?(host)
         nic_compute_attributes = nic.compute_attributes.merge(id: nic.identifier)
+        ForemanFogProxmox::HashCollection.remove_empty_values(nic_compute_attributes)
         mac = nic.mac
         mac ||= nic.attributes['mac']
-        nic_compute_attributes.store(:macaddr, mac) if mac.present?
+        set_mac(nic_compute_attributes, mac, vm_type(host)) if mac.present?
         interface_compute_attributes = host.compute_attributes['interfaces_attributes'] ? host.compute_attributes['interfaces_attributes'].select { |_k, v| v['id'] == nic.identifier } : {}
         nic_compute_attributes.store(:_delete, interface_compute_attributes[interface_compute_attributes.keys[0]]['_delete']) unless interface_compute_attributes.empty?
-        nic_compute_attributes.store(:ip, set_ip(host, nic, nic_compute_attributes))
-        nic_compute_attributes.store(:gw, set_gw(nic_compute_attributes))
-        nic_compute_attributes.store(:ip6, set_ip(host, nic, nic_compute_attributes, true))
-        nic_compute_attributes.store(:gw6, set_gw(nic_compute_attributes, true))
+        set_ip(host, nic, nic_compute_attributes)
+        set_ip(host, nic, nic_compute_attributes, true)
+        ForemanFogProxmox::HashCollection.remove_keys(nic_compute_attributes, ['dhcp', 'dhcp6', 'cidr', 'cidr6'])
         hash.merge(index.to_s => nic_compute_attributes)
       end
     end

data/app/models/foreman_fog_proxmox/proxmox_operating_systems.rb

@@ -39,7 +39,7 @@ module ForemanFogProxmox
     end
 
     def os_linux_types_mapping(host)
-      ['Debian', 'Redhat', 'Suse', 'Altlinux', 'Archlinux', 'Coreos', 'Gentoo'].include?(host.operatingsystem.type) ? available_linux_operating_systems : []
+      ['Debian', 'Redhat', 'Suse', 'Altlinux', 'Archlinux', 'Coreos', 'Rancheros', 'Gentoo'].include?(host.operatingsystem.type) ? available_linux_operating_systems : []
     end
 
     def os_windows_types_mapping(host)

data/app/models/foreman_fog_proxmox/proxmox_version.rb

@@ -29,8 +29,13 @@ module ForemanFogProxmox
     end
 
     def version
-      v = identity_client.read_version
-      "#{v['version']}.#{v['release']}"
+      v = identity_client.read_version if identity_client
+      v ? v['version'] : 'Unknown'
+    rescue ::Foreman::Exception => e
+      return 'Unkown' if e.message == 'User token expired'
+    rescue StandardError => e
+      logger.warn(format(_('failed to get identity client version: %<e>s'), e: e))
+      raise e
     end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox_vm_commands.rb

@@ -17,10 +17,13 @@
 # You should have received a copy of the GNU General Public License
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
+require 'foreman_fog_proxmox/hash_collection'
+
 module ForemanFogProxmox
   module ProxmoxVmCommands
     include ProxmoxVolumes
     include ProxmoxPools
+    include ProxmoxVmHelper
 
     def start_on_boot(vm, args)
       startonboot = args[:start_after_create].blank? ? false : Foreman::Cast.to_bool(args[:start_after_create])
@@ -40,20 +43,14 @@ module ForemanFogProxmox
         clone_from_image(image_id, args, vmid)
       else
         convert_sizes(args)
-        remove_deletes(args)
-        case type
-        when 'qemu'
-          vm = node.servers.create(parse_server_vm(args))
-        when 'lxc'
-          hash = parse_container_vm(args)
-          hash = hash.merge(vmid: vmid)
-          vm = node.containers.create(hash.reject { |key, _value| ['ostemplate_storage', 'ostemplate_file'].include? key })
-        end
+        remove_volume_keys(args)
+        logger.warn(format(_('create vm: args=%<args>s'), args: args))
+        vm = node.send(vm_collection(type)).create(parse_typed_vm(args, type))
         start_on_boot(vm, args)
       end
     rescue StandardError => e
       logger.warn(format(_('failed to create vm: %<e>s'), e: e))
-      destroy_vm vm.id if vm
+      destroy_vm client.identity + '_' + vm.id if vm
       raise e
     end
 
@@ -70,24 +67,18 @@ module ForemanFogProxmox
       true
     end
 
-    def update_required?(old_attrs, new_attrs)
-      return true if super(old_attrs, new_attrs)
-
-      new_attrs[:interfaces_attributes]&.each do |key, interface|
-        return true if (interface[:id].blank? || interface[:_delete] == '1') && key != 'new_interfaces' # ignore the template
-      end
-
-      new_attrs[:volumes_attributes]&.each do |key, volume|
-        return true if (volume[:id].blank? || volume[:_delete] == '1') && key != 'new_volumes' # ignore the template
-      end
-
-      false
-    end
-
     def user_data_supported?
       true
     end
 
+    def compute_config_attributes(parsed_attr)
+      excluded_keys = [:vmid, :templated, :ostemplate, :ostemplate_file, :ostemplate_storage, :volumes_attributes, :pool]
+      config_attributes = parsed_attr.reject { |key, _value| excluded_keys.include? key.to_sym }
+      ForemanFogProxmox::HashCollection.remove_empty_values(config_attributes)
+      config_attributes = config_attributes.reject { |key, _value| Fog::Proxmox::DiskHelper.disk?(key) }
+      { config_attributes: config_attributes }
+    end
+
     def save_vm(uuid, new_attributes)
       vm = find_vm_by_uuid(uuid)
       templated = new_attributes['templated']
@@ -98,15 +89,12 @@ module ForemanFogProxmox
         vm.migrate(node_id)
       else
         convert_memory_sizes(new_attributes)
+        parsed_attr = parse_typed_vm(ForemanFogProxmox::HashCollection.new_hash_reject_keys(new_attributes, ['volumes_attributes']).merge(type: vm.type), vm.type)
+        config_attributes = compute_config_attributes(parsed_attr)
         volumes_attributes = new_attributes['volumes_attributes']
+        logger.debug(format(_('save_vm(%<vmid>s) volumes_attributes=%<volumes_attributes>s'), vmid: uuid, volumes_attributes: volumes_attributes))
         volumes_attributes&.each_value { |volume_attributes| save_volume(vm, volume_attributes) }
-        parsed_attr = vm.container? ? parse_container_vm(new_attributes.merge(type: vm.type)) : parse_server_vm(new_attributes.merge(type: vm.type))
-        logger.debug("parsed_attr=#{parsed_attr}")
-        config_attributes = parsed_attr.reject { |key, _value| [:vmid, :templated, :ostemplate, :ostemplate_file, :ostemplate_storage, :volumes_attributes, :pool].include? key.to_sym }
-        config_attributes = config_attributes.reject { |_key, value| ForemanFogProxmox::Value.empty?(value) }
-        cdrom_attributes = parsed_attr.select { |_key, value| Fog::Proxmox::DiskHelper.cdrom?(value.to_s) }
-        config_attributes = config_attributes.reject { |key, _value| Fog::Proxmox::DiskHelper.disk?(key) }
-        vm.update(config_attributes.merge(cdrom_attributes))
+        vm.update(config_attributes[:config_attributes])
         poolid = new_attributes['pool'] if new_attributes.key?('pool')
         update_pool(vm, poolid) if poolid
       end

data/app/models/foreman_fog_proxmox/proxmox_vm_new.rb

@@ -20,76 +20,74 @@
 require 'fog/proxmox'
 require 'fog/proxmox/helpers/nic_helper'
 require 'fog/proxmox/helpers/disk_helper'
+require 'foreman_fog_proxmox/hash_collection'
 
 module ForemanFogProxmox
   module ProxmoxVmNew
     include ProxmoxVmHelper
 
-    def volume_server_defaults(controller = 'scsi', device = 0)
-      id = "#{controller}#{device}"
-      { id: id, storage: storages.first.identity.to_s, size: (8 * GIGA), options: { cache: 'none' } }
+    def cdrom_defaults
+      { storage_type: 'cdrom', id: 'ide2', volid: 'none', media: 'cdrom' }
     end
 
-    def volume_container_defaults(id = 'rootfs')
-      { id: id, storage: storages.first.identity.to_s, size: (8 * GIGA), options: {} }
+    def cloudinit_defaults
+      { storage_type: 'cloud_init', id: 'ide0', storage: storages.first.identity.to_s, media: 'cdrom' }
     end
 
-    def new_volume(attr = {})
-      type = attr['type']
-      type ||= 'qemu'
-      case type
-      when 'lxc'
-        new_volume_server(attr)
+    def hard_disk_typed_defaults(vm_type)
+      options = {}
+      volume_attributes_h = { storage: storages.first.identity.to_s, size: (8 * GIGA) }
+      case vm_type
       when 'qemu'
-        new_volume_container(attr)
+        controller = 'virtio'
+        device = 0
+        id = "#{controller}#{device}"
+        options = { cache: 'none' }
+        volume_attributes_h = volume_attributes_h.merge(controller: controller, device: device)
+      when 'lxc'
+        id = 'rootfs'
+        volume_attributes_h = volume_attributes_h.merge(storage_type: 'rootfs')
       end
+      volume_attributes_h[:id] = id
+      volume_attributes_h[:options] = options
+      volume_attributes_h
     end
 
-    def new_volume_server(attr = {})
-      opts = volume_server_defaults.merge(attr.to_h).deep_symbolize_keys
-      opts[:size] = opts[:size].to_s
+    def new_typed_volume(attr, vm_type, volume_type)
+      volume_defaults = hard_disk_typed_defaults(vm_type) if ['hard_disk', 'rootfs', 'mp'].include?(volume_type)
+      volume_defaults = cdrom_defaults if volume_type == 'cdrom'
+      volume_defaults = cloudinit_defaults if volume_type == 'cloud_init'
+      opts = volume_defaults.merge(attr.to_h).deep_symbolize_keys
+      opts = ForemanFogProxmox::HashCollection.new_hash_transform_values(opts, :to_s)
       Fog::Proxmox::Compute::Disk.new(opts)
     end
 
-    def new_volume_container(attr = {})
-      opts = volume_container_defaults.merge(attr.to_h).deep_symbolize_keys
-      opts[:size] = opts[:size].to_s
-      Fog::Proxmox::Compute::Disk.new(opts)
+    def new_volume(attr = {})
+      type = attr['type']
+      type ||= 'qemu'
+      new_typed_volume(attr, type, 'hard_disk')
     end
 
     def interface_defaults(id = 'net0')
-      { id: id, 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_server_defaults(id = 'net0')
-      { id: id, model: 'virtio', bridge: bridges.first.identity.to_s }
+    def interface_typed_defaults(type)
+      interface_attributes_h = { id: 'net0', compute_attributes: {} }
+      interface_attributes_h[:compute_attributes] = { model: 'virtio', bridge: bridges.first.identity.to_s } if type == 'qemu'
+      interface_attributes_h[:compute_attributes] = { name: 'eth0', bridge: bridges.first.identity.to_s, dhcp: 1, dhcp6: 1 } if type == 'lxc'
+      interface_attributes_h
     end
 
-    def interface_container_defaults(id = 'net0')
-      { id: id, name: 'eth0', bridge: bridges.first.identity.to_s, dhcpv4: 1, dhcpv6: 1 }
+    def new_typed_interface(attr, type)
+      opts = interface_typed_defaults(type).merge(attr.to_h).deep_symbolize_keys
+      Fog::Proxmox::Compute::Interface.new(opts)
     end
 
     def new_interface(attr = {})
       type = attr['type']
       type ||= 'qemu'
-      case type
-      when 'lxc'
-        new_container_interface(attr)
-      when 'qemu'
-        new_server_interface(attr)
-      end
-    end
-
-    def new_server_interface(attr = {})
-      logger.debug('new_server_interface')
-      opts = interface_server_defaults.merge(attr.to_h).deep_symbolize_keys
-      Fog::Proxmox::Compute::Interface.new(opts)
-    end
-
-    def new_container_interface(attr = {})
-      logger.debug('new_container_interface')
-      opts = interface_container_defaults.merge(attr.to_h).deep_symbolize_keys
-      Fog::Proxmox::Compute::Interface.new(opts)
+      new_typed_interface(attr, type)
     end
 
     def default_node
@@ -104,74 +102,90 @@ module ForemanFogProxmox
       default_node.servers.next_id
     end
 
-    def vm_server_instance_defaults
-      ActiveSupport::HashWithIndifferentAccess.new(
-        name: "foreman_#{Time.now.to_i}",
-        vmid: next_vmid,
-        type: 'qemu',
-        node_id: default_node_id,
-        cores: 1,
-        sockets: 1,
-        kvm: 1,
-        vga: 'std',
-        memory: 512 * MEGA,
-        ostype: 'l26',
-        keyboard: 'en-us',
-        cpu: 'kvm64',
-        scsihw: 'virtio-scsi-pci',
-        ide2: 'none,media=cdrom',
-        templated: 0
-      ).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_defaults))
-    end
-
-    def vm_container_instance_defaults
-      ActiveSupport::HashWithIndifferentAccess.new(
-        name: "foreman_#{Time.now.to_i}",
-        vmid: next_vmid,
-        type: 'lxc',
-        node_id: default_node_id,
-        memory: 512 * MEGA,
-        templated: 0
-      ).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_defaults))
+    def add_default_typed_interface(type, new_attr)
+      interfaces_attributes = []
+      interfaces_attributes.push(interface_typed_defaults(type))
+      new_attr = new_attr.merge(interfaces_attributes: interfaces_attributes.map.with_index.to_h.invert)
+      logger.debug(format(_('add_default_typed_interface(%<type>s) to new_attr=%<new_attr>s'), type: type, new_attr: new_attr))
+      new_attr
+    end
+
+    def add_default_typed_volume(new_attr)
+      volumes_attributes = []
+      volumes_attributes.push(hard_disk_typed_defaults('qemu'))
+      volumes_attributes.push(hard_disk_typed_defaults('lxc'))
+      new_attr = new_attr.merge(volumes_attributes: volumes_attributes.map.with_index.to_h.invert)
+      logger.debug(format(_('add_default_typed_volume(%<type>s) to new_attr=%<new_attr>s'), type: type, new_attr: new_attr))
+      new_attr
     end
 
     def vm_instance_defaults
-      super.merge(vmid: next_vmid, node_id: default_node_id)
+      super.merge(vmid: next_vmid, node_id: default_node_id, type: 'qemu')
+    end
+
+    def vm_typed_instance_defaults(type)
+      defaults = vm_instance_defaults
+      defaults = defaults.merge(config_attributes: config_attributes(type))
+      defaults = add_default_typed_volume(defaults)
+      defaults = add_default_typed_interface(type, defaults)
+      defaults
+    end
+
+    def config_attributes(type = 'qemu')
+      case type
+      when 'qemu'
+        config_attributes = {
+          cores: 1,
+          sockets: 1,
+          kvm: 0,
+          vga: 'std',
+          memory: 512 * MEGA,
+          ostype: 'l26',
+          cpu: 'cputype=kvm64',
+          scsihw: 'virtio-scsi-pci',
+          templated: 0
+        }
+        config_attributes = config_attributes
+      when 'lxc'
+        config_attributes = {
+          memory: 512 * MEGA,
+          templated: 0
+        }
+      end
+      config_attributes
     end
 
     def new_vm(new_attr = {})
       new_attr = ActiveSupport::HashWithIndifferentAccess.new(new_attr)
       type = new_attr['type']
       type ||= 'qemu'
-      case type
-      when 'lxc'
-        vm = new_container_vm(new_attr)
-      when 'qemu'
-        vm = new_server_vm(new_attr)
-      end
-      logger.debug(format(_('new_vm() vm.config=%<config>s'), config: vm.config.inspect))
+      vm = new_typed_vm(new_attr, type)
       vm
     end
 
-    def new_container_vm(new_attr = {})
-      options = new_attr
-      node_id = new_attr['node_id']
-      node = node_id ? client.nodes.get(node_id) : default_node
-      options = options.merge(type: 'lxc').merge(vmid: next_vmid)
-      options = vm_container_instance_defaults.merge(options) if new_attr.empty?
-      vm = node.containers.new(parse_container_vm(options).deep_symbolize_keys)
-      logger.debug(format(_('new_container_vm() vm.config=%<config>s'), config: vm.config.inspect))
-      vm
+    def convert_config_attributes(new_attr)
+      config_attributes = new_attr[:config_attributes]
+      config_attributes[:volumes_attributes] = Hash[config_attributes[:disks].each_with_index.map { |disk, idx| [idx.to_s, disk.attributes] }] if config_attributes.key?(:disks)
+      if config_attributes.key?(:interfaces)
+        config_attributes[:interfaces_attributes] = Hash[config_attributes[:interfaces].each_with_index.map { |interface, idx| [idx.to_s, interface_compute_attributes(interface.attributes)] }]
+      end
+      config_attributes.delete_if { |key, _value| ['disks', 'interfaces'].include?(key) }
     end
 
-    def new_server_vm(new_attr = {})
-      options = new_attr
+    def new_typed_vm(new_attr, type)
+      convert_config_attributes(new_attr) if new_attr.key?(:config_attributes)
       node_id = new_attr['node_id']
       node = node_id ? client.nodes.get(node_id) : default_node
-      options = options.merge(type: 'qemu').merge(vmid: next_vmid)
-      options = vm_server_instance_defaults.merge(options) if new_attr.empty?
-      vm = node.servers.new(parse_server_vm(options).deep_symbolize_keys)
-      logger.debug(format(_('new_server_vm() vm.config=%<config>s'), config: vm.config.inspect))
+      new_attr_type = new_attr['type']
+      new_attr_type ||= new_attr['config_attributes']['type'] if new_attr.key?('config_attributes')
+      new_attr_type ||= type
+      logger.debug(format(_('new_typed_vm(%<type>s): new_attr_type=%<new_attr_type>s'), type: type, new_attr_type: new_attr_type))
+      logger.debug(format(_('new_typed_vm(%<type>s): new_attr=%<new_attr>s'), type: type, new_attr: new_attr))
+      options = !new_attr.key?('vmid') || ForemanFogProxmox::Value.empty?(new_attr['vmid']) ? new_attr.merge(vm_typed_instance_defaults(type)).merge(type: type) : new_attr
+      logger.debug(format(_('new_typed_vm(%<type>s): options=%<options>s'), type: type, options: options))
+      vm_h = parse_typed_vm(options, type).deep_symbolize_keys
+      logger.debug(format(_('new_typed_vm(%<type>s): vm_h=%<vm_h>s'), type: type, vm_h: vm_h))
+      vm = node.send(vm_collection(type)).new(vm_h)
       vm
     end
   end