foreman_fog_proxmox 0.13.4 → 0.14.1

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] : ''

data/app/helpers/proxmox_vm_volumes_helper.rb

@@ -26,33 +26,37 @@ require 'foreman_fog_proxmox/hash_collection'
 module ProxmoxVmVolumesHelper
   include ProxmoxVmCdromHelper
   include ProxmoxVmCloudinitHelper
-  KILO = 1024
-  MEGA = KILO * KILO
-  GIGA = KILO * MEGA
 
   def add_disk_options(disk, args)
-    options = ForemanFogProxmox::HashCollection.new_hash_reject_keys(args, ['id', 'volid', 'controller', 'device', 'storage', 'size', '_delete', 'storage_type'])
+    options = ForemanFogProxmox::HashCollection.new_hash_reject_keys(args,
+      ['id', 'volid', 'controller', 'device', 'storage', 'size', '_delete', 'storage_type'])
     ForemanFogProxmox::HashCollection.remove_empty_values(options)
     disk[:options] = options
   end
 
   def parsed_typed_volumes(args, type, parsed_vm)
-    logger.debug(format(_('parsed_typed_volumes(%<type>s): args=%<args>s'), args: args, type: type))
+    logger.debug("parsed_typed_volumes(#{type}): args=#{args}")
     volumes_attributes = args['volumes_attributes']
-    volumes_attributes ||= args['config_attributes']['volumes_attributes'] unless ForemanFogProxmox::Value.empty?(args['config_attributes'])
-    volumes_attributes ||= args['vm_attrs']['volumes_attributes'] unless ForemanFogProxmox::Value.empty?(args['vm_attrs'])
+    unless ForemanFogProxmox::Value.empty?(args['config_attributes'])
+      volumes_attributes ||= args['config_attributes']['volumes_attributes']
+    end
+    unless ForemanFogProxmox::Value.empty?(args['vm_attrs'])
+      volumes_attributes ||= args['vm_attrs']['volumes_attributes']
+    end
     volumes = parse_typed_volumes(volumes_attributes, type)
     volumes.each { |volume| parsed_vm = parsed_vm.merge(volume) }
     parsed_vm
   end
 
   def parse_hard_disk_volume(args)
+    logger.debug(format(_('parse_hard_disk_volume(): args=%<args>s'), args: args))
     disk = {}
     disk[:id] = args['id'] if args.key?('id')
     disk[:volid] = args['volid'] if args.key?('volid')
     disk[:storage] = args['storage'].to_s if args.key?('storage')
     disk[:size] = args['size'].to_i if args.key?('size')
-    add_disk_options(disk, args)
+    add_disk_options(disk, args) unless args.key?('options')
+    disk[:options] = args['options'] if args.key?('options')
     disk.key?(:storage) ? disk : {}
   end
 
@@ -67,11 +71,12 @@ module ProxmoxVmVolumesHelper
   end
 
   def parse_typed_volume(args, type)
-    logger.debug(format(_('parse_typed_volume(%<type>s): args=%<args>s'), args: args, type: type))
-    disk = parse_hard_disk_volume(args) if volume_type?(args, 'hard_disk') || volume_type?(args, 'mp') || volume_type?(args, 'rootfs')
+    logger.debug("parse_typed_volume(#{type}): args=#{args}")
+    disk = parse_hard_disk_volume(args) if volume_type?(args,
+      'hard_disk') || volume_type?(args, 'mp') || volume_type?(args, 'rootfs')
     disk = parse_server_cloudinit(args) if volume_type?(args, 'cloud_init')
     disk = parse_server_cdrom(args) if volume_type?(args, 'cdrom')
-    logger.debug(format(_('parse_typed_volume(%<type>s): disk=%<disk>s'), disk: disk, type: type))
+    logger.debug("parse_typed_volume(#{type}): disk=#{disk}")
     Fog::Proxmox::DiskHelper.flatten(disk) unless disk.empty?
   end
 
@@ -81,25 +86,17 @@ module ProxmoxVmVolumesHelper
   end
 
   def parse_typed_volumes(args, type)
-    logger.debug(format(_('parse_typed_volumes(%<type>s): args=%<args>s'), args: args, type: type))
+    logger.debug("parse_typed_volumes(#{type}): args=#{args}")
     volumes = []
     args&.each_value { |value| add_typed_volume(volumes, value, type) }
     volumes
   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_volume_keys(args)
-    args['volumes_attributes'].each_value { |volume_attributes| ForemanFogProxmox::HashCollection.remove_keys(volume_attributes, ['_delete']) } if args.key?('volumes_attributes')
+    if args.key?('volumes_attributes')
+      args['volumes_attributes'].each_value do |volume_attributes|
+        ForemanFogProxmox::HashCollection.remove_keys(volume_attributes, ['_delete'])
+      end
+    end
   end
 end

data/app/models/concerns/fog_extensions/proxmox/node.rb

@@ -22,7 +22,7 @@ module FogExtensions
     module Node
       extend ActiveSupport::Concern
 
-      def each(collection_filters = {})
+      def each(collection_filters = {}, &block)
         if block_given?
           Kernel.loop do
             break unless collection_filters[:marker]
@@ -31,7 +31,7 @@ module FogExtensions
             # We need to explicitly use the base 'each' method here on the page,
             #  otherwise we get infinite recursion
             base_each = Fog::Collection.instance_method(:each)
-            base_each.bind(page).call { |item| yield item }
+            base_each.bind(page).call(&block)
           end
         end
         self

data/app/models/concerns/fog_extensions/proxmox/server.rb

@@ -24,7 +24,7 @@ module FogExtensions
       attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password, :start_after_create
 
       def unique_cluster_identity(compute_resource)
-        compute_resource.id.to_s + '_' + identity
+        compute_resource.id.to_s + '_' + identity.to_s
       end
 
       def start
@@ -59,11 +59,12 @@ module FogExtensions
       delegate :description, to: :config
 
       def vm_description
-        format(_('Type %<type>s, node %<node>s, %<cpus>s CPUs and %<memory>s MB memory'), type: type, node: node_id, cpus: config.cores || '0', memory: config.memory / (1024 * 1024) || '0')
+        format(_('Type %<type>s, node %<node>s, %<cpus>s CPUs and %<memory>s MB memory'),
+          type: type, node: node_id, cpus: config.cores || '0', memory: config.memory)
       end
 
       def select_nic(fog_nics, nic)
-        fog_nics.find { |fog_nic| fog_nic.identity.to_s == nic.identifier }
+        fog_nics.find { |fog_nic| fog_nic.identity.to_s == nic.compute_attributes[:id] }
       end
 
       delegate :interfaces, to: :config
@@ -84,11 +85,14 @@ module FogExtensions
       delegate :pool, to: :config
       delegate :cloud_init?, to: :config
 
-      def interfaces_attributes=(attrs); end
+      def interfaces_attributes=(attrs)
+      end
 
-      def volumes_attributes=(attrs); end
+      def volumes_attributes=(attrs)
+      end
 
-      def config_attributes=(attrs); end
+      def config_attributes=(attrs)
+      end
 
       def templated?
         volumes.any?(&:template?)

data/app/models/concerns/host_ext/proxmox/associator.rb

@@ -33,13 +33,14 @@ module HostExt
 
         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
       end
 
       def for_vm_uuid(cr, vm)
-        where(:compute_resource_id => cr.id, :uuid => Array.wrap(vm).compact.map(cr.id.to_s + '_' + vm&.identity).map(&:to_s))
+        where(:compute_resource_id => cr.id,
+          :uuid => Array.wrap(vm).compact.map(cr.id.to_s + '_' + vm&.identity).map(&:to_s))
       end
     end
   end

data/app/models/concerns/host_ext/proxmox/for_vm.rb

@@ -24,7 +24,7 @@ module HostExt
       module ClassMethods
         def for_vm_uuid(cr, vm)
           uuid = vm&.identity
-          uuid = cr.id.to_s + '_' + vm&.identity if cr.class == ForemanFogProxmox::Proxmox
+          uuid = cr.id.to_s + '_' + vm&.identity.to_s if cr.instance_of?(ForemanFogProxmox::Proxmox)
           where(:compute_resource_id => cr.id, :uuid => uuid)
         end
       end

data/app/models/concerns/host_ext/proxmox/interfaces.rb

@@ -24,14 +24,17 @@ module HostExt
     module Interfaces
       extend ActiveSupport::Concern
       def update(attributes = {})
-        add_interfaces_to_compute_attributes(attributes) if provider == 'Proxmox' && !attributes.nil? && attributes.key?('compute_attributes')
+        if provider == 'Proxmox' && !attributes.nil? && attributes.key?('compute_attributes')
+          add_interfaces_to_compute_attributes(attributes)
+        end
         super(attributes)
       end
 
       def add_interfaces_to_compute_attributes(attributes)
         attributes['compute_attributes'].store('interfaces_attributes', {})
         attributes['interfaces_attributes'].each do |index, interface_attributes|
-          add_interface_to_compute_attributes(index, interface_attributes, attributes['compute_attributes']['interfaces_attributes'])
+          add_interface_to_compute_attributes(index, interface_attributes,
+            attributes['compute_attributes']['interfaces_attributes'])
         end
       end
 
@@ -40,7 +43,8 @@ module HostExt
         key_ip += '6' if v == 6
         key_cidr = 'cidr'
         key_cidr += '6' if v == 6
-        Fog::Proxmox::IpHelper.to_cidr(interface_attributes[key_ip], interface_attributes['compute_attributes'][key_cidr])
+        Fog::Proxmox::IpHelper.to_cidr(interface_attributes[key_ip],
+          interface_attributes['compute_attributes'][key_cidr])
       end
 
       def add_interface_to_compute_attributes(index, interface_attributes, compute_attributes)

data/app/models/concerns/orchestration/proxmox/compute.rb

@@ -32,7 +32,8 @@ module Orchestration
           compute_resource.save_vm uuid, final_compute_attributes
         end
       rescue StandardError => e
-        failure format(_('Failed to update a compute %<compute_resource>s instance %<name>s: %<e>s'), :compute_resource => compute_resource, :name => name, :e => e), e
+        failure format(_('Failed to update a compute %<compute_resource>s instance %<name>s: %<e>s'), :compute_resource => compute_resource, :name => name, :e => e),
+          e
       end
 
       def delComputeUpdate
@@ -44,7 +45,8 @@ module Orchestration
           compute_resource.save_vm uuid, final_compute_attributes
         end
       rescue StandardError => e
-        failure format(_('Failed to undo update compute %<compute_resource>s instance %<name>s: %<e>s'), :compute_resource => compute_resource, :name => name, :e => e), e
+        failure format(_('Failed to undo update compute %<compute_resource>s instance %<name>s: %<e>s'), :compute_resource => compute_resource, :name => name, :e => e),
+          e
       end
 
       def empty_provided_ips?(ip, ip6)
@@ -62,7 +64,7 @@ module Orchestration
       def computeValue(foreman_attr, fog_attr)
         value = ''
         value += compute_resource.id.to_s + '_' if foreman_attr == :uuid
-        value += vm.send(fog_attr)
+        value += vm.send(fog_attr).to_s
         value
       end
 
@@ -82,7 +84,12 @@ module Orchestration
             result = false unless validate_required_foreman_attr(value, Host, foreman_attr)
           end
         end
-        return failure(format(_('Failed to acquire IP addresses from compute resource for %<name>s'), name: name)) if empty_provided_ips?(ip, ip6)
+        if empty_provided_ips?(
+          ip, ip6
+        )
+          return failure(format(_('Failed to acquire IP addresses from compute resource for %<name>s'),
+            name: name))
+        end
 
         result
       end

data/app/models/foreman_fog_proxmox/options_select.rb

@@ -19,9 +19,7 @@
 
 module ForemanFogProxmox
   class OptionsSelect
-    attr_accessor :id
-    attr_accessor :name
-    attr_accessor :range
+    attr_accessor :id, :name, :range
 
     def to_s
       id

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -36,11 +36,12 @@ module ForemanFogProxmox
     include ProxmoxVersion
     include ProxmoxConsole
     validates :url, :format => { :with => URI::DEFAULT_PARSER.make_regexp }, :presence => true
-    validates :auth_method, :presence => true, inclusion: { in: ['access_ticket', 'user_token'], message: ->(value) do format('%<value>s is not a valid authentication method', { value: value }) end }
-    validates :user, :format => { :with => /(\w+)[@]{1}(\w+)/ }, :presence => true
-    validates :password, :presence => true, if: :access_ticket?
-    validates :token_id, :presence => true, if: :user_token?
-    validates :token, :presence => true, if: :user_token?
+    validates :auth_method, :presence => true, :inclusion => { in: ['access_ticket', 'user_token'],
+      message: ->(value) do format('%<value>s is not a valid authentication method', { value: value }) end }
+    validates :user, :format => { :with => /(\w+)@{1}(\w+)/ }, :presence => true
+    validates :password, :presence => true, :if => :access_ticket?
+    validates :token_id, :presence => true, :if => :user_token?
+    validates :token, :presence => true, :if => :user_token?
 
     def provided_attributes
       super.merge(
@@ -65,7 +66,8 @@ module ForemanFogProxmox
     end
 
     def associate_by(name, attributes)
-      Host.authorized(:view_hosts, Host).joins(:primary_interface).where(:nics => { :primary => true }).where("nics.#{name}" => attributes).readonly(false).first
+      Host.authorized(:view_hosts,
+        Host).joins(:primary_interface).where(:nics => { :primary => true }).where("nics.#{name}".downcase => attributes.downcase).readonly(false).first
     end
 
     def ssl_certs
@@ -128,7 +130,7 @@ module ForemanFogProxmox
       hash = {
         proxmox_url: url,
         proxmox_auth_method: auth_method || 'access_ticket',
-        connection_options: connection_options
+        connection_options: connection_options,
       }
       if access_ticket?
         hash[:proxmox_username] = user
@@ -151,7 +153,7 @@ module ForemanFogProxmox
     rescue Excon::Errors::Unauthorized => e
       raise ::Foreman::Exception, 'User token expired' if token_expired?(e)
     rescue StandardError => e
-      logger.warn(format(_('failed to create compute client: %<e>s'), e: e))
+      logger.warn("failed to create compute client: #{e}")
       raise e
     end
 
@@ -160,7 +162,7 @@ module ForemanFogProxmox
     rescue Excon::Errors::Unauthorized => e
       raise ::Foreman::Exception, 'User token expired' if token_expired?(e)
     rescue StandardError => e
-      logger.warn(format(_('failed to create identity client: %<e>s'), e: e))
+      logger.warn("failed to create identity client: #{e}")
       raise e
     end
 
@@ -169,7 +171,7 @@ module ForemanFogProxmox
     rescue Excon::Errors::Unauthorized => e
       raise ::Foreman::Exception, 'User token expired' if token_expired?(e)
     rescue StandardError => e
-      logger.warn(format(_('failed to create network client: %<e>s'), e: e))
+      logger.warn("failed to create network client: #{e}")
       raise e
     end
 

data/app/models/foreman_fog_proxmox/proxmox_compute_attributes.rb

@@ -27,7 +27,11 @@ module ForemanFogProxmox
         host.compute_attributes['config_attributes'].store('hostname', host.name)
       when 'qemu'
         host.compute_attributes['config_attributes'].store('name', host.name)
-        raise ::Foreman::Exception, format(_('Operating system family %<type>s is not consistent with %<ostype>s'), type: host.operatingsystem.type, ostype: ostype) unless compute_os_types(host).include?(ostype)
+        unless compute_os_types(host).include?(ostype)
+          raise ::Foreman::Exception,
+            format(_('Operating system family %<type>s is not consistent with %<ostype>s'), type: host.operatingsystem.type,
+ostype: ostype)
+        end
       end
       super
     end
@@ -47,8 +51,16 @@ module ForemanFogProxmox
       vm_attrs = {}
       vm_attrs = vm_attrs.merge(vmid: vm.identity, node_id: vm.node_id, type: vm.type)
       if vm.respond_to?(:config)
-        vm_attrs[:volumes_attributes] = Hash[vm.config.disks.each_with_index.map { |disk, idx| [idx.to_s, disk.attributes] }] if vm.config.respond_to?(:disks)
-        vm_attrs[:interfaces_attributes] = Hash[vm.config.interfaces.each_with_index.map { |interface, idx| [idx.to_s, interface_compute_attributes(interface.attributes)] }] if vm.config.respond_to?(:interfaces)
+        if vm.config.respond_to?(:disks)
+          vm_attrs[:volumes_attributes] = Hash[vm.config.disks.each_with_index.map do |disk, idx|
+                                                 [idx.to_s, disk.attributes]
+                                               end ]
+        end
+        if vm.config.respond_to?(:interfaces)
+          vm_attrs[:interfaces_attributes] = Hash[vm.config.interfaces.each_with_index.map do |interface, idx|
+                                                    [idx.to_s, interface_compute_attributes(interface.attributes)]
+                                                  end ]
+        end
         vm_attrs[:config_attributes] = vm.config.attributes.reject do |key, value|
           not_config_key?(vm, key) || ForemanFogProxmox::Value.empty?(value.to_s) || Fog::Proxmox::DiskHelper.disk?(key.to_s) || Fog::Proxmox::NicHelper.nic?(key.to_s)
         end

data/app/models/foreman_fog_proxmox/proxmox_connection.rb

@@ -38,8 +38,12 @@ module ForemanFogProxmox
 
     def credentials_valid?
       errors[:url].empty? && errors[:auth_method].empty?
-      errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_id].empty? if access_ticket?
-      errors[:user].empty? && errors[:user].include?('@') && errors[:token_id].empty? && errors[:token].empty? && errors[:node_id].empty? if user_token?
+      if access_ticket?
+        errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_id].empty?
+      end
+      if user_token?
+        errors[:user].empty? && errors[:user].include?('@') && errors[:token_id].empty? && errors[:token].empty? && errors[:node_id].empty?
+      end
     end
 
     def current_user_token_expire

data/app/models/foreman_fog_proxmox/proxmox_console.rb

@@ -31,7 +31,9 @@ module ForemanFogProxmox
       options.store(:websocket, 1) if type_console == 'vnc'
       begin
         vnc_console = vm.start_console(options)
-        WsProxy.start(:host => host, :host_port => vnc_console['port'], :password => vnc_console['ticket']).merge(:name => vm.name, :type => type_console)
+        WsProxy.start(:host => host, :host_port => vnc_console['port'], :password => vnc_console['ticket']).merge(
+          :name => vm.name, :type => type_console
+        )
       rescue StandardError => e
         logger.error(e)
         raise ::Foreman::Exception, _('%<s>s console is not supported at this time') % type_console

data/app/models/foreman_fog_proxmox/proxmox_images.rb

@@ -27,7 +27,7 @@ module ForemanFogProxmox
       node = client.nodes.get node_id
       node ||= default_node
       storage = node.storages.get storage_id if storage_id
-      logger.debug(format(_('images_by_storage(): node_id %<node_id>s storage_id %<storage_id>s type %<type>s'), node_id: node_id, storage_id: storage_id, type: type))
+      logger.debug("images_by_storage(): node_id #{node_id} storage_id #{storage_id} type #{type}")
       storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
@@ -58,7 +58,7 @@ module ForemanFogProxmox
     end
 
     def clone_from_image(image_id, args, vmid)
-      logger.debug(format(_('create_vm(): clone %<image_id>s in %<vmid>s'), image_id: image_id, vmid: vmid))
+      logger.debug("create_vm(): clone #{image_id} in #{vmid}")
       image = find_vm_by_uuid(image_id)
       image.clone(vmid)
       clone = find_vm_by_uuid(id.to_s + '_' + vmid.to_s)