foreman_fog_proxmox 0.12.0

data/app/helpers/proxmox_container_helper.rb

@@ -0,0 +1,163 @@
+# 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'
+
+module ProxmoxContainerHelper
+  def config_keys
+    general_a = ['node_id', 'name', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
+    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
+    keys = { general: general_a }
+    keys.store(:main, ['name', 'type', 'node_id', 'vmid', 'interfaces', 'mount_points', 'disks'])
+    keys.store(:cpu, ['arch', 'cpulimit', 'cpuunits', 'cores'])
+    keys.store(:memory, ['memory', 'swap'])
+    keys
+  end
+
+  def ostemplate_keys
+    ['ostemplate', 'ostemplate_storage', 'ostemplate_file']
+  end
+
+  def parse_ostemplate_without_keys(args)
+    parse_container_ostemplate(args.select { |key, _value| ostemplate_keys.include? key })
+  end
+
+  def config_general_or_ostemplate_key?(key)
+    config_keys[:general].include?(key) || ostemplate_keys.include?(key)
+  end
+
+  def parse_container_vm(args)
+    logger.debug("parse_container_vm args=#{args}")
+    args = ActiveSupport::HashWithIndifferentAccess.new(args)
+    return {} unless args
+    return {} if args.empty?
+    return {} unless args['type'] == 'lxc'
+
+    config = args['config_attributes']
+    config ||= args.reject { |key, _value| config_keys[:main].include? key }
+    ostemplate = parse_ostemplate_without_keys(args)
+    ostemplate = parse_ostemplate_without_keys(config) unless ostemplate[:ostemplate]
+    volumes = parse_container_volumes(args['volumes_attributes'])
+    cpu = parse_container_cpu(config.select { |key, _value| config_keys[:cpu].include? key })
+    memory = parse_container_memory(config.select { |key, _value| config_keys[:memory].include? key })
+    interfaces_attributes = args['interfaces_attributes']
+    interfaces_to_add, interfaces_to_delete = parse_container_interfaces(interfaces_attributes)
+    logger.debug("config_keys[:general]: #{config_keys[:general]}")
+    parsed_vm = args.reject { |key, value| config_general_or_ostemplate_key?(key) || ForemanFogProxmox::Value.empty?(value) }
+    parsed_config = config.reject { |key, value| config_keys.include?(key) || ForemanFogProxmox::Value.empty?(value) }
+    logger.debug("parse_container_config(): #{parsed_config}")
+    parsed_vm = parsed_vm.merge(parsed_config).merge(cpu).merge(memory).merge(ostemplate)
+    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?
+    volumes.each { |volume| parsed_vm = parsed_vm.merge(volume) }
+    logger.debug("parse_container_vm(): #{parsed_vm}")
+    parsed_vm
+  end
+
+  def parse_container_memory(args)
+    memory = {}
+    args.delete_if { |_key, value| ForemanFogProxmox::Value.empty?(value) }
+    memory.store(:memory, args['memory'].to_i) if args['memory']
+    memory.store(:swap, args['swap'].to_i) if args['swap']
+    logger.debug("parse_container_memory(): #{memory}")
+    memory
+  end
+
+  def parse_container_cpu(args)
+    cpu = {}
+    args.delete_if { |_key, value| ForemanFogProxmox::Value.empty?(value) }
+    cpu.store(:arch, args['arch'].to_s) if args['arch']
+    cpu.store(:cpulimit, args['cpulimit'].to_i) if args['cpulimit']
+    cpu.store(:cpuunits, args['cpuunits'].to_i) if args['cpuunits']
+    cpu.store(:cores, args['cores'].to_i) if args['cores']
+    logger.debug("parse_container_cpu(): #{cpu}")
+    cpu
+  end
+
+  def parse_container_ostemplate(args)
+    ostemplate = args['ostemplate']
+    ostemplate_file = args['ostemplate_file']
+    ostemplate ||= ostemplate_file
+    ostemplate_storage = args['ostemplate_storage']
+    ostemplate_storage, ostemplate_file, _size = Fog::Proxmox::DiskHelper.extract_storage_volid_size(ostemplate) unless ForemanFogProxmox::Value.empty?(ostemplate)
+    parsed_ostemplate = { ostemplate: ostemplate, ostemplate_file: ostemplate_file, ostemplate_storage: ostemplate_storage }
+    logger.debug("parse_container_ostemplate(): #{parsed_ostemplate}")
+    parsed_ostemplate
+  end
+
+  def parse_container_volume(args)
+    disk = {}
+    id = args['id']
+    id = "mp#{args['device']}" if args.key?('device')
+    logger.debug("parse_container_volume() args=#{args}")
+    return args if ForemanFogProxmox::Value.empty?(id) || Fog::Proxmox::DiskHelper.server_disk?(id)
+
+    args.delete_if { |_key, value| ForemanFogProxmox::Value.empty?(value) }
+    disk.store(:id, id)
+    disk.store(:volid, args['volid'])
+    disk.store(:storage, args['storage'].to_s)
+    disk.store(:size, args['size'].to_i)
+    options = args.reject { |key, _value| ['id', 'volid', 'device', 'storage', 'size', '_delete'].include? key }
+    disk.store(:options, options)
+    logger.debug("parse_container_volume(): disk=#{disk}")
+    Fog::Proxmox::DiskHelper.flatten(disk)
+  end
+
+  def parse_container_volumes(args)
+    logger.debug("parse_container_volumes() args=#{args}")
+    volumes = []
+    args&.each_value { |value| volumes.push(parse_container_volume(value)) }
+    logger.debug("parse_container_volumes(): volumes=#{volumes}")
+    volumes
+  end
+
+  def parse_container_interfaces(interfaces_attributes)
+    interfaces_to_add = []
+    interfaces_to_delete = []
+    interfaces_attributes&.each_value { |value| add_container_interface(value, interfaces_to_delete, interfaces_to_add) }
+    logger.debug("parse_container_interfaces(): interfaces_to_add=#{interfaces_to_add}, interfaces_to_delete=#{interfaces_to_delete}")
+    [interfaces_to_add, interfaces_to_delete]
+  end
+
+  def add_container_interface(interface_attributes, interfaces_to_delete, interfaces_to_add)
+    interface_attributes.delete_if { |_key, value| ForemanFogProxmox::Value.empty?(value) }
+    nic = {}
+    id = interface_attributes['id']
+    logger.debug("parse_container_interface(): id=#{id}")
+    delete = interface_attributes['_delete'].to_i == 1
+    if delete
+      interfaces_to_delete.push(id.to_s)
+    else
+      nic.store(:id, id)
+      nic.store(:hwaddr, interface_attributes['macaddr']) if interface_attributes['macaddr']
+      nic.store(:name, interface_attributes['name'].to_s)
+      nic.store(:bridge, interface_attributes['bridge'].to_s) if interface_attributes['bridge']
+      nic.store(:ip, interface_attributes['ip'].to_s) if interface_attributes['ip']
+      nic.store(:ip6, interface_attributes['ip6'].to_s) if interface_attributes['ip6']
+      nic.store(:gw, interface_attributes['gw'].to_s) if interface_attributes['gw']
+      nic.store(:gw6, interface_attributes['gw6'].to_s) if interface_attributes['gw6']
+      nic.store(:rate, interface_attributes['rate'].to_i) if interface_attributes['rate']
+      nic.store(:tag, interface_attributes['tag'].to_i) if interface_attributes['tag']
+      logger.debug("parse_container_interface(): add nic=#{nic}")
+      interfaces_to_add.push(Fog::Proxmox::NicHelper.flatten(nic))
+    end
+  end
+end

data/app/helpers/proxmox_form_helper.rb

@@ -0,0 +1,70 @@
+# 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/>.
+
+module ProxmoxFormHelper
+  def password_proxmox_f(f, attr, options = {})
+    unset_button = options.delete(:unset)
+    value = f.object[attr] if options.delete(:keep_value)
+    password_field_tag(:fakepassword, value, :style => 'display: none', :autocomplete => 'new-password-fake') +
+      field(f, attr, options) do
+        options[:autocomplete]   ||= 'new-password'
+        options[:placeholder]    ||= password_proxmox_placeholder(f.object, attr)
+        options[:disabled] = true if unset_button
+        options[:value] = value if value.present?
+        addClass options, 'form-control'
+        pass = f.password_field(attr, options) +
+               content_tag(:span, '', class: 'glyphicon glyphicon-warning-sign input-addon',
+                                      title: 'Caps lock ON', style: 'display:none')
+        if unset_button
+          button = link_to_function(icon_text('edit', '', :kind => 'pficon'), 'toggle_input_group(this)', :id => 'disable-pass-btn', :class => 'btn btn-default', :title => _('Change the password'))
+          input_group(pass, input_group_btn(button))
+        else
+          pass
+        end
+      end
+  end
+
+  def password_proxmox_placeholder(obj, attr = nil)
+    pass = obj.attributes.key?(attr)
+    pass ? '********' : ''
+  end
+
+  def new_child_fields_template_typed(form_builder, association, options = {})
+    if options[:object].blank?
+      association_object = form_builder.object.class.reflect_on_association(association)
+      options[:object] = association_object.klass.new(association_object.foreign_key => form_builder.object.id)
+    end
+    options[:partial]            ||= association.to_s.singularize
+    options[:form_builder_local] ||= :f
+    options[:form_builder_attrs] ||= {}
+
+    content_tag(:div, :class => "#{options[:type]}_#{association}_fields_template form_template ", :style => 'display: none;') do
+      form_builder.fields_for(association, options[:object], :child_index => "new_#{options[:type]}_#{association}") do |f|
+        render(:partial => options[:partial], :layout => options[:layout],
+               :locals => { options[:form_builder_local] => f }.merge(options[:form_builder_attrs]))
+      end
+    end
+  end
+
+  def add_child_link_typed(name, association, type, opts = {})
+    opts[:class] = [opts[:class], 'add_nested_fields btn btn-primary'].compact.join(' ')
+    opts[:"data-association"] = (type + '_' + association.to_s).to_sym
+    link_to_function(name.to_s, 'add_child_node(this);tfm.numFields.initAll();', opts)
+  end
+end

data/app/helpers/proxmox_server_helper.rb

@@ -0,0 +1,155 @@
+# 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'
+
+module ProxmoxServerHelper
+  def parse_server_vm(args)
+    logger.debug("parse_server_vm args=#{args}")
+    args = ActiveSupport::HashWithIndifferentAccess.new(args)
+    return {} unless args
+    return {} if args.empty?
+    return {} unless args['type'] == 'qemu'
+
+    config = args['config_attributes']
+    main_a = ['name', 'type', 'node_id', 'vmid', 'interfaces', 'mount_points', 'disks']
+    config ||= args.reject { |key, _value| main_a.include? key }
+    cdrom_a = ['cdrom', 'cdrom_storage', 'cdrom_iso']
+    cdrom = parse_server_cdrom(config.select { |key, _value| cdrom_a.include? key })
+    vols = args['volumes_attributes']
+    volumes = parse_server_volumes(vols)
+    cpu_a = ['cpu_type', 'spectre', 'pcid']
+    cpu = parse_server_cpu(config.select { |key, _value| cpu_a.include? key })
+    memory_a = ['memory', 'balloon', 'shares']
+    memory = parse_server_memory(config.select { |key, _value| memory_a.include? key })
+    interfaces_attributes = args['interfaces_attributes']
+    interfaces_to_add, interfaces_to_delete = parse_server_interfaces(interfaces_attributes)
+    general_a = ['node_id', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
+    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
+    logger.debug("general_a: #{general_a}")
+    parsed_vm = args.reject { |key, value| general_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
+    config_a = []
+    config_a += cpu_a
+    config_a += cdrom_a
+    config_a += memory_a
+    config_a += general_a
+    parsed_config = config.reject { |key, value| config_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
+    logger.debug("parse_server_config(): #{parsed_config}")
+    parsed_vm = parsed_vm.merge(parsed_config).merge(cpu).merge(memory).merge(cdrom)
+    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?
+    volumes.each { |volume| parsed_vm = parsed_vm.merge(volume) }
+    logger.debug("parse_server_vm(): #{parsed_vm}")
+    parsed_vm
+  end
+
+  def parse_server_memory(args)
+    memory = {}
+    memory.store(:memory, args['memory'].to_i) if args['memory']
+    memory.store(:shares, args['shares'].to_i) if args['shares']
+    memory.store(:balloon, args['balloon'].to_i) if args['balloon']
+    logger.debug("parse_server_memory(): #{memory}")
+    memory
+  end
+
+  def parse_server_cpu(args)
+    return {} unless args['cpu_type']
+
+    cpu = "cputype=#{args['cpu_type']}"
+    spectre = args['spectre'].to_i == 1
+    pcid = args['pcid'].to_i == 1
+    cpu += ',flags=' if spectre || pcid
+    cpu += '+spec-ctrl' if spectre
+    cpu += ';' if spectre && pcid
+    cpu += '+pcid' if pcid
+    args.delete_if { |key, value| ['cpu_type', 'spectre', 'pcid'].include?(key) || ForemanFogProxmox::Value.empty?(value) }
+    args.each_value(&:to_i)
+    parsed_cpu = { cpu: cpu }.merge(args)
+    logger.debug("parse_server_cpu(): #{parsed_cpu}")
+    parsed_cpu
+  end
+
+  def parse_server_cdrom(args)
+    cdrom = args['cdrom']
+    cdrom_image = args['cdrom_iso']
+    volid = cdrom_image.empty? ? cdrom : cdrom_image
+    return {} unless volid
+
+    cdrom = "#{volid},media=cdrom"
+    { ide2: cdrom }
+  end
+
+  def parse_server_volume(args)
+    disk = {}
+    volid = args['volid'] if args.key?('volid')
+    id = args['id'] if volid
+    id = "#{args['controller']}#{args['device']}" if args.key?('controller') && args.key?('device') && !id
+    return args if ForemanFogProxmox::Value.empty?(id) || id == 'rootfs'
+
+    args.delete_if { |_key, value| ForemanFogProxmox::Value.empty?(value) }
+    disk.store(:id, id)
+    disk.store(:volid, args['volid']) if args.key?('volid')
+    disk.store(:storage, args['storage'].to_s) if args.key?('storage')
+    disk.store(:size, args['size'].to_i) if args.key?('size')
+    options = args.reject { |key, _value| ['id', 'volid', 'controller', 'device', 'storage', 'size', '_delete'].include? key }
+    disk.store(:options, options)
+    logger.debug("parse_server_volume(): disk=#{disk}")
+    Fog::Proxmox::DiskHelper.flatten(disk)
+  end
+
+  def parse_server_volumes(args)
+    volumes = []
+    args&.each_value { |value| volumes.push(parse_server_volume(value)) }
+    logger.debug("parse_server_volumes(): volumes=#{volumes}")
+    volumes
+  end
+
+  def parse_server_interfaces(interfaces_attributes)
+    interfaces_to_add = []
+    interfaces_to_delete = []
+    interfaces_attributes&.each_value { |value| add_server_interface(value, interfaces_to_delete, interfaces_to_add) }
+    logger.debug("parse_server_interfaces(): interfaces_to_delete=#{interfaces_to_delete} interfaces_to_add=#{interfaces_to_add}")
+    [interfaces_to_add, interfaces_to_delete]
+  end
+
+  def add_server_interface(interface_attributes, interfaces_to_delete, interfaces_to_add)
+    interface_attributes.delete_if { |_key, value| ForemanFogProxmox::Value.empty?(value) }
+    nic = {}
+    id = interface_attributes['id']
+    logger.debug("add_server_interface(): id=#{id}")
+    delete = interface_attributes['_delete'].to_i == 1
+    if delete
+      interfaces_to_delete.push(id.to_s)
+    else
+      nic.store(:id, id)
+      nic.store(:macaddr, interface_attributes['macaddr']) if interface_attributes['macaddr']
+      nic.store(:tag, interface_attributes['tag'].to_i) if interface_attributes['tag']
+      nic.store(:model, interface_attributes['model'].to_s)
+      nic.store(:bridge, interface_attributes['bridge'].to_s) if interface_attributes['bridge']
+      nic.store(:firewall, interface_attributes['firewall'].to_i) if interface_attributes['firewall']
+      nic.store(:rate, interface_attributes['rate'].to_i) if interface_attributes['rate']
+      nic.store(:link_down, interface_attributes['link_down'].to_i) if interface_attributes['link_down']
+      nic.store(:queues, interface_attributes['queues'].to_i) if interface_attributes['queues']
+      logger.debug("add_server_interface(): add nic=#{nic}")
+      interfaces_to_add.push(Fog::Proxmox::NicHelper.flatten(nic))
+    end
+  end
+end

data/app/helpers/proxmox_vm_helper.rb

@@ -0,0 +1,88 @@
+# 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'
+
+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)
+  end
+end