foreman_fog_proxmox 0.14.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19b7f2f30af319dbc8881900c660bf9ddc5026eb8762ace34dcd6b4ac7fa85f8
-  data.tar.gz: 5430f62a1d7db829fddb142c468d5c3741a0090131f0a3d26746bec75f6b943e
+  metadata.gz: 70a0629dba4c5afe29ddca15cbe49df9325edb80ca73d076c41c3fc1d283ecff
+  data.tar.gz: f680eed4c519701ecdc5bc38117ca62eb846551ab972aa8e5f38869b17fe414e
 SHA512:
-  metadata.gz: ceac1a672eb780a7c7e8e05d8024f70d74d129a3ff48ad5d65f9947c78d60778a3697c7a70e030eff53346f3f56587a726fa71b5a719bb448bbea573d7970e47
-  data.tar.gz: cd477463a37e43ce80db0986f08d8203b225cfc5abae4f31b5c165cfc149197c99be2b2d8687b6e217246609c77d781658d93c119b37c41bfebc6049be852b4a
+  metadata.gz: 6c8d56b7e0a4e02ac2195fdd248aa12f5934b8a9746763d1aff59d0df1316f09abb3dbfe212f99e7a39307132065550871bb84a7fcab04787e3e8ca9bd70e50d
+  data.tar.gz: 883ee296ceea79f15e220c8fe9cad273aed8201862be59b41b79761ae01d8cc837adcbe3dae54e9e24d1f30f34dee3d85e7eb8c83ccaa94d0522f27bc28925b3

data/README.md

@@ -2,7 +2,7 @@
 
 ![CI](https://github.com/theforeman/foreman_fog_proxmox/workflows/CI/badge.svg)
 [![Maintainability](https://api.codeclimate.com/v1/badges/922162c278e0fa9207ba/maintainability)](https://codeclimate.com/github/theforeman/foreman_fog_proxmox/maintainability)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/922162c278e0fa9207ba/test_coverage)](https://codeclimate.com/github/theforeman/foreman_fog_proxmox/test_coverage)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/a6446cf7b1cf09b83de6/test_coverage)](https://codeclimate.com/github/theforeman/foreman_fog_proxmox/test_coverage)
 [![Gem Version](https://badge.fury.io/rb/foreman_fog_proxmox.svg)](https://badge.fury.io/rb/foreman_fog_proxmox)
 
 # ForemanFogProxmox
@@ -38,7 +38,7 @@ You can support the plugin development via the following methods:
 
 ## Installation
 
-### From OS packages
+### From OS packages (required)
 
 Please see the Foreman manual for complete instructions:
 
@@ -128,15 +128,17 @@ Then you can check plugin installation after login into your new foreman server
 
 ### Dev prerequisites
 
-* You need a Proxmox VE 5.4+ server running.
-* You need ruby >= 2.5. You can install it with [asdf-vm](https://asdf-vm.com).
-* You also need nodejs in your dev machine to run webpack-dev-server. You can install it with [asdf-vm](https://asdf-vm.com).
+> See [Foreman dev setup](https://github.com/theforeman/foreman/blob/develop/developer_docs/foreman_dev_setup.asciidoc)
+
+* You need a Proxmox VE 6.2+ server running.
+* You need ruby 2.7. You can install it with [asdf-vm](https://asdf-vm.com).
+* You also need nodejs 14 in your dev machine to run webpack-dev-server. You can install it with [asdf-vm](https://asdf-vm.com).
 
 ### Platform
 
 * Fork this github repo.
 * Clone it on your local machine
-* Install foreman v1.22+ on your machine:
+* Install foreman v2.5+ on your machine:
 
 ```shell
 git clone https://github.com/theforeman/foreman -b develop
@@ -158,9 +160,9 @@ gem 'simplecov' # test
 
 ```shell
 gem install bundler
-# prerequisites postgresql-XX-client library on OS (XX=major release installed in OS)
-bundle config set without 'libvirt ovirt mysql2'
-bundle config build.pg --with-pg-config=/usr/pgsql-XX/bin/pg_config
+# prerequisites libraries on Ubuntu OS:
+# sudo apt install postgresql-client-13 libpq-dev libsystemd-dev
+bundle config set without 'libvirt ovirt'
 bundle install
 ```
 
@@ -178,6 +180,12 @@ add these lines to config/settings.yml:
 
 ```yaml
     :webpack_dev_server: true
+    :destroy_vm_on_host_delete: true # optional, could be set on UI
+    :logging:
+      :level: debug
+    :loggers:
+      :sql:
+       :enabled: false
 ```
 
 * SQLite is no more default rails dev or test database, instead add:
@@ -189,45 +197,42 @@ DATABASE_URL=nulldb://nohost
 * (Optional) test and dev with postgresql database:
 
 ```shell
-cp config/model.mappings.example config/model.mappings
 cp config/database.yml.example config/database.yml
 ```
 
 add these lines to each environment in config/database.yml:
 
 ```yaml
+    host: localhost
     username: foreman
     password: foreman
 ```
 
 ```shell
 cp config/ignored_environments.yml.sample config/ignored_environments.yml
-docker run --name foreman-db -v foreman_data:/var/lib/postgresql/data -e POSTGRES_DB=foreman -e POSTGRES_USER=foreman -e POSTGRES_PASSWORD=foreman -p 5432:5432 -d postgres
+docker run --name foreman-db -v foreman_data:/var/lib/postgresql/data -e POSTGRES_DB=foreman -e POSTGRES_USER=foreman -e POSTGRES_PASSWORD=foreman -p 5432:5432 -d postgres:13
 bundle exec bin/rake db:migrate
-# reboot if settings.NAME error in schema
-bundle exec bin/rake db:seed assets:precompile locale:pack webpack:compile
+RAILS_ENV=development bundle exec bin/rake db:seed assets:precompile locale:pack webpack:compile
 ```
 
-* You can reset admin password if needed:
+* You can reset and change your admin password if needed:
 
 ```shell
-bundle exec bin/rake permissions:reset
+RAILS_ENV=development bundle exec bin/rake permissions:reset password=changeme
 ```
 
 * You should write tests and you can execute those specific to this plugin:
 
-first, create database `foreman-test` with psql commands:
+first, create database `foreman-test`:
 
 ```shell
-docker exec -it foreman-db psql -U foreman
-foreman=# create database "foreman-test";
+RAILS_ENV=test bundle exec rake db:create
 ```
 
 then add test schema and seeds:
 
 ```shell
 RAILS_ENV=test bundle exec bin/rake db:migrate
-# reboot if error: "ActiveRecord::RecordNotFound: Couldn't find Setting with [WHERE "settings"."name" = $1]"
 RAILS_ENV=test bundle exec bin/rake db:seed
 ```
 
@@ -245,10 +250,22 @@ export DISABLE_SPRING=true
 bundle exec bin/rake test TEST=../foreman_fog_proxmox/test/functional/compute_resources_controller_test.rb DATABASE_URL=nulldb://nohost
 ```
 
-* Check code syntax with rubocop and foreman rules:
+* In foreman_fog_proxmox source directory, check code syntax with rubocop and foreman rules:
+
+```shell
+bundle exec rubocop
+```
+
+safe autocorrect:
+
+```shell
+bundle exec rubocop -a
+```
+
+Temporary ignore offenses:
 
 ```shell
-bundle exec bin/rake foreman_fog_proxmox:rubocop
+bundle exec rubocop --auto-gen-config
 ```
 
 * See deface overrides result:
@@ -265,14 +282,16 @@ bundle exec bin/rake plugin:assets:precompile[foreman_fog_proxmox]
 
 * In foreman directory, after you modify foreman_fog_proxmox translations (language, texts in new files, etc) you have to compile it:
 
+Prerequisites: [Transifex CLI](https://github.com/transifex/cli)
+
 ```shell
-bundle exec bin/rake plugin:gettext[foreman_fog_proxmox]
+bundle exec bin/rake plugin:gettext\[foreman_fog_proxmox\]
 ```
 
 * In foreman directory, run in a new terminal the webpack-dev-server:
 
 ```shell
-./node_modules/.bin/webpack-dev-server --config config/webpack.config.js
+./node_modules/.bin/webpack-dev-server-without-h2 --config config/webpack.config.js
 ```
 
 * Or without webpack-dev-server, add this line in config/settings.yml:
@@ -299,12 +318,6 @@ bundle exec bin/rails server
 bundle exec foreman start
 ```
 
-If you want to delete vm on host destroy, add this line in config/settings.yml:
-
-```yml
-:destroy_vm_on_host_delete: false
-```
-
 See details in [foreman plugin development](https://projects.theforeman.org/projects/foreman/wiki/How_to_Create_a_Plugin)
 
 ## Contributing

data/app/controllers/concerns/foreman_fog_proxmox/compute_resources_vms_controller.rb

@@ -26,15 +26,20 @@ module ForemanFogProxmox
     module Overrides
       def associate
         if Host.for_vm_uuid(@compute_resource, @vm).any?
-          process_error(:error_msg => _("VM already associated with a host"), :redirect => compute_resource_vm_path(:compute_resource_id => params[:compute_resource_id], :id => proxmox_vm_id(@compute_resource, @vm)))
+          process_error(:error_msg => _("VM already associated with a host"),
+            :redirect => compute_resource_vm_path(:compute_resource_id => params[:compute_resource_id],
+              :id => proxmox_vm_id(@compute_resource, @vm)))
           return
         end
         host = @compute_resource.associated_host(@vm) if @compute_resource.respond_to?(:associated_host)
         if host.present?
           host.associate!(@compute_resource, @vm)
-          process_success(:success_msg => _("VM associated to host %s") % host.name, :success_redirect => host_path(host))
+          process_success(:success_msg => _("VM associated to host %s") % host.name,
+            :success_redirect => host_path(host))
         else
-          process_error(:error_msg => _("No host found to associate this VM with"), :redirect => compute_resource_vm_path(:compute_resource_id => params[:compute_resource_id], :id => proxmox_vm_id(@compute_resource, @vm)))
+          process_error(:error_msg => _("No host found to associate this VM with"),
+            :redirect => compute_resource_vm_path(:compute_resource_id => params[:compute_resource_id],
+              :id => proxmox_vm_id(@compute_resource, @vm)))
         end
       end
 
@@ -51,14 +56,15 @@ module ForemanFogProxmox
                  'hosts/console/log'
                end
       rescue StandardError => e
-        process_error :redirect => compute_resource_vm_path(@compute_resource, proxmox_vm_id(@compute_resource, @vm)), :error_msg => (_("Failed to set console: %s") % e), :object => @vm
+        process_error :redirect => compute_resource_vm_path(@compute_resource, proxmox_vm_id(@compute_resource, @vm)),
+          :error_msg => (_("Failed to set console: %s") % e), :object => @vm
       end
 
       private
 
       def proxmox_vm_id(compute_resource, vm)
         id = vm.identity
-        id = vm.unique_cluster_identity(compute_resource) if compute_resource.class == ForemanFogProxmox::Proxmox
+        id = vm.unique_cluster_identity(compute_resource) if compute_resource.instance_of?(ForemanFogProxmox::Proxmox)
         id
       end
 
@@ -69,11 +75,15 @@ module ForemanFogProxmox
         else
           error format(_("failed to %<action>s %<vm>s"), { :action => _(action), :vm => @vm })
         end
-        redirect_back(:fallback_location => compute_resource_vm_path(:compute_resource_id => params[:compute_resource_id], :id => proxmox_vm_id(@compute_resource, @vm)))
+        redirect_back(:fallback_location => compute_resource_vm_path(
+          :compute_resource_id => params[:compute_resource_id], :id => proxmox_vm_id(@compute_resource, @vm)
+        ))
       # This should only rescue Fog::Errors, but Fog returns all kinds of errors...
       rescue StandardError => e
         error format(_("Error - %<message>s"), { :message => _(e.message) })
-        redirect_back(:fallback_location => compute_resource_vm_path(:compute_resource_id => params[:compute_resource_id], :id => proxmox_vm_id(@compute_resource, @vm)))
+        redirect_back(:fallback_location => compute_resource_vm_path(
+          :compute_resource_id => params[:compute_resource_id], :id => proxmox_vm_id(@compute_resource, @vm)
+        ))
       end
     end
   end

data/app/controllers/concerns/foreman_fog_proxmox/controller/parameters/compute_resource.rb

@@ -27,7 +27,7 @@ module ForemanFogProxmox
           def compute_resource_params_filter
             super.tap do |filter|
               filter.permit :ssl_verify_peer,
-                            :ssl_certs, :disable_proxy, :auth_method, :token_id, :token
+                :ssl_certs, :disable_proxy, :auth_method, :token_id, :token
             end
           end
 

data/app/controllers/concerns/foreman_fog_proxmox/hosts_controller.rb

@@ -28,11 +28,16 @@ module ForemanFogProxmox
       # Clone the host
       def clone
         super
-        return true unless @host.compute_resource.class == ForemanFogProxmox::Proxmox
+        return true unless @host.compute_resource.instance_of?(ForemanFogProxmox::Proxmox)
 
         @host.compute_attributes[:vmid] = next_vmid
-        @host.compute_attributes[:interfaces_attributes].each { |index, interface_attributes| @host.compute_attributes[:interfaces_attributes][index] = interface_attributes.merge(macaddr: nil).merge(hwaddr: nil).merge(ip: nil).merge(ip6: nil) }
-        @host.compute_attributes[:volumes_attributes].each { |index, volume_attributes| @host.compute_attributes[:volumes_attributes][index] = volume_attributes.merge(volid: nil) }
+        @host.compute_attributes[:interfaces_attributes].each do |index, interface_attributes|
+          @host.compute_attributes[:interfaces_attributes][index] =
+            interface_attributes.merge(macaddr: nil).merge(hwaddr: nil).merge(ip: nil).merge(ip6: nil)
+        end
+        @host.compute_attributes[:volumes_attributes].each do |index, volume_attributes|
+          @host.compute_attributes[:volumes_attributes][index] = volume_attributes.merge(volid: nil)
+        end
       end
 
       private

data/app/controllers/foreman_fog_proxmox/compute_resources_controller.rb

@@ -21,7 +21,8 @@ module ForemanFogProxmox
   class ComputeResourcesController < ::ApplicationController
     # GET foreman_fog_proxmox/isos/:compute_resource_id/:node_id/:storage
     def isos_by_id_and_node_and_storage
-      volumes = load_compute_resource(params[:compute_resource_id]).images_by_storage(params[:node_id], params[:storage], 'iso')
+      volumes = load_compute_resource(params[:compute_resource_id]).images_by_storage(params[:node_id],
+        params[:storage], 'iso')
       respond_to do |format|
         format.json { render :json => volumes }
       end
@@ -29,7 +30,8 @@ module ForemanFogProxmox
 
     # GET foreman_fog_proxmox/ostemplates/:compute_resource_id/:node_id/:storage
     def ostemplates_by_id_and_node_and_storage
-      volumes = load_compute_resource(params[:compute_resource_id]).images_by_storage(params[:node_id], params[:storage], 'vztmpl')
+      volumes = load_compute_resource(params[:compute_resource_id]).images_by_storage(params[:node_id],
+        params[:storage], 'vztmpl')
       respond_to do |format|
         format.json { render :json => volumes }
       end
@@ -37,7 +39,8 @@ module ForemanFogProxmox
 
     # GET foreman_fog_proxmox/isos/:compute_resource_id/:node_id
     def isos_by_id_and_node
-      volumes = load_compute_resource(params[:compute_resource_id]).images_by_storage(params[:node_id], params[:storage], 'iso')
+      volumes = load_compute_resource(params[:compute_resource_id]).images_by_storage(params[:node_id],
+        params[:storage], 'iso')
       respond_to do |format|
         format.json { render :json => volumes }
       end

data/app/helpers/proxmox_compute_controllers_helper.rb

@@ -19,7 +19,8 @@
 
 module ProxmoxComputeControllersHelper
   def proxmox_controllers_map
-    proxmox_controllers_cloudinit_map << ForemanFogProxmox::OptionsSelect.new(name: 'VirtIO Block', id: 'virtio', range: 15)
+    proxmox_controllers_cloudinit_map << ForemanFogProxmox::OptionsSelect.new(name: 'VirtIO Block', id: 'virtio',
+      range: 15)
   end
 
   def proxmox_controllers_cloudinit_map

data/app/helpers/proxmox_compute_resources_helper.rb

@@ -21,9 +21,9 @@ module ProxmoxComputeResourcesHelper
   def user_token_expiration_date(compute_resource)
     expire = compute_resource.current_user_token_expire
   rescue ::Foreman::Exception => e
-    return 'Has already expired. Please edit the compute resource to set a new valid one.' if e.message == 'User token expired'
+    'Has already expired. Please edit the compute resource to set a new valid one.' if e.message == 'User token expired'
   rescue StandardError => e
-    logger.warn(format(_('failed to get identity client version: %<e>s'), e: e))
+    logger.warn("failed to get identity client version: #{e}")
     raise e
   else
     return 'Never' if expire == 0
@@ -36,7 +36,7 @@ module ProxmoxComputeResourcesHelper
   rescue ::Foreman::Exception => e
     return [] if e.message == 'User token expired'
   rescue StandardError => e
-    logger.warn(format(_('failed to get cluster nodes: %<e>s'), e: e))
+    logger.warn("failed to get cluster nodes: #{e}")
     raise e
   else
     nodes

data/app/helpers/proxmox_compute_resources_vms_helper.rb

@@ -20,7 +20,7 @@
 module ProxmoxComputeResourcesVmsHelper
   def proxmox_vm_id(compute_resource, vm)
     id = vm.identity
-    id = vm.unique_cluster_identity(compute_resource) if compute_resource.class == ForemanFogProxmox::Proxmox
+    id = vm.unique_cluster_identity(compute_resource) if compute_resource.instance_of?(ForemanFogProxmox::Proxmox)
     id
   end
 
@@ -32,7 +32,9 @@ module ProxmoxComputeResourcesVmsHelper
   end
 
   def vm_power_action(vm, authorizer = nil)
-    opts = hash_for_power_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => proxmox_vm_id(@compute_resource, vm)).merge(:auth_object => @compute_resource, :permission => 'power_compute_resources_vms', :authorizer => authorizer)
+    opts = hash_for_power_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => proxmox_vm_id(@compute_resource, vm)).merge(
+      :auth_object => @compute_resource, :permission => 'power_compute_resources_vms', :authorizer => authorizer
+    )
     html = power_action_html(vm)
 
     display_link_if_authorized "Power #{action_string(vm)}", opts, html.merge(:method => :put)
@@ -46,7 +48,8 @@ module ProxmoxComputeResourcesVmsHelper
         :id => proxmox_vm_id(@compute_resource, vm)
       ).merge(
         :auth_object => @compute_resource,
-        :permission => 'edit_compute_resources'),
+        :permission => 'edit_compute_resources'
+      ),
       :title => _('Associate VM to a Foreman host'),
       :method => :put,
       :class => 'btn btn-default'
@@ -62,7 +65,8 @@ module ProxmoxComputeResourcesVmsHelper
       hash_for_import_compute_resource_vm_path(
         :compute_resource_id => @compute_resource,
         :id => proxmox_vm_id(@compute_resource, vm),
-        :type => 'managed'),
+        :type => 'managed'
+      ),
       html_options
     )
     import_unmanaged_link = display_link_if_authorized(
@@ -70,7 +74,8 @@ module ProxmoxComputeResourcesVmsHelper
       hash_for_import_compute_resource_vm_path(
         :compute_resource_id => @compute_resource,
         :id => proxmox_vm_id(@compute_resource, vm),
-        :type => 'unmanaged'),
+        :type => 'unmanaged'
+      ),
       html_options
     )
 
@@ -88,12 +93,16 @@ module ProxmoxComputeResourcesVmsHelper
       ),
       {
         :id => 'console-button',
-        :class => 'btn btn-info'
+        :class => 'btn btn-info',
       }
     )
   end
 
   def vm_delete_action(vm, authorizer = nil)
-    display_delete_if_authorized(hash_for_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => proxmox_vm_id(@compute_resource, vm)).merge(:auth_object => @compute_resource, :authorizer => authorizer), :class => 'btn btn-danger')
+    display_delete_if_authorized(
+      hash_for_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => proxmox_vm_id(@compute_resource, vm)).merge(
+        :auth_object => @compute_resource, :authorizer => authorizer
+      ), :class => 'btn btn-danger'
+    )
   end
 end

data/app/helpers/proxmox_form_helper.rb

@@ -29,9 +29,11 @@ module ProxmoxFormHelper
         options[:value] = value if value.present?
         addClass options, 'form-control'
         pass = f.password_field(attr, options) +
-               tag(:span, '', class: 'glyphicon glyphicon-warning-sign input-addon', title: 'Caps lock ON', style: 'display:none')
+               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'))
+          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
@@ -53,10 +55,12 @@ module ProxmoxFormHelper
     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|
+    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]))
+          :locals => { options[:form_builder_local] => f }.merge(options[:form_builder_attrs]))
       end
     end
   end

data/app/helpers/proxmox_vm_config_helper.rb

@@ -25,28 +25,20 @@ 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) }
+    config = vm.config.attributes.reject do |key, _value|
+      main_a.include?(key) || Fog::Proxmox::DiskHelper.disk?(key) || Fog::Proxmox::NicHelper.nic?(key)
+    end
     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))
+    logger.debug("object_to_config_hash(#{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']
@@ -59,7 +51,7 @@ module ProxmoxVmConfigHelper
     main_a = ['name', 'type', 'node_id', 'vmid', 'interfaces', 'mount_points', 'disks']
     case type
     when 'lxc'
-      cpu_a = ['arch', 'cpulimit', 'cpuunits', 'cores', 'sockets']
+      cpu_a = ['arch', 'cpulimit', 'cpuunits']
       memory_a = ['memory', 'swap']
       ostemplate_a = ['ostemplate', 'ostemplate_storage', 'ostemplate_file']
       keys.store(:ostemplate, ostemplate_a)
@@ -76,10 +68,6 @@ module ProxmoxVmConfigHelper
     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
@@ -125,7 +113,9 @@ module ProxmoxVmConfigHelper
     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_config = config.reject do |key, value|
+      config_a(type).include?(key) || ForemanFogProxmox::Value.empty?(value)
+    end
     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)
@@ -134,26 +124,27 @@ module ProxmoxVmConfigHelper
   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
+    logger.debug("parse_typed_memory(#{type}): args=#{args}")
+    args
   end
 
   def parse_typed_cpu(args, type)
     cpu = {}
     ForemanFogProxmox::HashCollection.remove_empty_values(args)
-    if type == 'qemu'
+    case type
+    when '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 }
+    when 'lxc'
+      config_typed_keys('lxc')[:cpu].each do |key|
+        ForemanFogProxmox::HashCollection.add_and_format_element(cpu, key.to_sym, args, key)
+      end
     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

data/app/helpers/proxmox_vm_interfaces_helper.rb

@@ -35,8 +35,12 @@ module ProxmoxVmInterfacesHelper
     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) }
+    unless ForemanFogProxmox::Value.empty?(args['config_attributes'])
+      interfaces_attributes ||= args['config_attributes']['interfaces_attributes']
+    end
+    interfaces_attributes&.each_value do |value|
+      add_or_delete_typed_interface(value, interfaces_to_delete, interfaces_to_add, type)
+    end
     [interfaces_to_add, interfaces_to_delete]
   end
 
@@ -65,7 +69,9 @@ module ProxmoxVmInterfacesHelper
   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']
+    if interface_attributes['compute_attributes']
+      ForemanFogProxmox::HashCollection.remove_empty_values(interface_attributes['compute_attributes'])
+    end
     nic = {}
     id = interface_attributes['id']
     delete = interface_attributes['_delete'].to_i == 1
@@ -73,10 +79,17 @@ module ProxmoxVmInterfacesHelper
       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_common_typed_keys(type).each do |key|
+        ForemanFogProxmox::HashCollection.add_and_format_element(nic, key[:dest].to_sym, interface_attributes,
+          key[:origin])
+      end
       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) }
+      if ForemanFogProxmox::Value.empty?(interface_attributes['compute_attributes'])
+        interface_attributes_h ||= interface_attributes
+      end
+      interface_compute_attributes_typed_keys(type).each do |key|
+        ForemanFogProxmox::HashCollection.add_and_format_element(nic, key.to_sym, interface_attributes_h, key)
+      end
       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))

data/app/helpers/proxmox_vm_os_template_helper.rb

@@ -38,10 +38,7 @@ module ProxmoxVmOsTemplateHelper
   end
 
   def parse_container_ostemplate(args)
-    ostemplate = args['ostemplate']
-    ostemplate_file = args['ostemplate_file']
-    ostemplate ||= ostemplate_file
-    parsed_ostemplate = { ostemplate: ostemplate }
-    parsed_ostemplate
+    ostemplate = args['ostemplate'] || args['ostemplate_file']
+    { ostemplate: ostemplate }
   end
 end

data/app/helpers/proxmox_vm_uuid_helper.rb

@@ -18,7 +18,7 @@
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
 module ProxmoxVmUuidHelper
-  UUID_REGEXP = /(?<cluster_id>\d+)[_](?<vmid>\d+)/.freeze
+  UUID_REGEXP = /(?<cluster_id>\d+)_(?<vmid>\d+)/.freeze
   def extract(uuid, name)
     captures_h = uuid ? UUID_REGEXP.match(uuid.to_s) : { cluster_id: '', vmid: '' }
     captures_h ? captures_h[name] : ''