foreman_fog_proxmox 0.12.4 → 0.13.0

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

data/app/models/foreman_fog_proxmox/proxmox_vm_queries.rb

@@ -30,6 +30,7 @@ module ForemanFogProxmox
       node = client.nodes.get node_id
       node ||= default_node
       storages = node.storages.list_by_content_type type
+      logger.debug(format(_('storages(): node_id %<node_id>s type %<type>s'), node_id: node_id, type: type))
       storages.sort_by(&:storage)
     end
 
@@ -62,7 +63,7 @@ module ForemanFogProxmox
     end
 
     def find_vm_in_servers_by_uuid(servers, uuid)
-      vm = servers.get(uuid) if !uuid.nil? && !uuid.to_s.empty?
+      vm = servers.get(uuid) unless ForemanFogProxmox::Value.empty?(uuid)
       pool_owner(vm) if vm
       vm
     rescue Fog::Errors::NotFound

data/app/models/foreman_fog_proxmox/proxmox_volumes.rb

@@ -18,13 +18,17 @@
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
 require 'fog/proxmox/helpers/disk_helper'
+require 'foreman_fog_proxmox/hash_collection'
 
 module ForemanFogProxmox
   module ProxmoxVolumes
     include ProxmoxVmHelper
 
-    def delete_volume(vm, id)
+    def delete_volume(vm, id, volume_attributes)
+      logger.info(format(_('vm %<vmid>s delete volume %<volume_id>s'), vmid: vm.identity, volume_id: id))
       vm.detach(id)
+      return unless volume_type?(volume_attributes, 'hard_disk')
+
       device = Fog::Proxmox::DiskHelper.extract_device(id)
       vm.detach('unused' + device.to_s)
     end
@@ -36,25 +40,65 @@ module ForemanFogProxmox
       options
     end
 
-    def update_volume(vm, id, volume_attributes)
-      disk = vm.config.disks.get(id)
-      diff_size = volume_attributes['size'].to_i - disk.size
-      raise ::Foreman::Exception, format(_('Unable to shrink %<id>s size. Proxmox allows only increasing size.'), id: id) unless diff_size >= 0
+    def update_volume_required?(old_volume_attributes, new_volume_attributes)
+      old_h = ForemanFogProxmox::HashCollection.new_hash_reject_empty_values(old_volume_attributes)
+      new_h = ForemanFogProxmox::HashCollection.new_hash_reject_empty_values(new_volume_attributes)
+      new_h = ForemanFogProxmox::HashCollection.new_hash_reject_keys(new_h, ['cdrom', 'cloudinit', 'storage_type'])
+      !ForemanFogProxmox::HashCollection.equals?(old_h.with_indifferent_access, new_h.with_indifferent_access)
+    end
 
-      if diff_size > 0
-        extension = '+' + (diff_size / GIGA).to_s + 'G'
-        vm.extend(id, extension)
-      elsif disk.storage != volume_attributes['storage']
-        vm.move(id, volume_attributes['storage'])
+    def update_cdrom(vm, disk, volume_attributes)
+      new_disk = { id: disk.id }
+      if ['none', 'cdrom'].include?(volume_attributes[:cdrom])
+        new_disk[:volid] = volume_attributes[:cdrom]
       else
-        options = volume_options(vm, id, volume_attributes)
-        vm.attach({ :id => disk.id, :volid => disk.volid, :size => disk.size }, options)
+        new_disk[:storage] = volume_attributes[:storage]
+        new_disk[:volid] = volume_attributes[:volid]
+      end
+      vm.attach(new_disk, {})
+    end
+
+    def extend_volume(vm, id, diff_size)
+      extension = '+' + (diff_size / GIGA).to_s + 'G'
+      logger.info(format(_('vm %<vmid>s extend volume %<volume_id>s to %<extension>s'), vmid: vm.identity, volume_id: id, extension: extension))
+      vm.extend(id, extension)
+    end
+
+    def move_volume(id, vm, new_storage)
+      logger.info(format(_('vm %<vmid>s move volume %<volume_id>s into %<new_storage>s'), vmid: vm.identity, volume_id: id, new_storage: new_storage))
+      vm.move(id, new_storage)
+    end
+
+    def update_options(disk, vm, volume_attributes)
+      options = volume_options(vm, disk.id, volume_attributes) if volume_type?(volume_attributes, 'hard_disk')
+      logger.info(format(_('vm %<vmid>s update volume %<volume_id>s to %<options>s'), vmid: vm.identity, volume_id: disk.id, options: options))
+      new_disk = { id: disk.id }
+      new_disk[:volid] = disk.volid
+      vm.attach(new_disk, options)
+    end
+
+    def update_volume(vm, disk, volume_attributes)
+      id = disk.id
+      if volume_type?(volume_attributes, 'cdrom')
+        update_cdrom(vm, disk, volume_attributes)
+      elsif volume_type?(volume_attributes, 'hard_disk')
+        diff_size = volume_attributes['size'].to_i - disk.size 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']
+
+        if diff_size > 0
+          extend_volume(vm, id, diff_size)
+        elsif disk.storage != new_storage
+          move_volume(id, vm, new_storage)
+        else
+          update_options(disk, vm, volume_attributes)
+        end
       end
     end
 
-    def volume_exists?(volume_attributes)
-      volid = volume_attributes.key?('volid') ? volume_attributes['volid'] : ''
-      volid.present?
+    def volume_exists?(vm, volume_attributes)
+      vm.attributes.key?(volume_attributes['id'])
     end
 
     def volume_to_delete?(volume_attributes)
@@ -63,28 +107,41 @@ module ForemanFogProxmox
 
     def extract_id(vm, volume_attributes)
       id = ''
-      if volume_exists?(volume_attributes)
+      if volume_exists?(vm, volume_attributes)
         id = volume_attributes['id']
       else
         device = vm.container? ? 'mp' : volume_attributes['controller']
-        id = device + volume_attributes['device']
+        id = volume_type?(volume_attributes, 'cdrom') ? 'ide2' : device + volume_attributes['device']
       end
       id
     end
 
     def add_volume(vm, id, volume_attributes)
-      options = volume_options(vm, id, volume_attributes)
-      disk_attributes = { id: id, storage: volume_attributes['storage'], size: (volume_attributes['size'].to_i / GIGA).to_s }
+      disk_attributes = { id: id }
+      if volume_type?(volume_attributes, 'hard_disk')
+        options = volume_options(vm, id, volume_attributes)
+        disk_attributes[:storage] = volume_attributes['storage']
+        disk_attributes[:size] = (volume_attributes['size'].to_i / GIGA).to_s
+      elsif volume_type?(volume_attributes, 'cdrom')
+        disk_attributes[:volid] = volume_attributes[:iso]
+      elsif volume_type?(volume_attributes, 'cloud_init')
+        disk_attributes[:storage] = volume_attributes['storage']
+        disk_attributes[:volid] = "#{volume_attributes['storage']}:cloudinit"
+      end
+      logger.info(format(_('vm %<vmid>s add volume %<volume_id>s'), vmid: vm.identity, volume_id: id))
+      logger.debug(format(_('add_volume(%<vmid>s) disk_attributes=%<disk_attributes>s'), vmid: vm.identity, disk_attributes: disk_attributes))
       vm.attach(disk_attributes, options)
     end
 
     def save_volume(vm, volume_attributes)
+      logger.debug(format(_('save_volume(%<vmid>s) volume_attributes=%<volume_attributes>s'), vmid: vm.identity, volume_attributes: volume_attributes))
       id = extract_id(vm, volume_attributes)
-      if volume_exists?(volume_attributes)
+      if volume_exists?(vm, volume_attributes)
         if volume_to_delete?(volume_attributes)
-          delete_volume(vm, id)
+          delete_volume(vm, id, volume_attributes)
         else
-          update_volume(vm, id, volume_attributes)
+          disk = vm.config.disks.get(id)
+          update_volume(vm, disk, volume_attributes) if update_volume_required?(disk.attributes, volume_attributes)
         end
       else
         add_volume(vm, id, volume_attributes)

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

@@ -17,13 +17,26 @@ along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>. %>
 
 <%= javascript_include_tag 'foreman_fog_proxmox/proxmox_compute_resource', "data-turbolinks-track" => true %>
 
-<% nodes = f.object.nodes rescue nil %>
-<% token_expired = f.object.token_expired? %>
-<% token_deadline = f.object.token_deadline %>
-<%= checkbox_f f, :renew, :label => _("Renew expired token ?"), :checked_value => '1', :label_help => _("Token expires on #{token_deadline}") %>
-<%= text_f f, :url, :help_block => _("e.g. https://127.0.0.1:8006/api2/json"), :help_inline_permanent => load_button_f(f, !!nodes, _("Test failed")) %>
-<%= text_f f, :user , :help_block => _("e.g. root@pam") %>
-<%= password_f f, :password, :keep_value => true, :unset => unset_password? %>
-<%= checkbox_f f, :ssl_verify_peer, :label => _("SSL verify peer"), :checked_value => '1', :onchange => "sslVerifyPeerSelected()" %>
-<%= textarea_f f, :ssl_certs, :label => _("X509 Certification Authorities"), :size => "col-md-4",
-  :placeholder => _("Optionally provide a CA, or a correctly ordered CA chain. If left blank, disable ssl_verify_peer.") %>
+<% user_token = f.object.auth_method == 'user_token' %>
+<% access_ticket = f.object.auth_method == 'access_ticket' %>
+<% ssl_verify_peer = f.object.ssl_verify_peer == '1' %>
+<%= select_f f, :auth_method, proxmox_auth_methods_map, :id, :name, { }, :label_help => _("Click Test connection button before changing it"), :label => _('Authentication method'), :label_size => "col-md-2", :required => true, :onchange => 'authMethodSelected();' %>
+<%= field_set_tag _("Common fields"), :id => "compute_ressource_common_field_set" do %>
+  <%= text_f f, :url, :help_block => _("e.g. https://127.0.0.1:8006/api2/json") %>
+  <%= text_f f, :user , :help_block => _("e.g. root@pam") %>
+<% end %>
+<%= field_set_tag _("User token fields"), :id => "compute_ressource_user_token_field_set", :class => ('hide' unless user_token), :disabled => !user_token do %>
+  <%= text_f f, :token_id, :label => _('User token id'), :required => user_token %>
+  <%= text_f f, :token, :label => _('User token value'), :required => user_token, :label_help => _("Click Test connection button to check token") %>
+<% end %>
+<%= field_set_tag _("Access ticket fields"), :id => "compute_ressource_access_ticket_field_set", :class => ('hide' unless access_ticket), :disabled => !access_ticket do %>
+  <%= password_f f, :password, :keep_value => true, :unset => unset_password?, :required => access_ticket %>
+<% end %>
+<%= field_set_tag _("SSL fields"), :id => "compute_ressource_ssl_field_set" do %>  
+  <%= checkbox_f f, :ssl_verify_peer, :label => _("SSL verify peer"), :label_help => _("Click Test connection button before changing it"), :checked_value => '1', :onchange => 'sslVerifyPeerSelected();' %>
+  <%= textarea_f f, :ssl_certs, :label => _("X509 Certification Authorities"), :size => "col-md-4",
+    :placeholder => _("Optionally provide a CA, or a correctly ordered CA chain. If left blank, disable ssl_verify_peer.") %>
+<% end %>
+<div class="col-md-offset-2">
+  <%= test_connection_button_f(f, (f.object.nodes rescue false)) %>
+</div>