foreman_fog_proxmox 0.12.2 → 0.13.3

data/app/helpers/proxmox_vm_cdrom_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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/>.
+
+require 'fog/proxmox/helpers/disk_helper'
+require 'fog/proxmox/helpers/nic_helper'
+require 'foreman_fog_proxmox/value'
+require 'foreman_fog_proxmox/hash_collection'
+
+# Convert a foreman form server hash into a fog-proxmox server attributes hash
+module ProxmoxVmCdromHelper
+  def parse_server_cdrom(args)
+    cdrom_media = args['cdrom'] if args.key?('cdrom')
+    cdrom_image = args['volid'] if args.key?('volid')
+    volid = cdrom_image.empty? ? cdrom_media : cdrom_image
+    return {} unless volid
+
+    { id: 'ide2', volid: volid, media: 'cdrom' }
+  end
+end

data/app/helpers/proxmox_vm_cloudinit_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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/>.
+
+require 'fog/proxmox/helpers/disk_helper'
+require 'fog/proxmox/helpers/nic_helper'
+require 'foreman_fog_proxmox/value'
+require 'foreman_fog_proxmox/hash_collection'
+
+# Convert a foreman form server hash into a fog-proxmox server attributes hash
+module ProxmoxVmCloudinitHelper
+  def parse_server_cloudinit(args)
+    cloudinit_h = {}
+    cloudinit = args['cloudinit']
+    unless ['none'].include? cloudinit
+      volid = args['volid']
+      storage = args['storage']
+      cloudinit_volid = volid if volid
+      cloudinit_volid ||= "#{storage}:cloudinit" if storage
+      controller = args['controller']
+      device = args['device']
+      id = "#{controller}#{device}" if controller && device
+      cloudinit_h.store(:id, id.to_sym) if id
+      cloudinit_h.store(:volid, cloudinit_volid) if cloudinit_volid
+    end
+    cloudinit_h
+  end
+end

data/app/helpers/proxmox_vm_config_helper.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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/>.
+
+require 'fog/proxmox/helpers/disk_helper'
+require 'fog/proxmox/helpers/nic_helper'
+require 'fog/proxmox/helpers/cpu_helper'
+require 'foreman_fog_proxmox/value'
+require 'foreman_fog_proxmox/hash_collection'
+
+# Convert a foreman form server hash into a fog-proxmox server attributes hash
+module ProxmoxVmConfigHelper
+  KILO = 1024
+  MEGA = KILO * KILO
+  GIGA = KILO * MEGA
+
+  def object_to_config_hash(vm, type)
+    vm_h = ActiveSupport::HashWithIndifferentAccess.new
+    main_a = ['vmid']
+    main = vm.attributes.select { |key, _value| main_a.include? key }
+    main_a += ['templated']
+    config = vm.config.attributes.reject { |key, _value| main_a.include?(key) || Fog::Proxmox::DiskHelper.disk?(key) || Fog::Proxmox::NicHelper.nic?(key) }
+    vm_h = vm_h.merge(main)
+    vm_h = vm_h.merge('config_attributes': config)
+    logger.debug(format(_('object_to_config_hash(%<type>s): vm_h=%<vm_h>s'), type: type, vm_h: vm_h))
+    vm_h
+  end
+
+  def convert_memory_size(config_hash, key)
+    # default unit memory size is Mb
+    memory = (config_hash[key].to_i / MEGA).to_s == '0' ? config_hash[key] : (config_hash[key].to_i / MEGA).to_s
+    config_hash.store(key, memory)
+  end
+
+  def general_a(type)
+    general_a = ['node_id', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
+    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
+    general_a += ['name'] if type == 'lxc'
+    general_a
+  end
+
+  def config_typed_keys(type)
+    keys = { general: general_a(type) }
+    main_a = ['name', 'type', 'node_id', 'vmid', 'interfaces', 'mount_points', 'disks']
+    case type
+    when 'lxc'
+      cpu_a = ['arch', 'cpulimit', 'cpuunits', 'cores', 'sockets']
+      memory_a = ['memory', 'swap']
+      ostemplate_a = ['ostemplate', 'ostemplate_storage', 'ostemplate_file']
+      keys.store(:ostemplate, ostemplate_a)
+    when 'qemu'
+      cpu_a = ['cpu_type', 'cpu']
+      cpu_a += ForemanFogProxmox::HashCollection.stringify_keys(Fog::Proxmox::CpuHelper.flags).keys
+      memory_a = ['memory', 'balloon', 'shares']
+      cloud_init_a = ['ciuser', 'cipassword', 'searchdomain', 'nameserver']
+      keys.store(:cloud_init, cloud_init_a)
+    end
+    keys.store(:main, main_a)
+    keys.store(:cpu, cpu_a)
+    keys.store(:memory, memory_a)
+    keys
+  end
+
+  def convert_memory_sizes(args)
+    ['memory', 'balloon', 'shares', 'swap'].each { |key| convert_memory_size(args['config_attributes'], key) }
+  end
+
+  def config_general_or_ostemplate_key?(key)
+    config_typed_keys('lxc')[:general].include?(key) || config_typed_keys(type)[:ostemplate].include?(key)
+  end
+
+  def config_a(type)
+    config_a = []
+    case type
+    when 'qemu'
+      [:cpu, :memory, :general, :cloud_init].each { |key| config_a += config_typed_keys(type)[key] }
+    when 'lxc'
+      [:main].each { |key| config_a += config_typed_keys(type)[key] }
+    end
+    config_a
+  end
+
+  def args_a(type)
+    args_a = []
+    case type
+    when 'qemu'
+      [:general].each { |key| args_a += config_typed_keys(type)[key] }
+    when 'lxc'
+      [:general, :ostemplate].each { |key| args_a += config_typed_keys(type)[key] }
+    end
+    args_a
+  end
+
+  def config_options(config, args, type)
+    options = {}
+    case type
+    when 'qemu'
+      options = config.select { |key, _value| config_typed_keys(type)[:cloud_init].include? key }
+    when 'lxc'
+      options = parse_ostemplate(args, config)
+    end
+    options
+  end
+
+  def parsed_typed_config(args, type)
+    config = args['config_attributes']
+    config ||= ForemanFogProxmox::HashCollection.new_hash_reject_keys(args, config_typed_keys(type)[:main])
+    logger.debug("parsed_typed_config(#{type}): config=#{config}")
+    config_cpu = config.select { |key, _value| config_typed_keys(type)[:cpu].include? key }
+    logger.debug("parsed_typed_config(#{type}): config_cpu=#{config_cpu}")
+    cpu = parse_typed_cpu(config_cpu, type)
+    memory = parse_typed_memory(config.select { |key, _value| config_typed_keys(type)[:memory].include? key }, type)
+    parsed_config = config.reject { |key, value| config_a(type).include?(key) || ForemanFogProxmox::Value.empty?(value) }
+    parsed_vm = args.reject { |key, value| args_a(type).include?(key) || ForemanFogProxmox::Value.empty?(value) }
+    parsed_vm = parsed_vm.merge(config_options(config, args, type))
+    parsed_vm = parsed_vm.merge(parsed_config).merge(cpu).merge(memory)
+    logger.debug("parsed_typed_config(#{type}): parsed_vm=#{parsed_vm}")
+    parsed_vm
+  end
+
+  def parse_typed_memory(args, type)
+    memory = {}
+    ForemanFogProxmox::HashCollection.remove_empty_values(args)
+    config_typed_keys(type)[:memory].each { |key| ForemanFogProxmox::HashCollection.add_and_format_element(memory, key.to_sym, args, key, :to_i) }
+    memory
+  end
+
+  def parse_typed_cpu(args, type)
+    cpu = {}
+    ForemanFogProxmox::HashCollection.remove_empty_values(args)
+    if type == 'qemu'
+      logger.debug("parse_typed_cpu(#{type}): args=#{args}")
+      cpu_flattened = Fog::Proxmox::CpuHelper.flatten(args)
+      cpu_flattened = args[:cpu] if cpu_flattened.empty?
+      logger.debug("parse_typed_cpu(#{type}): cpu_flattened=#{cpu_flattened}")
+      ForemanFogProxmox::HashCollection.remove_empty_values(args)
+      ForemanFogProxmox::HashCollection.remove_keys(args, config_typed_keys('qemu')[:cpu])
+      args.each_value(&:to_i)
+      cpu = { cpu: cpu_flattened }
+    end
+    config_typed_keys('lxc')[:cpu].each { |key| ForemanFogProxmox::HashCollection.add_and_format_element(cpu, key.to_sym, args, key) } if type == 'lxc'
+    logger.debug("parse_typed_cpu(#{type}): cpu=#{cpu}")
+    cpu
+  end
+end

data/app/helpers/proxmox_vm_helper.rb

@@ -22,67 +22,29 @@ require 'fog/proxmox/helpers/nic_helper'
 require 'foreman_fog_proxmox/value'
 
 module ProxmoxVmHelper
-  KILO = 1024
-  MEGA = KILO * KILO
-  GIGA = KILO * MEGA
-
-  def object_to_config_hash(vm)
-    vm_h = ActiveSupport::HashWithIndifferentAccess.new
-    main_a = ['hostname', 'name', 'vmid']
-    main = vm.attributes.select { |key, _value| main_a.include? key }
-    main_a += ['templated']
-    config = vm.config.attributes.reject { |key, _value| main_a.include?(key) || Fog::Proxmox::DiskHelper.disk?(key) || Fog::Proxmox::NicHelper.nic?(key) }
-    vm_h = vm_h.merge(main)
-    vm_h = vm_h.merge('config_attributes': config)
-    vm_h
-  end
-
-  def add_cdrom_to_config_server(vm, config)
-    cd_disks = vm.config.disks.select { |disk| disk.id == 'ide2' }
-    cdrom = {}
-    disk_to_cdrom(cd_disks.first, cdrom)
-    config = config.merge(cdrom)
-    config
-  end
-
-  def disk_to_cdrom(disk, cdrom)
-    volid = disk.volid
-    cdrom_a = ['none', 'cdrom']
-    if cdrom_a.include? volid
-      cdrom.store('cdrom', volid)
-    else
-      cdrom.store('cdrom', 'image')
-      cdrom.store('cdrom_iso', volid)
-      cdrom.store('cdrom_storage', disk.storage)
-    end
-  end
-
-  def convert_memory_sizes(args)
-    convert_memory_size(args['config_attributes'], 'memory')
-    convert_memory_size(args['config_attributes'], 'balloon')
-    convert_memory_size(args['config_attributes'], 'shares')
-    convert_memory_size(args['config_attributes'], 'swap')
-  end
-
-  def convert_volumes_size(args)
-    args['volumes_attributes'].each_value { |value| value['size'] = (value['size'].to_i / GIGA).to_s unless ForemanFogProxmox::Value.empty?(value['size']) }
-  end
-
-  def convert_sizes(args)
-    convert_memory_size(args['config_attributes'], 'memory')
-    convert_memory_size(args['config_attributes'], 'balloon')
-    convert_memory_size(args['config_attributes'], 'shares')
-    convert_memory_size(args['config_attributes'], 'swap')
-    args['volumes_attributes'].each_value { |value| value['size'] = (value['size'].to_i / GIGA).to_s unless ForemanFogProxmox::Value.empty?(value['size']) }
-  end
-
-  def remove_deletes(args)
-    args['volumes_attributes']&.delete_if { |_key, value| value.key? '_delete' }
-  end
-
-  def convert_memory_size(config_hash, key)
-    # default unit memory size is Mb
-    memory = (config_hash[key].to_i / MEGA).to_s == '0' ? config_hash[key] : (config_hash[key].to_i / MEGA).to_s
-    config_hash.store(key, memory)
+  include ProxmoxVmInterfacesHelper
+  include ProxmoxVmVolumesHelper
+  include ProxmoxVmConfigHelper
+  include ProxmoxVmOsTemplateHelper
+
+  def vm_collection(type)
+    collection = :servers
+    collection = :containers if type == 'lxc'
+    collection
+  end
+
+  # Convert a foreman form server/container vm hash into a fog-proxmox server/container attributes hash
+  def parse_typed_vm(args, type)
+    args = ActiveSupport::HashWithIndifferentAccess.new(args)
+    return {} unless args
+    return {} if args.empty?
+    return {} unless args['type'] == type
+
+    logger.debug("parse_typed_vm(#{type}): args=#{args}")
+    parsed_vm = parsed_typed_config(args, type)
+    parsed_vm = parsed_typed_interfaces(args, type, parsed_vm)
+    parsed_vm = parsed_typed_volumes(args, type, parsed_vm)
+    logger.debug("parse_typed_vm(#{type}): parsed_vm=#{parsed_vm}")
+    parsed_vm
   end
 end

data/app/helpers/proxmox_vm_interfaces_helper.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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/>.
+
+require 'fog/proxmox/helpers/disk_helper'
+require 'fog/proxmox/helpers/nic_helper'
+require 'foreman_fog_proxmox/value'
+require 'foreman_fog_proxmox/hash_collection'
+
+# Convert a foreman form server hash into a fog-proxmox server attributes hash
+module ProxmoxVmInterfacesHelper
+  def parsed_typed_interfaces(args, type, parsed_vm)
+    interfaces_to_add, interfaces_to_delete = parse_typed_interfaces(args, type)
+    interfaces_to_add.each { |interface| parsed_vm = parsed_vm.merge(interface) }
+    parsed_vm = parsed_vm.merge(delete: interfaces_to_delete.join(',')) unless interfaces_to_delete.empty?
+    parsed_vm
+  end
+
+  def parse_typed_interfaces(args, type)
+    interfaces_to_add = []
+    interfaces_to_delete = []
+    interfaces_attributes = args['interfaces_attributes']
+    interfaces_attributes ||= args['config_attributes']['interfaces_attributes'] unless ForemanFogProxmox::Value.empty?(args['config_attributes'])
+    interfaces_attributes&.each_value { |value| add_or_delete_typed_interface(value, interfaces_to_delete, interfaces_to_add, type) }
+    [interfaces_to_add, interfaces_to_delete]
+  end
+
+  def interface_compute_attributes_typed_keys(type)
+    keys = ['rate', 'bridge', 'tag']
+    case type
+    when 'qemu'
+      keys += ['model', 'firewall', 'link_down', 'queues']
+    when 'lxc'
+      keys += ['name', 'ip', 'ip6', 'gw', 'gw6', 'dhcp', 'dhcp6', 'cidr', 'cidr6', 'firewall']
+    end
+    keys
+  end
+
+  def interface_common_typed_keys(type)
+    [{ origin: 'id', dest: 'id' }, { origin: 'mac', dest: type == 'qemu' ? 'macaddr' : 'hwaddr' }]
+  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'
+  end
+
+  def add_or_delete_typed_interface(interface_attributes, interfaces_to_delete, interfaces_to_add, type)
+    logger.debug("add_or_delete_typed_interface(#{type}): interface_attributes=#{interface_attributes}")
+    ForemanFogProxmox::HashCollection.remove_empty_values(interface_attributes)
+    ForemanFogProxmox::HashCollection.remove_empty_values(interface_attributes['compute_attributes']) if interface_attributes['compute_attributes']
+    nic = {}
+    id = interface_attributes['id']
+    delete = interface_attributes['_delete'].to_i == 1
+    if delete
+      logger.debug("add_or_delete_typed_interface(#{type}): delete id=#{id}")
+      interfaces_to_delete.push(id.to_s)
+    else
+      interface_common_typed_keys(type).each { |key| ForemanFogProxmox::HashCollection.add_and_format_element(nic, key[:dest].to_sym, interface_attributes, key[:origin]) }
+      interface_attributes_h = interface_attributes['compute_attributes']
+      interface_attributes_h ||= interface_attributes if ForemanFogProxmox::Value.empty?(interface_attributes['compute_attributes'])
+      interface_compute_attributes_typed_keys(type).each { |key| ForemanFogProxmox::HashCollection.add_and_format_element(nic, key.to_sym, interface_attributes_h, key) }
+      compute_dhcps(interface_attributes_h)
+      logger.debug("add_or_delete_typed_interface(#{type}): add nic=#{nic}")
+      interfaces_to_add.push(Fog::Proxmox::NicHelper.flatten(nic))
+    end
+  end
+end

data/app/helpers/proxmox_vm_os_template_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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/>.
+
+require 'fog/proxmox/helpers/disk_helper'
+require 'fog/proxmox/helpers/nic_helper'
+require 'foreman_fog_proxmox/value'
+require 'foreman_fog_proxmox/hash_collection'
+
+module ProxmoxVmOsTemplateHelper
+  def ostemplate_keys
+    ['ostemplate_storage', 'ostemplate_file']
+  end
+
+  def parse_ostemplate_without_keys(args)
+    parse_container_ostemplate(args.select { |key, _value| ostemplate_keys.include? key })
+  end
+
+  def parse_ostemplate(args, config)
+    ostemplate = parse_ostemplate_without_keys(args)
+    ostemplate = parse_ostemplate_without_keys(config) unless ostemplate[:ostemplate]
+    ostemplate
+  end
+
+  def parse_container_ostemplate(args)
+    ostemplate = args['ostemplate']
+    ostemplate_file = args['ostemplate_file']
+    ostemplate ||= ostemplate_file
+    parsed_ostemplate = { ostemplate: ostemplate }
+    parsed_ostemplate
+  end
+end