foreman_fog_proxmox 0.11.1 → 0.13.0

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

@@ -35,8 +35,12 @@ module HostExt
         end
       end
 
-      def cidr_ip(interface_attributes)
-        Fog::Proxmox::IpHelper.to_cidr(interface_attributes['ip'], interface_attributes['compute_attributes']['cidr_suffix'])
+      def cidr_ip(interface_attributes, v = 4)
+        key_ip = 'ip'
+        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])
       end
 
       def add_interface_to_compute_attributes(index, interface_attributes, compute_attributes)
@@ -45,6 +49,7 @@ module HostExt
         compute_attributes[index].store('_delete', interface_attributes['_destroy'])
         compute_attributes[index].store('macaddr', interface_attributes['mac'])
         compute_attributes[index].store('ip', cidr_ip(interface_attributes))
+        compute_attributes[index].store('ip6', cidr_ip(interface_attributes, 6))
         compute_attributes[index].merge!(interface_attributes['compute_attributes'].reject { |k, _v| k == 'id' })
       end
     end

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

@@ -25,6 +25,7 @@ module Orchestration
       def setComputeUpdate
         logger.info "Update Proxmox Compute instance for #{name}"
         final_compute_attributes = compute_attributes.merge(compute_resource.host_compute_attrs(self))
+        logger.debug("setComputeUpdate: final_compute_attributes=#{final_compute_attributes}")
         compute_resource.save_vm uuid, final_compute_attributes
       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

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -24,10 +24,7 @@ require 'foreman_fog_proxmox/value'
 module ForemanFogProxmox
   class Proxmox < ComputeResource
     include ProxmoxVmHelper
-    include ProxmoxServerHelper
-    include ProxmoxContainerHelper
     include ProxmoxConnection
-    include ProxmoxTokenExpiration
     include ProxmoxVmNew
     include ProxmoxVmCommands
     include ProxmoxVmQueries
@@ -39,9 +36,11 @@ 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
-    before_create :test_connection
+    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(
@@ -95,35 +94,79 @@ module ForemanFogProxmox
       attrs[:ssl_verify_peer] = value
     end
 
-    def renew
-      attrs[:renew].blank? ? false : Foreman::Cast.to_bool(attrs[:renew])
+    def auth_method
+      attrs[:auth_method] || 'access_ticket'
     end
 
-    def renew=(value)
-      attrs[:renew] = value
+    def auth_method=(value)
+      attrs[:auth_method] = value
+    end
+
+    def token_id
+      attrs[:token_id]
+    end
+
+    def token_id=(value)
+      attrs[:token_id] = value
+    end
+
+    def token
+      attrs[:token]
+    end
+
+    def token=(value)
+      attrs[:token] = value
     end
 
     private
 
+    def fog_credentials
+      hash = {
+        proxmox_url: url,
+        proxmox_auth_method: auth_method || 'access_ticket',
+        connection_options: connection_options
+      }
+      if access_ticket?
+        hash[:proxmox_username] = user
+        hash[:proxmox_password] = password
+      end
+      if user_token?
+        hash[:proxmox_userid] = user
+        hash[:proxmox_token] = token
+        hash[:proxmox_tokenid] = token_id
+      end
+      hash
+    end
+
+    def token_expired?(e)
+      e.response.reason_phrase == 'token expired'
+    end
+
     def client
       @client ||= ::Fog::Proxmox::Compute.new(fog_credentials)
+    rescue Excon::Errors::Unauthorized => e
+      raise ::Foreman::Exception, 'User token expired' if token_expired?(e)
     rescue StandardError => e
-      logger.error(e)
-      raise ::Foreman::Exception, format(N_('Failed retrieving proxmox compute client caused by %<e>s'), e: e)
+      logger.warn(format(_('failed to create compute client: %<e>s'), e: e))
+      raise e
     end
 
     def identity_client
       @identity_client ||= ::Fog::Proxmox::Identity.new(fog_credentials)
+    rescue Excon::Errors::Unauthorized => e
+      raise ::Foreman::Exception, 'User token expired' if token_expired?(e)
     rescue StandardError => e
-      logger.error(e)
-      raise ::Foreman::Exception, format(N_('Failed retrieving proxmox identity client caused by %<e>s'), e: e)
+      logger.warn(format(_('failed to create identity client: %<e>s'), e: e))
+      raise e
     end
 
     def network_client
       @network_client ||= ::Fog::Proxmox::Network.new(fog_credentials)
+    rescue Excon::Errors::Unauthorized => e
+      raise ::Foreman::Exception, 'User token expired' if token_expired?(e)
     rescue StandardError => e
-      logger.error(e)
-      raise ::Foreman::Exception, format(N_('Failed retrieving proxmox network client caused by %<e>s'), e: e)
+      logger.warn(format(_('failed to create network client: %<e>s'), e: e))
+      raise e
     end
 
     def host

data/app/models/foreman_fog_proxmox/proxmox_compute_attributes.rb

@@ -20,30 +20,38 @@
 module ForemanFogProxmox
   module ProxmoxComputeAttributes
     def host_compute_attrs(host)
-      super.tap do |_attrs|
-        ostype = host.compute_attributes['config_attributes']['ostype']
-        type = host.compute_attributes['type']
-        case type
-        when 'lxc'
-          host.compute_attributes['config_attributes'].store('hostname', host.name)
-        when 'qemu'
-          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
+      ostype = host.compute_attributes['config_attributes']['ostype']
+      type = host.compute_attributes['type']
+      case type
+      when 'lxc'
+        host.compute_attributes['config_attributes'].store('hostname', host.name)
+      when 'qemu'
+        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
 
     def not_config_key?(vm, key)
       [:disks, :interfaces, :vmid, :node_id, :node, :type].include?(key) || !vm.config.respond_to?(key)
     end
 
+    def interface_compute_attributes(interface_attributes)
+      vm_attrs = ForemanFogProxmox::HashCollection.new_hash_reject_keys(interface_attributes, [:identifier, :mac])
+      vm_attrs[:dhcp] = interface_attributes[:ip] == 'dhcp' ? '1' : '0'
+      vm_attrs[:dhcp6] = interface_attributes[:ip6] == 'dhcp' ? '1' : '0'
+      vm_attrs
+    end
+
     def vm_compute_attributes(vm)
       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 = vm_attrs.merge(vmid: vm.identity, node_id: vm.node_id, type: vm.type)
         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.attributes] }] if vm.config.respond_to?(:interfaces)
+        if vm.config.respond_to?(:interfaces)
+          vm_attrs[:interfaces_attributes] = Hash[vm.config.interfaces.each_with_index.map { |interface, idx| [idx.to_s, interface_compute_attributes(interface.attributes)] }]
+        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

@@ -28,23 +28,28 @@ module ForemanFogProxmox
       opts
     end
 
-    def fog_credentials
-      credentials = { pve_url: url,
-                      pve_username: user,
-                      pve_password: password,
-                      connection_options: connection_options }
-      ticket = Fog::Proxmox.credentials[:ticket]
-      credentials.store(:pve_ticket, ticket) if renew
-      credentials
+    def access_ticket?
+      auth_method == 'access_ticket'
+    end
+
+    def user_token?
+      auth_method == 'user_token'
     end
 
     def credentials_valid?
-      errors[:url].empty? && errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_id].empty?
+      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?
+    end
+
+    def current_user_token_expire
+      identity_client ? identity_client.expires : 0
     end
 
     def test_connection(options = {})
       super
       credentials_valid?
+      identity_client
       version_suitable?
     rescue StandardError => e
       errors[:base] << e.message

data/app/models/foreman_fog_proxmox/proxmox_images.rb

@@ -27,6 +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))
       storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
@@ -40,7 +41,7 @@ module ForemanFogProxmox
         storage = storages(node.node).first
         volumes += storage.volumes.list_by_content_type('images')
       end
-      volumes.select(&:templated?)
+      volumes.select(&:template?)
     end
 
     def template(vmid)

data/app/models/foreman_fog_proxmox/proxmox_interfaces.rb

@@ -30,8 +30,14 @@ module ForemanFogProxmox
       raise ::Foreman::Exception, _(format('Invalid identifier interface[%<index>s]. Must be net[n] with n integer >= 0', index: index)) unless Fog::Proxmox::NicHelper.nic?(nic.identifier)
     end
 
+    def vm_type(host)
+      type = host.compute_attributes['type']
+      type ||= host.compute_attributes[:config_attributes].key?(:arch) ? 'lxc' : 'qemu'
+      type
+    end
+
     def container?(host)
-      host.compute_attributes['type'] == 'lxc'
+      vm_type(host) == 'lxc'
     end
 
     def container_nic_name_valid?(nic)
@@ -44,32 +50,46 @@ module ForemanFogProxmox
     end
 
     def cidr_prefix(nic_compute_attributes, v6 = false)
-      attr_name = 'cidrv'
-      attr_name += v6 ? '6' : '4'
-      attr_name += '_prefix'
-      nic_compute_attributes[attr_name] if nic_compute_attributes[attr_name].presence
+      attr_name = "cidr#{v6_s(v6)}"
+      nic_compute_attributes[attr_name] if nic_compute_attributes.key?(attr_name)
     end
 
-    def set_ip(host, nic, nic_compute_attributes, v6 = false)
-      return 'dhcp' if dhcp?(nic_compute_attributes, v6)
-
-      ip = v6 ? nic.ip6 : nic.ip
-      return ip unless container?(host) || cidr_prefix(nic_compute_attributes, v6)
+    def cidr_prefix_method(v6)
+      "cidr#{v6_s(v6)}_prefix?".to_sym
+    end
 
-      valid = v6 ? Fog::Proxmox::IpHelper.cidr6_prefix?(cidr_prefix(nic_compute_attributes, v6)) : Fog::Proxmox::IpHelper.cidr_prefix?(cidr_prefix(nic_compute_attributes, v6))
-      ipv = v6 ? 'IPv6' : 'IPv4'
+    def check_cidr(nic_compute_attributes, v6, ip)
+      valid = Fog::Proxmox::IpHelper.send(cidr_prefix_method(v6), cidr_prefix(nic_compute_attributes, v6))
+      ipv = "IPv#{v6 ? '6' : '4'}"
       max = v6 ? 128 : 32
-      unless valid
-        raise ::Foreman::Exception, _(format('Invalid Interface Proxmox CIDR %<ip>s. If %<ip>s is not empty, Proxmox CIDR prefix must be an integer between 0 and %<max>i.', ip: ipv, max: max))
-      end
+      checked = valid || ForemanFogProxmox::Value.empty?(ip)
+      message = format('Invalid Interface Proxmox CIDR %<ip>s. If %<ip>s is not empty, Proxmox CIDR prefix must be an integer between 0 and %<max>i.', ip: ipv, max: max)
+      raise ::Foreman::Exception, _(message) unless checked
+    end
 
-      v6 ? Fog::Proxmox::IpHelper.to_cidr6(nic.ip6, cidr_prefix(nic_compute_attributes, v6)) : Fog::Proxmox::IpHelper.to_cidr(nic.ip, cidr_prefix(nic_compute_attributes, v6))
+    def v6_s(v6)
+      v6 ? '6' : ''
     end
 
-    def set_gw(nic_compute_attributes, v6 = false)
-      attr_name = 'gwv'
-      attr_name += v6 ? '6' : '4'
-      nic_compute_attributes[attr_name] if nic_compute_attributes[attr_name].presence
+    def ip_s(v6)
+      "ip#{v6_s(v6)}"
+    end
+
+    def to_cidr_method(v6)
+      "to_cidr#{v6_s(v6)}".to_sym
+    end
+
+    def set_ip(host, nic, nic_compute_attributes, v6 = false)
+      ip = nic.send(ip_s(v6).to_sym)
+      if container?(host)
+        if dhcp?(nic_compute_attributes, v6)
+          ip = 'dhcp'
+        elsif !ForemanFogProxmox::Value.empty?(cidr_prefix(nic_compute_attributes, v6))
+          check_cidr(nic_compute_attributes, v6, ip)
+          ip = Fog::Proxmox::IpHelper.send(to_cidr_method(v6), nic.send(ip_s(v6).to_sym), cidr_prefix(nic_compute_attributes, v6)) if ip
+        end
+      end
+      nic_compute_attributes[ip_s(v6).to_sym] = ip
     end
 
     def to_boolean(value)
@@ -77,9 +97,14 @@ module ForemanFogProxmox
     end
 
     def dhcp?(nic_compute_attributes, v6 = false)
-      attr_name = 'dhcpv'
-      attr_name += v6 ? '6' : '4'
-      to_boolean(nic_compute_attributes[attr_name]) if nic_compute_attributes[attr_name].present?
+      attr_name = "dhcp#{v6_s(v6)}"
+      nic_compute_attributes.key?(attr_name) ? to_boolean(nic_compute_attributes[attr_name]) : false
+    end
+
+    def set_mac(nic_compute_attributes, mac, type)
+      mac_attr_name = { 'qemu' => :macaddr, 'lxc' => :hwaddr }
+      mac_key = mac_attr_name[type] || 'mac'
+      nic_compute_attributes[mac_key] = mac
     end
 
     def host_interfaces_attrs(host)
@@ -87,15 +112,15 @@ module ForemanFogProxmox
         set_nic_identifier(nic, index)
         set_container_interface_name(host, nic, index) if container?(host)
         nic_compute_attributes = nic.compute_attributes.merge(id: nic.identifier)
+        ForemanFogProxmox::HashCollection.remove_empty_values(nic_compute_attributes)
         mac = nic.mac
         mac ||= nic.attributes['mac']
-        nic_compute_attributes.store(:macaddr, mac) if mac.present?
+        set_mac(nic_compute_attributes, mac, vm_type(host)) if mac.present?
         interface_compute_attributes = host.compute_attributes['interfaces_attributes'] ? host.compute_attributes['interfaces_attributes'].select { |_k, v| v['id'] == nic.identifier } : {}
         nic_compute_attributes.store(:_delete, interface_compute_attributes[interface_compute_attributes.keys[0]]['_delete']) unless interface_compute_attributes.empty?
-        nic_compute_attributes.store(:ip, set_ip(host, nic, nic_compute_attributes))
-        nic_compute_attributes.store(:gw, set_gw(nic_compute_attributes))
-        nic_compute_attributes.store(:ip6, set_ip(host, nic, nic_compute_attributes, true))
-        nic_compute_attributes.store(:gw6, set_gw(nic_compute_attributes, true))
+        set_ip(host, nic, nic_compute_attributes)
+        set_ip(host, nic, nic_compute_attributes, true)
+        ForemanFogProxmox::HashCollection.remove_keys(nic_compute_attributes, ['dhcp', 'dhcp6', 'cidr', 'cidr6'])
         hash.merge(index.to_s => nic_compute_attributes)
       end
     end

data/app/models/foreman_fog_proxmox/proxmox_operating_systems.rb

@@ -39,7 +39,7 @@ module ForemanFogProxmox
     end
 
     def os_linux_types_mapping(host)
-      ['Debian', 'Redhat', 'Suse', 'Altlinux', 'Archlinux', 'CoreOs', 'Gentoo'].include?(host.operatingsystem.type) ? available_linux_operating_systems : []
+      ['Debian', 'Redhat', 'Suse', 'Altlinux', 'Archlinux', 'Coreos', 'Rancheros', 'Gentoo'].include?(host.operatingsystem.type) ? available_linux_operating_systems : []
     end
 
     def os_windows_types_mapping(host)

data/app/models/foreman_fog_proxmox/proxmox_version.rb

@@ -29,8 +29,13 @@ module ForemanFogProxmox
     end
 
     def version
-      v = identity_client.read_version
-      "#{v['version']}.#{v['release']}"
+      v = identity_client.read_version if identity_client
+      v ? v['version'] : 'Unknown'
+    rescue ::Foreman::Exception => e
+      return 'Unkown' if e.message == 'User token expired'
+    rescue StandardError => e
+      logger.warn(format(_('failed to get identity client version: %<e>s'), e: e))
+      raise e
     end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox_vm_commands.rb

@@ -17,10 +17,13 @@
 # You should have received a copy of the GNU General Public License
 # along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
+require 'foreman_fog_proxmox/hash_collection'
+
 module ForemanFogProxmox
   module ProxmoxVmCommands
     include ProxmoxVolumes
     include ProxmoxPools
+    include ProxmoxVmHelper
 
     def start_on_boot(vm, args)
       startonboot = args[:start_after_create].blank? ? false : Foreman::Cast.to_bool(args[:start_after_create])
@@ -32,6 +35,7 @@ module ForemanFogProxmox
       vmid = args[:vmid].to_i
       type = args[:type]
       node = client.nodes.get(args[:node_id])
+      vmid = node.servers.next_id.to_i if vmid < 1
       raise ::Foreman::Exception, format(N_('invalid vmid=%<vmid>s'), vmid: vmid) unless node.servers.id_valid?(vmid)
 
       image_id = args[:image_id]
@@ -39,15 +43,9 @@ module ForemanFogProxmox
         clone_from_image(image_id, args, vmid)
       else
         convert_sizes(args)
-        remove_deletes(args)
-        case type
-        when 'qemu'
-          vm = node.servers.create(parse_server_vm(args))
-        when 'lxc'
-          hash = parse_container_vm(args)
-          hash = hash.merge(vmid: vmid)
-          vm = node.containers.create(hash.reject { |key, _value| ['ostemplate_storage', 'ostemplate_file'].include? key })
-        end
+        remove_volume_keys(args)
+        logger.warn(format(_('create vm: args=%<args>s'), args: args))
+        vm = node.send(vm_collection(type)).create(parse_typed_vm(args, type))
         start_on_boot(vm, args)
       end
     rescue StandardError => e
@@ -69,24 +67,18 @@ module ForemanFogProxmox
       true
     end
 
-    def update_required?(old_attrs, new_attrs)
-      return true if super(old_attrs, new_attrs)
-
-      new_attrs[:interfaces_attributes]&.each do |key, interface|
-        return true if (interface[:id].blank? || interface[:_delete] == '1') && key != 'new_interfaces' # ignore the template
-      end
-
-      new_attrs[:volumes_attributes]&.each do |key, volume|
-        return true if (volume[:id].blank? || volume[:_delete] == '1') && key != 'new_volumes' # ignore the template
-      end
-
-      false
-    end
-
     def user_data_supported?
       true
     end
 
+    def compute_config_attributes(parsed_attr)
+      excluded_keys = [:vmid, :templated, :ostemplate, :ostemplate_file, :ostemplate_storage, :volumes_attributes, :pool]
+      config_attributes = parsed_attr.reject { |key, _value| excluded_keys.include? key.to_sym }
+      ForemanFogProxmox::HashCollection.remove_empty_values(config_attributes)
+      config_attributes = config_attributes.reject { |key, _value| Fog::Proxmox::DiskHelper.disk?(key) }
+      { config_attributes: config_attributes }
+    end
+
     def save_vm(uuid, new_attributes)
       vm = find_vm_by_uuid(uuid)
       templated = new_attributes['templated']
@@ -97,15 +89,12 @@ module ForemanFogProxmox
         vm.migrate(node_id)
       else
         convert_memory_sizes(new_attributes)
+        parsed_attr = parse_typed_vm(ForemanFogProxmox::HashCollection.new_hash_reject_keys(new_attributes, ['volumes_attributes']).merge(type: vm.type), vm.type)
+        config_attributes = compute_config_attributes(parsed_attr)
         volumes_attributes = new_attributes['volumes_attributes']
+        logger.debug(format(_('save_vm(%<vmid>s) volumes_attributes=%<volumes_attributes>s'), vmid: uuid, volumes_attributes: volumes_attributes))
         volumes_attributes&.each_value { |volume_attributes| save_volume(vm, volume_attributes) }
-        parsed_attr = vm.container? ? parse_container_vm(new_attributes.merge(type: vm.type)) : parse_server_vm(new_attributes.merge(type: vm.type))
-        logger.debug("parsed_attr=#{parsed_attr}")
-        config_attributes = parsed_attr.reject { |key, _value| [:vmid, :templated, :ostemplate, :ostemplate_file, :ostemplate_storage, :volumes_attributes, :pool].include? key.to_sym }
-        config_attributes = config_attributes.reject { |_key, value| ForemanFogProxmox::Value.empty?(value) }
-        cdrom_attributes = parsed_attr.select { |_key, value| Fog::Proxmox::DiskHelper.cdrom?(value.to_s) }
-        config_attributes = config_attributes.reject { |key, _value| Fog::Proxmox::DiskHelper.disk?(key) }
-        vm.update(config_attributes.merge(cdrom_attributes))
+        vm.update(config_attributes[:config_attributes])
         poolid = new_attributes['pool'] if new_attributes.key?('pool')
         update_pool(vm, poolid) if poolid
       end