foreman_fog_proxmox 0.13.0 → 0.13.4

data/app/controllers/foreman_fog_proxmox/compute_resources_controller.rb

@@ -19,59 +19,57 @@
 
 module ForemanFogProxmox
   class ComputeResourcesController < ::ApplicationController
-    before_action :load_compute_resource
-
-    # GET foreman_fog_proxmox/isos/:node_id/:storage
-    def isos_by_node_and_storage
-      volumes = @compute_resource.images_by_storage(params[:node_id], params[:storage], 'iso')
+    # 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')
       respond_to do |format|
         format.json { render :json => volumes }
       end
     end
 
-    # GET foreman_fog_proxmox/ostemplates/:node_id/:storage
-    def ostemplates_by_node_and_storage
-      volumes = @compute_resource.images_by_storage(params[:node_id], params[:storage], 'vztmpl')
+    # 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')
       respond_to do |format|
         format.json { render :json => volumes }
       end
     end
 
-    # GET foreman_fog_proxmox/isos/:node_id
-    def isos_by_node
-      volumes = @compute_resource.images_by_storage(params[:node_id], params[:storage], 'iso')
+    # 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')
       respond_to do |format|
         format.json { render :json => volumes }
       end
     end
 
-    # GET foreman_fog_proxmox/ostemplates/:node_id
-    def ostemplates_by_node
-      storages = @compute_resource.storages(params[:node_id], 'vztmpl')
+    # GET foreman_fog_proxmox/ostemplates/:compute_resource_id/:node_id
+    def ostemplates_by_id_and_node
+      storages = load_compute_resource(params[:compute_resource_id]).storages(params[:node_id], 'vztmpl')
       respond_to do |format|
         format.json { render :json => storages }
       end
     end
 
-    # GET foreman_fog_proxmox/storages/:node_id
-    def storages_by_node
-      storages = @compute_resource.storages(params[:node_id])
+    # GET foreman_fog_proxmox/storages/:compute_resource_id/:node_id
+    def storages_by_id_and_node
+      storages = load_compute_resource(params[:compute_resource_id]).storages(params[:node_id])
       respond_to do |format|
         format.json { render :json => storages }
       end
     end
 
-    # GET foreman_fog_proxmox/isostorages/:node_id
-    def iso_storages_by_node
-      storages = @compute_resource.storages(params[:node_id], 'iso')
+    # GET foreman_fog_proxmox/isostorages/:compute_resource_id/:node_id
+    def iso_storages_by_id_and_node
+      storages = load_compute_resource(params[:compute_resource_id]).storages(params[:node_id], 'iso')
       respond_to do |format|
         format.json { render :json => storages }
       end
     end
 
-    # GET foreman_fog_proxmox/bridges/:node_id
-    def bridges_by_node
-      bridges = @compute_resource.bridges(params[:node_id])
+    # GET foreman_fog_proxmox/bridges/:compute_resource_id/:node_id
+    def bridges_by_id_and_node
+      bridges = load_compute_resource(params[:compute_resource_id]).bridges(params[:node_id])
       respond_to do |format|
         format.json { render :json => bridges }
       end
@@ -79,8 +77,8 @@ module ForemanFogProxmox
 
     private
 
-    def load_compute_resource
-      @compute_resource = ComputeResource.find_by(type: 'ForemanFogProxmox::Proxmox')
+    def load_compute_resource(compute_resource_id)
+      ComputeResource.find(compute_resource_id)
     end
   end
 end

data/app/helpers/proxmox_compute_resources_vms_helper.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Copyright 2021 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 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
+  end
+
+  def vm_host_action(vm)
+    host = Host.for_vm_uuid(@compute_resource, vm).first
+    return unless host
+
+    display_link_if_authorized(_("Host"), hash_for_host_path(:id => host), :class => 'btn btn-default')
+  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)
+    html = power_action_html(vm)
+
+    display_link_if_authorized "Power #{action_string(vm)}", opts, html.merge(:method => :put)
+  end
+
+  def vm_associate_action(vm)
+    display_link_if_authorized(
+      _('Associate VM'),
+      hash_for_associate_compute_resource_vm_path(
+        :compute_resource_id => @compute_resource,
+        :id => proxmox_vm_id(@compute_resource, vm)
+      ).merge(
+        :auth_object => @compute_resource,
+        :permission => 'edit_compute_resources'),
+      :title => _('Associate VM to a Foreman host'),
+      :method => :put,
+      :class => 'btn btn-default'
+    )
+  end
+
+  def vm_import_action(vm, html_options = {})
+    @_linked_hosts_cache ||= Host.where(:compute_resource_id => @compute_resource.id).pluck(:uuid)
+    return if @_linked_hosts_cache.include?(proxmox_vm_id(@compute_resource, vm).to_s)
+
+    import_managed_link = display_link_if_authorized(
+      _('Import as managed Host'),
+      hash_for_import_compute_resource_vm_path(
+        :compute_resource_id => @compute_resource,
+        :id => proxmox_vm_id(@compute_resource, vm),
+        :type => 'managed'),
+      html_options
+    )
+    import_unmanaged_link = display_link_if_authorized(
+      _('Import as unmanaged Host'),
+      hash_for_import_compute_resource_vm_path(
+        :compute_resource_id => @compute_resource,
+        :id => proxmox_vm_id(@compute_resource, vm),
+        :type => 'unmanaged'),
+      html_options
+    )
+
+    import_managed_link + import_unmanaged_link
+  end
+
+  def vm_console_action(vm)
+    return unless vm.ready?
+
+    link_to_if_authorized(
+      _('Console'),
+      hash_for_console_compute_resource_vm_path.merge(
+        :auth_object => @compute_resource,
+        :id => proxmox_vm_id(@compute_resource, vm)
+      ),
+      {
+        :id => 'console-button',
+        :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')
+  end
+end

data/app/helpers/proxmox_vm_config_helper.rb

@@ -31,7 +31,7 @@ module ProxmoxVmConfigHelper
 
   def object_to_config_hash(vm, type)
     vm_h = ActiveSupport::HashWithIndifferentAccess.new
-    main_a = ['hostname', 'name', 'vmid']
+    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) }
@@ -47,14 +47,15 @@ module ProxmoxVmConfigHelper
     config_hash.store(key, memory)
   end
 
-  def general_a
-    general_a = ['name', 'node_id', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
+  def general_a(type)
+    general_a = ['node_id', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
     general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
+    general_a += ['name'] if type == 'lxc'
     general_a
   end
 
   def config_typed_keys(type)
-    keys = { general: general_a }
+    keys = { general: general_a(type) }
     main_a = ['name', 'type', 'node_id', 'vmid', 'interfaces', 'mount_points', 'disks']
     case type
     when 'lxc'

data/app/helpers/proxmox_vm_uuid_helper.rb

@@ -0,0 +1,34 @@
+# 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 ProxmoxVmUuidHelper
+  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] : ''
+  end
+
+  def match_uuid?(uuid)
+    extract(uuid, :cluster_id) != ''
+  end
+
+  def extract_vmid(uuid)
+    extract(uuid, :vmid)
+  end
+end

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

@@ -23,6 +23,10 @@ module FogExtensions
       extend ActiveSupport::Concern
       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
+      end
+
       def start
         action('start')
       end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Copyright 2021 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 HostExt
+  module Proxmox
+    module Associator
+      extend ActiveSupport::Concern
+      included do
+        prepend Overrides
+      end
+      module Overrides
+        def associate!(cr, vm)
+          self.uuid = proxmox_vm_id(cr, vm)
+          self.compute_resource_id = cr.id
+          save!(:validate => false) # don't want to trigger callbacks
+        end
+
+        def proxmox_vm_id(compute_resource, vm)
+          id = vm.identity
+          id = vm.unique_cluster_identity(compute_resource) if compute_resource.class == 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))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright 2021 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 HostExt
+  module Proxmox
+    module ForVm
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def for_vm_uuid(cr, vm)
+          uuid = vm&.identity
+          uuid = cr.id.to_s + '_' + vm&.identity if cr.class == ForemanFogProxmox::Proxmox
+          where(:compute_resource_id => cr.id, :uuid => uuid)
+        end
+      end
+    end
+  end
+end

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

@@ -23,21 +23,79 @@ module Orchestration
       extend ActiveSupport::Concern
 
       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
+        if compute_resource.class != ForemanFogProxmox::Proxmox
+          super
+        else
+          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
+        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
       end
 
       def delComputeUpdate
-        logger.info "Undo Update Proxmox Compute instance for #{name}"
-        final_compute_attributes = old.compute_attributes.merge(compute_resource.host_compute_attrs(old))
-        compute_resource.save_vm uuid, final_compute_attributes
+        if compute_resource.class != ForemanFogProxmox::Proxmox
+          super
+        else
+          logger.info "Undo Update Proxmox Compute instance for #{name}"
+          final_compute_attributes = old.compute_attributes.merge(compute_resource.host_compute_attrs(old))
+          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
       end
+
+      def empty_provided_ips?(ip, ip6)
+        ip.blank? && ip6.blank? && (compute_provides?(:ip) || compute_provides?(:ip6))
+      end
+
+      def ips_keys
+        [:ip, :ip6]
+      end
+
+      def computeIp(foreman_attr, fog_attr)
+        vm.send(fog_attr) || find_address(foreman_attr)
+      end
+
+      def computeValue(foreman_attr, fog_attr)
+        value = ''
+        value += compute_resource.id.to_s + '_' if foreman_attr == :uuid
+        value += vm.send(fog_attr)
+        value
+      end
+
+      def setVmDetails
+        attrs = compute_resource.provided_attributes
+        result = true
+        attrs.each do |foreman_attr, fog_attr|
+          if foreman_attr == :mac
+            result = false unless match_macs_to_nics(fog_attr)
+          elsif ips_keys.include?(foreman_attr)
+            value = computeIp(foreman_attr, fog_attr)
+            send("#{foreman_attr}=", value)
+            result = false if send(foreman_attr).present? && !validate_foreman_attr(value, ::Nic::Base, foreman_attr)
+          else
+            value = computeValue(foreman_attr, fog_attr)
+            send("#{foreman_attr}=", value)
+            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)
+
+        result
+      end
+
+      def setComputeDetails
+        if compute_resource.class != ForemanFogProxmox::Proxmox
+          super
+        elsif vm
+          setVmDetails
+        else
+          failure format(_('failed to save %<name>s'), name: name)
+        end
+      end
     end
   end
 end

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -64,6 +64,10 @@ module ForemanFogProxmox
       associate_by('mac', vm.mac)
     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
+    end
+
     def ssl_certs
       attrs[:ssl_certs]
     end