foreman_fog_proxmox 0.9.4 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c422b2ba09e7b1cd71a0dec7ec72398c71f4653a0b8386d4949ea15932df346
-  data.tar.gz: e870f6684243b1a7f7ee061648d0ad6efd1a1e51a466861f2c1e60f13bc6bc10
+  metadata.gz: 8d5a92b97ae63b9983d1e09d466c72be641abac13618416b3f9f9bc4adf9fe59
+  data.tar.gz: 44d499507243f4f78910adfdfd566e4fff153dd8b3b4783be1727d905fb9633b
 SHA512:
-  metadata.gz: eede4a7f2e4a098e90737ba71c389d979254720fbd876d5a5c73e792302fc6b59a69e37ec8736fa4fd31da982384b6bde8bd9651131ec71035338460c6bb4c26
-  data.tar.gz: 315fc305b50d96704ac6637d9a8689af9cc7d43ec93afe0c2804755b2b14a35183754a212be2f33cec25c1b37c0b124e9c20f0e0ed12a397560749115c88907c
+  metadata.gz: 61df6f0b8aa1caba1c31ad6c696093f3d92d8900d32e01985a671372b8f3503ee3d3752fd930b7a518dc2cd9a1b6eb56d92255fa5c19ff27eff049c2bfef6ff9
+  data.tar.gz: acac445ca9f9ee687c440707da9fab8e26e35afc455b29a14f325bcc5a42768f263edb5f6def86eb24acfa583658a5cd70729c40e3f86d5f9c740ec3f4555c4e

data/app/assets/javascripts/foreman_fog_proxmox/proxmox_vm.js

@@ -96,3 +96,92 @@ function toggleFieldset(fieldset, index, fieldsets){
       break;
   }
 }
+
+function nodeSelected(item) {
+  var node_id = $(item).val();
+  var type = $("#host_compute_attributes_type").val();
+  if (type == undefined) type = $("#compute_attribute_vm_attrs_type").val();
+  switch (type) {
+    case 'qemu':
+      updateOptions('isostorages', 'compute_attributes_config_attributes', 'cdrom_storage', 'compute_attributes_config_attributes', 'cdrom_iso', 'storage', node_id);
+      updateOptions('storages', 'compute_attributes_volumes_attributes', 'storage', undefined, undefined, 'storage', node_id);
+      updateOptions('bridges', 'interfaces_attributes', 'compute_attributes_bridge', undefined, undefined, 'iface', node_id);
+      break;
+    case 'lxc':
+      updateOptions('ostemplates', 'compute_attributes_ostemplate', 'storage', 'compute_attributes_ostemplate', 'file', 'storage', node_id);
+      updateOptions('storages', 'compute_attributes_volumes_attributes', 'storage', undefined, undefined, 'storage', node_id);
+      updateOptions('bridges', 'interfaces_attributes', 'compute_attributes_bridge', undefined, undefined, 'iface', node_id);
+      break;
+    default:
+      console.log("unkown type=" + type);
+      break;
+  }
+}
+
+function emptySelect(select){
+  $(select).empty();
+  $(select).append($("<option></option>").val('').text(''));
+  $(select).val('');
+}
+
+function initOptions(select_ids){
+  console.log('initOptions(' + select_ids[0] + ')');
+  select_ids.forEach(emptySelect);
+  select_ids.forEach(function(select){
+    $(select + ' option:selected').prop('selected',false);
+    $(select).val('');
+  });
+}
+
+function updateOption(select_id, option, option_id){
+  console.log('update '+ select_id + ' with '+ option[option_id]);
+  $(select_id).append($('<option></option>').val(option[option_id]).text(option[option_id]));
+}
+
+function selectIds(start_options_id, end_options_id){
+  let select_host_id = 'select[id^=host_' + start_options_id + ']';
+  let compute_attributes_regex = /compute_attributes_/gi;
+  let select_profile_id = 'select[id^=compute_attribute_vm_attrs_' + start_options_id.replace(compute_attributes_regex, '') + ']';
+  if (end_options_id != undefined) {
+    select_host_id += '[id$=' + end_options_id + ']';
+    select_profile_id += '[id$=' + end_options_id.replace(compute_attributes_regex, '') + ']';
+  }
+  return [select_host_id, select_profile_id];
+}
+
+function updateOptions(options_path, start_options_id, end_options_id, start_second_options_id, end_second_options_id, option_id, node_id, second_id = undefined) {
+  
+  let select_ids = selectIds(start_options_id, end_options_id);
+  let select_second_ids;
+  if ( start_second_options_id != undefined && end_second_options_id != undefined) {
+    select_second_ids = selectIds(start_second_options_id, end_second_options_id);
+  }
+  var url = '/foreman_fog_proxmox/' + options_path +  '/' + node_id;
+  if (second_id != undefined) url += '/' + second_id;
+  tfm.tools.showSpinner();
+  $.getJSON({
+    type: 'get',
+    url: url,
+    error: function(j,status,error){
+      var errorMsg = 'Error=' + error + ', status=' + status + ' loading ' + options_path + ' for node_id=' + node_id;
+      if (second_id != undefined) errorMsg += ' and second_id=' + second_id;
+      console.log(errorMsg);
+    },
+    success: function(options) {
+      initOptions(select_ids);
+      if (select_second_ids != undefined) {
+        initOptions(select_second_ids);
+      }
+      $.each(options, function(i,option){
+        for (let j = 0; j < select_ids.length; j++) {
+          updateOption(select_ids[j], option, option_id);
+        }
+      });
+    },
+    complete: function(item){
+      // eslint-disable-next-line no-undef
+      reloadOnAjaxComplete(item);
+      tfm.tools.hideSpinner();
+    }
+  });
+}

data/app/assets/javascripts/foreman_fog_proxmox/proxmox_vm_container.js

@@ -15,46 +15,10 @@
 // You should have received a copy of the GNU General Public License
 // along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
 
-function initOstemplateStorage(){
-    var select = '#host_compute_attributes_ostemplate_storage';
-    $(select + ' option:selected').prop('selected',false);
-    $(select).val('');
-  }
-  
-  function initOstemplateOptions(){
-    var select_ids = ['#host_compute_attributes_ostemplate_file','#compute_attribute_vm_attrs_ostemplate_file'];
-    select_ids.forEach(emptySelect);
-  }
-
-  function emptySelect(select, index, select_ids){
-    $(select).empty();
-    $(select).append($("<option></option>").val('').text(''));
-    $(select).val('');
-  }
-
 
 function storageOstemplateSelected(item) {
-    var storage = $(item).val();
-    if (storage != '') {
-      tfm.tools.showSpinner();
-      $.getJSON({
-        type: 'get',
-        url: '/foreman_fog_proxmox/ostemplates/'+storage,
-        complete: function(){
-          tfm.tools.hideSpinner();
-        },
-        error: function(j,status,error){
-          console.log("Error=" + error +", status=" + status + " loading os templates for storage=" + storage);
-        },
-        success: function(ostemplates) {
-          initOstemplateOptions();
-          $.each(ostemplates, function(i,ostemplate){
-            $('#host_compute_attributes_ostemplate_file').append($("<option></option>").val(ostemplate.volid).text(ostemplate.volid));
-            $('#compute_attribute_vm_attrs_ostemplate_file').append($("<option></option>").val(ostemplate.volid).text(ostemplate.volid));
-          });
-        }
-      });
-    } else {
-      initOstemplateOptions();
-    }
-  }
+  var storage = $(item).val();
+  var node_id = $('#host_compute_attributes_node_id').val();
+  if (node_id == undefined) node_id = $("#compute_attribute_vm_attrs_node_id").val();
+  updateOptions('ostemplates', 'compute_attributes_ostemplate', 'file', undefined, undefined, 'volid', node_id, storage);
+}

data/app/assets/javascripts/foreman_fog_proxmox/proxmox_vm_server.js

@@ -56,27 +56,8 @@ function initCdromOptions(name) {
 
 function storageIsoSelected(item) {
   var storage = $(item).val();
-  if (storage != '') {
-    tfm.tools.showSpinner();
-    $.getJSON({
-      type: 'get',
-      url: '/foreman_fog_proxmox/isos/' + storage,
-      complete: function () {
-        tfm.tools.hideSpinner();
-      },
-      error: function (j, status, error) {
-        console.log("Error=" + error + ", status=" + status + " loading isos for storage=" + storage);
-      },
-      success: function (isos) {
-        initCdromOptions('iso');
-        $.each(isos, function (i, iso) {
-          $('#host_compute_attributes_config_attributes_cdrom_iso').append($("<option></option>").val(iso.volid).text(iso.volid));
-        });
-      }
-    });
-  } else {
-    initCdromOptions('iso');
-  }
+  var node_id = $('#host_compute_attributes_node_id').val();
+  updateOptions('isos', 'compute_attributes_config_attributes', 'cdrom_iso', undefined, undefined, 'volid', node_id, storage);
 }
 
 function attributesPrefixSelector(profile, type) {

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, :node_id, :disable_proxy, :cr_id, :renew
+                            :ssl_certs, :disable_proxy, :cr_id, :renew
             end
           end
 

data/app/controllers/foreman_fog_proxmox/compute_resources_controller.rb

@@ -21,22 +21,62 @@ module ForemanFogProxmox
   class ComputeResourcesController < ::ApplicationController
     before_action :load_compute_resource
 
-    # GET foreman_fog_proxmox/isos/:storage
-    def isos
-      volumes = @compute_resource.images_by_storage(params[:storage], 'iso')
+    # 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')
       respond_to do |format|
         format.json { render :json => volumes }
       end
     end
 
-    # GET foreman_fog_proxmox/ostemplates/:storage
-    def ostemplates
-      volumes = @compute_resource.images_by_storage(params[:storage], 'vztmpl')
+    # 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')
       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')
+      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')
+      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])
+      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')
+      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])
+      respond_to do |format|
+        format.json { render :json => bridges }
+      end
+    end
+
     private
 
     def load_compute_resource

data/app/helpers/proxmox_container_helper.rb

@@ -23,7 +23,9 @@ require 'foreman_fog_proxmox/value'
 
 module ProxmoxContainerHelper
   def config_keys
-    keys = { general: ['node_id', 'name', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes', 'firmware_type', 'provision_method', 'container_volumes', 'server_volumes'] }
+    general_a = ['node_id', 'name', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
+    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
+    keys = { general: general_a }
     keys.store(:main, ['name', 'type', 'node_id', 'vmid', 'interfaces', 'mount_points', 'disks'])
     keys.store(:cpu, ['arch', 'cpulimit', 'cpuunits', 'cores'])
     keys.store(:memory, ['memory', 'swap'])

data/app/helpers/proxmox_server_helper.rb

@@ -42,7 +42,8 @@ module ProxmoxServerHelper
     memory = parse_server_memory(config.select { |key, _value| memory_a.include? key })
     interfaces_attributes = args['interfaces_attributes']
     interfaces_to_add, interfaces_to_delete = parse_server_interfaces(interfaces_attributes)
-    general_a = ['node_id', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes', 'firmware_type', 'provision_method', 'container_volumes', 'server_volumes']
+    general_a = ['node_id', 'type', 'config_attributes', 'volumes_attributes', 'interfaces_attributes']
+    general_a += ['firmware_type', 'provision_method', 'container_volumes', 'server_volumes', 'start_after_create']
     logger.debug("general_a: #{general_a}")
     parsed_vm = args.reject { |key, value| general_a.include?(key) || ForemanFogProxmox::Value.empty?(value) }
     config_a = []

data/app/helpers/proxmox_vm_helper.rb

@@ -57,6 +57,17 @@ module ProxmoxVmHelper
     end
   end
 
+  def convert_memory_sizes(args)
+    convert_memory_size(args['config_attributes'], 'memory')
+    convert_memory_size(args['config_attributes'], 'min_memory')
+    convert_memory_size(args['config_attributes'], 'shares')
+    convert_memory_size(args['config_attributes'], 'swap')
+  end
+
+  def convert_volumes_size(args)
+    args['volumes_attributes'].each_value { |value| value['size'] = (value['size'].to_i / GIGA).to_s unless ForemanFogProxmox::Value.empty?(value['size']) }
+  end
+
   def convert_sizes(args)
     convert_memory_size(args['config_attributes'], 'memory')
     convert_memory_size(args['config_attributes'], 'min_memory')
@@ -74,4 +85,12 @@ module ProxmoxVmHelper
     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 vm_type(host)
+    host.compute_object.type
+  end
+
+  def node_id(host)
+    host.compute_object.node_id
+  end
 end

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

@@ -21,11 +21,6 @@ module FogExtensions
   module Proxmox
     module Node
       extend ActiveSupport::Concern
-      def all(_options = {})
-        vms = servers.all
-        vms += containers.all
-        vms
-      end
 
       def each(collection_filters = {})
         if block_given?

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

@@ -21,7 +21,7 @@ module FogExtensions
   module Proxmox
     module Server
       extend ActiveSupport::Concern
-      attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password
+      attr_accessor :image_id, :templated, :ostemplate_storage, :ostemplate_file, :password, :start_after_create
 
       def start
         action('start')

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -41,7 +41,6 @@ module ForemanFogProxmox
     validates :url, :format => { :with => URI::DEFAULT_PARSER.make_regexp }, :presence => true
     validates :user, :format => { :with => /(\w+)[@]{1}(\w+)/ }, :presence => true
     validates :password, :presence => true
-    validates :node_id, :presence => true
     before_create :test_connection
 
     def provided_attributes
@@ -66,18 +65,6 @@ module ForemanFogProxmox
       associate_by('mac', vm.mac)
     end
 
-    def node_id
-      attrs[:node_id]
-    end
-
-    def node_id=(value)
-      attrs[:node_id] = value
-    end
-
-    def node
-      client.nodes.get node_id
-    end
-
     def ssl_certs
       attrs[:ssl_certs]
     end
@@ -120,14 +107,23 @@ module ForemanFogProxmox
 
     def client
       @client ||= ::Fog::Proxmox::Compute.new(fog_credentials)
+    rescue StandardError => e
+      logger.error(e)
+      raise ::Foreman::Exception, format(N_('Failed retrieving proxmox compute client caused by %<e>s'), e: e)
     end
 
     def identity_client
       @identity_client ||= ::Fog::Proxmox::Identity.new(fog_credentials)
+    rescue StandardError => e
+      logger.error(e)
+      raise ::Foreman::Exception, format(N_('Failed retrieving proxmox identity client caused by %<e>s'), e: e)
     end
 
     def network_client
       @network_client ||= ::Fog::Proxmox::Network.new(fog_credentials)
+    rescue StandardError => e
+      logger.error(e)
+      raise ::Foreman::Exception, format(N_('Failed retrieving proxmox network client caused by %<e>s'), e: e)
     end
 
     def host

data/app/models/foreman_fog_proxmox/proxmox_images.rb

@@ -23,19 +23,24 @@ module ForemanFogProxmox
       !find_vm_by_uuid(image).nil?
     end
 
-    def images_by_storage(storage_id, type = 'iso')
+    def images_by_storage(node_id, storage_id, type = 'iso')
+      node = client.nodes.get node_id
+      node ||= default_node
       storage = node.storages.get storage_id if storage_id
       storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
     def available_images
-      templates.collect { |template| OpenStruct.new(id: template.vmid) }
+      templates.collect { |template| OpenStruct.new(id: template.vmid.to_s) }
     end
 
     def templates
-      storage = storages.first
-      images = storage.volumes.list_by_content_type('images')
-      images.select(&:templated?)
+      volumes = []
+      nodes.each do |node|
+        storage = storages(node.node).first
+        volumes += storage.volumes.list_by_content_type('images')
+      end
+      volumes.select(&:templated?)
     end
 
     def template(vmid)

data/app/models/foreman_fog_proxmox/proxmox_vm_commands.rb

@@ -22,7 +22,7 @@ module ForemanFogProxmox
     include ProxmoxVolumes
 
     def start_on_boot(vm, args)
-      startonboot = args[:config_attributes][:onboot].blank? ? false : Foreman::Cast.to_bool(args[:config_attributes][:onboot])
+      startonboot = args[:start_after_create].blank? ? false : Foreman::Cast.to_bool(args[:start_after_create])
       vm.start if startonboot
       vm
     end
@@ -30,6 +30,7 @@ module ForemanFogProxmox
     def create_vm(args = {})
       vmid = args[:vmid].to_i
       type = args[:type]
+      node = client.nodes.get(args[:node_id])
       raise ::Foreman::Exception, format(N_('invalid vmid=%<vmid>s'), vmid: vmid) unless node.servers.id_valid?(vmid)
 
       image_id = args[:image_id]
@@ -88,9 +89,13 @@ module ForemanFogProxmox
     def save_vm(uuid, new_attributes)
       vm = find_vm_by_uuid(uuid)
       templated = new_attributes['templated']
+      node_id = new_attributes['node_id']
       if templated == '1' && !vm.templated?
         vm.create_template
+      elsif vm.node_id != node_id
+        vm.migrate(node_id)
       else
+        convert_memory_sizes(new_attributes)
         volumes_attributes = new_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))
@@ -100,7 +105,6 @@ module ForemanFogProxmox
         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))
-        start_on_boot(vm, new_attributes)
       end
       find_vm_by_uuid(uuid)
     end