foreman_fog_proxmox 0.4.0 → 0.5.0

data/app/models/foreman_fog_proxmox/proxmox.rb

@@ -21,12 +21,14 @@ require 'fog/proxmox'
 
 module ForemanFogProxmox
   class Proxmox < ComputeResource
-    include ProxmoxComputeHelper
+    include ProxmoxVmHelper
+    include ProxmoxServerHelper
+    include ProxmoxContainerHelper
     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_name, :presence => true
     before_create :test_connection
-    attr_accessor :node
 
     def provided_attributes
       super.merge(
@@ -47,7 +49,7 @@ module ForemanFogProxmox
     end
 
     def credentials_valid?
-      errors[:url].empty? && errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && node
+      errors[:url].empty? && errors[:user].empty? && errors[:user].include?('@') && errors[:password].empty? && errors[:node_name].empty?
     end
 
     def test_connection(options = {})
@@ -59,8 +61,8 @@ module ForemanFogProxmox
     end
 
     def nodes
-      nodes = client.nodes.all
-      nodes.sort_by(&:node)
+      nodes = client.nodes.all if client
+      nodes.sort_by(&:node) if nodes
     end
 
     def pools
@@ -68,19 +70,14 @@ module ForemanFogProxmox
       pools.sort_by(&:poolid)
     end
 
-    def storages
-      storages = node.storages.list_by_content_type 'images'
+    def storages(type = 'images')
+      storages = node.storages.list_by_content_type type
       storages.sort_by(&:storage)
     end
 
-    def storages_isos
-      storages = node.storages.list_by_content_type 'iso'
-      storages.sort_by(&:storage)
-    end
-
-    def isos(storage_id)
+    def images_by_storage(type = 'iso', storage_id)
       storage = node.storages.find_by_id storage_id if storage_id
-      storage.volumes.list_by_content_type('iso').sort_by(&:volid) if storage
+      storage.volumes.list_by_content_type(type).sort_by(&:volid) if storage
     end
 
     def associated_host(vm)
@@ -104,51 +101,85 @@ module ForemanFogProxmox
     end
 
     def template(vmid)
-      find_vm_by_uuid(vmid)
+      vm = find_vm_by_uuid("qemu_#{vmid}")
+      vm = find_vm_by_uuid("lxc_#{vmid}") unless vm
+      vm
     end
 
     def host_compute_attrs(host)
       super.tap do |attrs|
         ostype = host.compute_attributes['config_attributes']['ostype']
-        raise Foreman::Exception.new("Operating system family #{host.operatingsystem.type} is not consistent with #{ostype}") unless compute_os_types(host).include?(ostype)
+        case host.compute_attributes['type']
+        when 'lxc'
+          host.compute_attributes['config_attributes'].store('hostname',host.name)
+        when 'qemu'
+          raise ::Foreman::Exception.new(_("Operating system family %{type} is not consistent with %{ostype}") % { type: host.operatingsystem.type, ostype: ostype }) unless compute_os_types(host).include?(ostype)
+        end
       end
     end
 
     def host_interfaces_attrs(host)
       host.interfaces.select(&:physical?).each.with_index.reduce({}) do |hash, (nic, index)|
-        raise ::Foreman::Exception.new N_("Identifier interface[#{index}] required.") if nic.identifier.empty?
-        raise ::Foreman::Exception.new N_("Invalid identifier interface[#{index}]. Must be net[n] with n integer >= 0") unless Fog::Proxmox::ControllerHelper.valid?(Fog::Compute::Proxmox::Interface::NAME,nic.identifier)
-        hash.merge(index.to_s => nic.compute_attributes.merge(id: nic.identifier, ip: nic.ip, ip6: nic.ip6))
+        raise ::Foreman::Exception.new _("Identifier interface[%{index}] required." % { index: index }) if nic.identifier.empty?
+        raise ::Foreman::Exception.new _("Invalid identifier interface[%{index}]. Must be net[n] with n integer >= 0" % { index: index }) unless Fog::Proxmox::NicHelper.valid?(nic.identifier)
+        nic_compute_attributes = nic.compute_attributes.merge(id: nic.identifier)
+        nic_compute_attributes.store(:ip, nic.ip) if (nic.ip && !nic.ip.empty?)
+        nic_compute_attributes.store(:ip6, nic.ip6) if (nic.ip6 && !nic.ip6.empty?)
+        hash.merge(index.to_s => nic_compute_attributes)
       end
     end
 
     def new_volume(attr = {})     
-      opts = volume_defaults('scsi',1).merge(attr.to_h).deep_symbolize_keys
+      type = attr['type']
+      type = 'qemu' unless type
+      case type
+      when 'lxc'
+        return new_volume_server(attr)
+      when 'qemu'
+        return new_volume_container(attr)
+      end
+    end
+
+    def new_volume_server(attr = {})
+      opts = volume_server_defaults.merge(attr.to_h).deep_symbolize_keys
+      opts[:size] = opts[:size].to_s
+      Fog::Compute::Proxmox::Disk.new(opts)
+    end
+
+    def new_volume_container(attr = {})
+      id = attr[:id]
+      opts = volume_container_defaults(id).merge(attr.to_h).deep_symbolize_keys
       opts[:size] = opts[:size].to_s
       Fog::Compute::Proxmox::Disk.new(opts)
     end
 
     def new_interface(attr = {})
-      opts = interface_defaults.merge(attr.to_h).deep_symbolize_keys
+      opts = interface_server_defaults.merge(attr.to_h).deep_symbolize_keys
       Fog::Compute::Proxmox::Interface.new(opts)
     end
 
     def vm_compute_attributes(vm)
-      vm_attrs = vm.attributes rescue {}
-      vm_attrs = vm_attrs.reject{|k,v| k == :id }  
+      vm_attrs = vm.attributes.reject { |key,value| [:config].include?(key) || value.to_s.empty? }
+      vm_attrs = set_vm_config_attributes(vm, vm_attrs)
       vm_attrs = set_vm_volumes_attributes(vm, vm_attrs)
       vm_attrs = set_vm_interfaces_attributes(vm, vm_attrs)
       vm_attrs
     end
 
-    def set_vm_volumes_attributes(vm, vm_attrs)
-      if vm.config.respond_to?(:volumes)
-        volumes = vm.config.volumes || []
-        vm_attrs[:volumes_attributes] = Hash[volumes.each_with_index.map { |volume, idx| [idx.to_s, volume.attributes] }]
+    def set_vm_config_attributes(vm, vm_attrs)
+      if vm.respond_to?(:config)
+        config = vm.config.attributes.reject { |key,value| [:disks,:mount_points,:interfaces].include?(key) || value.to_s.empty?}
+        vm_attrs[:config_attributes] = config
       end
       vm_attrs
     end
 
+    def set_vm_volumes_attributes(vm, vm_attrs)
+      volumes = vm.container? ? vm.config.mount_points : vm.config.disks || []
+      vm_attrs[:volumes_attributes] = Hash[volumes.each_with_index.map { |volume, idx| [idx.to_s, volume.attributes] }]
+      vm_attrs
+    end
+
     def set_vm_interfaces_attributes(vm, vm_attrs)
       if vm.config.respond_to?(:interfaces)
         interfaces = vm.config.interfaces || []
@@ -158,37 +189,72 @@ module ForemanFogProxmox
     end
 
     def new_vm(attr = {})
-      vm = node.servers.new(vm_instance_defaults.merge(parse_vm(attr)))
-      logger.debug("new_vm() vm.config=#{vm.config.inspect}")
+      attr = ActiveSupport::HashWithIndifferentAccess.new(attr)
+      type = attr['type']
+      type = 'qemu' unless type
+      case type
+      when 'lxc'
+        vm = new_container_vm(attr)
+      when 'qemu'
+        vm = new_server_vm(attr)
+      end
+      logger.debug(_("new_vm() vm.config=%{config}") % { config: vm.config.inspect })
+      vm
+    end
+
+    def new_container_vm(attr = {})
+      vm = node.containers.new(vm_container_instance_defaults.merge(parse_container_vm(attr.merge(type: 'lxc'))))
+      logger.debug(_("new_container_vm() vm.config=%{config}") % { config: vm.config.inspect })
+      vm
+    end
+
+    def new_server_vm(attr = {})
+      vm = node.servers.new(vm_server_instance_defaults.merge(parse_server_vm(attr.merge(type: 'qemu'))))
+      logger.debug(_("new_server_vm() vm.config=%{config}") % { config: vm.config.inspect })
       vm
     end
 
     def create_vm(args = {})
-      vmid = args[:vmid]
-      raise ::Foreman::Exception.new N_("invalid vmid=#{vmid}") unless node.servers.id_valid?(vmid)
+      vmid = args[:vmid].to_i
+      type = args[:type]
+      raise ::Foreman::Exception.new N_("invalid vmid=%{vmid}") % { vmid: vmid } unless node.servers.id_valid?(vmid)
       image_id = args[:image_id]
-      node = get_cluster_node args
       if image_id
-        logger.debug("create_vm(): clone #{image_id} in #{vmid}")
+        logger.debug(_("create_vm(): clone %{image_id} in %{vmid}") % { image_id: image_id, vmid: vmid })
         image = node.servers.get image_id
         image.clone(vmid)
+        clone = node.servers.get vmid
+        clone.update(name: args[:name])        
       else
-        logger.debug("create_vm(): #{args}")
+        logger.debug(_("create_vm(): %{args}") % { args: args })
         convert_sizes(args)
-        node.servers.create(parse_vm(args))
+        case type
+          when 'qemu'
+            node.servers.create(parse_server_vm(args))
+          when 'lxc'
+            hash = parse_container_vm(args)
+            hash = hash.merge(vmid: vmid)
+            node.containers.create(hash.reject { |key,_value| %w[ostemplate_storage ostemplate_file].include? key })
+        end
       end
-      vm = find_vm_by_uuid(vmid)
+      vm = find_vm_by_uuid("#{type}_#{vmid}")
       vm
     rescue => e
-      logger.warn "failed to create vm: #{e}"
+      logger.warn(_("failed to create vm: %{e}") % { e: e })
       destroy_vm vm.id if vm
       raise e
     end
 
     def find_vm_by_uuid(uuid)
-      node.servers.get(uuid)
+      type, vmid = parse_type_and_vmid(uuid)
+      case type
+      when 'qemu'
+        node.servers.get(vmid)
+      when 'lxc'
+        node.containers.get(vmid)
+      end
     rescue Fog::Errors::Error => e
-      Foreman::Logging.exception("Failed retrieving proxmox vm by vmid=#{uuid}", e)
+      Foreman::Logging.exception(_("Failed retrieving proxmox vm by vmid=%{vmid} and type=%{type}") % { vmid: vmid, type: type }, e)
       raise(ActiveRecord::RecordNotFound)
     end
 
@@ -219,18 +285,23 @@ module ForemanFogProxmox
     end
 
     def image_exists?(image)
-      find_vm_by_uuid(image)
+      vm = find_vm_by_uuid("qemu_#{image}")
+      vm = find_vm_by_uuid("lxc_#{image}") unless vm
+      vm!=nil
     end
 
     def save_vm(uuid, attr)
+      type, vmid = parse_type_and_vmid(uuid)
+      attr = attr.merge(type: type, vmid: vmid)
       vm = find_vm_by_uuid(uuid)
-      logger.debug("save_vm(): #{attr}")
+      logger.debug(N_("save_vm(): %{attr}") % { attr: attr })
       templated = attr[:templated]
       if (templated == '1' && !vm.templated?)
         vm.template
       else
-        merged = vm.config.attributes.merge!(parse_vm(attr).symbolize_keys).deep_symbolize_keys
-        filtered = merged.reject { |key,value| %w[node vmid].include?(key) || [:templated,:image_id].include?(key) || value.to_s.empty? }
+        parsed_attr = vm.container? ? parse_container_vm(attr) : parse_server_vm(attr)
+        merged = vm.config.attributes.merge(parsed_attr.symbolize_keys).deep_symbolize_keys
+        filtered = merged.reject { |key,value| [:node,:vmid,:type,:templated,:image_id].include?(key) || value.to_s.empty? }
         vm.update(filtered)
       end
     end
@@ -239,8 +310,16 @@ module ForemanFogProxmox
       node.servers.next_id
     end
 
+    def node_name  
+      self.attrs[:node_name]
+    end
+
+    def node_name=(value)
+      self.attrs[:node_name] = value
+    end
+
     def node
-      @node ||= get_cluster_node
+      client.nodes.find_by_id node_name
     end
 
     def ssl_certs  
@@ -281,11 +360,15 @@ module ForemanFogProxmox
 
     def console(uuid)
       vm = find_vm_by_uuid(uuid)
-      if vm.config.type_console == 'vnc'
-        vnc_console = vm.start_console(websocket: 1)  
-        WsProxy.start(:host => host, :host_port => vnc_console['port'], :password => vnc_console['ticket']).merge(:name => vm.name, :type => vm.config.type_console)
-      else
-        raise ::Foreman::Exception.new(N_("%s console is not supported at this time"), vm.config.type_console)
+      type_console = vm.config.type_console
+      options = {}
+      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)
+      rescue => e
+        logger.error(e)
+        raise ::Foreman::Exception.new(_("%s console is not supported at this time") % type_console)
       end
     end
 
@@ -319,8 +402,9 @@ module ForemanFogProxmox
       @network_client = nil
     end
 
-    def vm_instance_defaults
-      super.merge(
+    def vm_server_instance_defaults
+      ActiveSupport::HashWithIndifferentAccess.new(
+        name: "foreman_#{Time.now.to_i}",
         vmid: next_vmid, 
         type: 'qemu', 
         node: node.to_s, 
@@ -334,23 +418,39 @@ module ForemanFogProxmox
         cpu: 'kvm64',
         scsihw: 'virtio-scsi-pci',
         ide2: "none,media=cdrom",
-        templated: 0
-      ).merge(Fog::Proxmox::DiskHelper.flatten(volume_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_defaults))
+        templated: 0).merge(Fog::Proxmox::DiskHelper.flatten(volume_server_defaults)).merge(Fog::Proxmox::NicHelper.flatten(interface_server_defaults))
     end
 
-    def volume_defaults(controller = 'scsi', device = 0)
+    def vm_container_instance_defaults
+      ActiveSupport::HashWithIndifferentAccess.new(
+        name: "foreman_#{Time.now.to_i}",
+        vmid: next_vmid, 
+        type: 'lxc', 
+        node: node.to_s,
+        memory: 512 * MEGA, 
+        templated: 0).merge(Fog::Proxmox::DiskHelper.flatten(volume_container_defaults)).merge(Fog::Proxmox::NicHelper.container_flatten(interface_container_defaults))
+    end
+
+    def vm_instance_defaults
+      super.merge(vmid: next_vmid, node: node.to_s)
+    end
+
+    def volume_server_defaults(controller = 'scsi', device = 0)
       id = "#{controller}#{device}"
       { id: id, storage: storages.first.to_s, size: (8 * GIGA), options: { cache: 'none' } }
     end
 
-    def interface_defaults(id = 'net0')
+    def volume_container_defaults(id='rootfs')
+      { id: id, storage: storages.first.to_s, size: (8 * GIGA), options: {  } }
+    end
+
+    def interface_server_defaults(id = 'net0')
       { id: id, model: 'virtio', bridge: bridges.first.to_s }
     end
 
-    def get_cluster_node(args = {})
-      test_connection
-      args.empty? ? client.nodes.first : client.nodes.find_by_id(args[:node])  if errors.empty?
-    end 
+    def interface_container_defaults(id = 'net0')
+      { id: id, name: 'eth0', bridge: bridges.first.to_s }
+    end
     
     def compute_os_types(host)
       os_linux_types_mapping(host).empty? ? os_windows_types_mapping(host) : os_linux_types_mapping(host)
@@ -364,7 +464,7 @@ module ForemanFogProxmox
     end
 
     def available_linux_operating_systems
-      %w[l24 l26]
+      %w[l24 l26 debian ubuntu centos fedora opensuse archlinux gentoo alpine]
     end
 
     def available_windows_operating_systems
@@ -379,13 +479,6 @@ module ForemanFogProxmox
       %w[Windows].include?(host.operatingsystem.type) ? available_windows_operating_systems : []
     end
 
-    def convert_sizes(args)
-      args['config_attributes']['memory'] = (args['config_attributes']['memory'].to_i / MEGA).to_s
-      args['config_attributes']['min_memory'] = (args['config_attributes']['min_memory'].to_i / MEGA).to_s
-      args['config_attributes']['shares'] = (args['config_attributes']['shares'].to_i / MEGA).to_s
-      args['volumes_attributes'].each_value { |value| value['size'] = (value['size'].to_i / GIGA).to_s }
-    end
-
     def host
       URI.parse(url).host
     end

data/app/overrides/compute_resources_vms/form/add_clone_to_new_vm_compute_detail.rb

@@ -0,0 +1,24 @@
+# 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/>.
+
+Deface::Override.new(
+    :virtual_path => "hosts/_compute_detail",
+    :name => "add_clone_to_new_vm_compute_detail",
+    :replace => "erb[silent]:contains('new_vm = @host.nil? || new_vm?(@host)')",
+    :text => "<% new_vm = @host.nil? || new_vm?(@host) || @host.name.nil? %>",
+    :original => "<% new_vm = @host.nil? || new_vm?(@host) %>"
+)

data/app/overrides/compute_resources_vms/form/add_vm_type_to_networks_form.rb

@@ -0,0 +1,32 @@
+# 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/>.
+
+Deface::Override.new(
+    :virtual_path => "compute_resources_vms/form/_networks",
+    :name => "add_vm_type_to_networks_form",
+    :replace => "erb[loud]:contains('render')",
+    :partial => "compute_resources_vms/form/proxmox/add_vm_type_to_networks_form",
+    :original => 'bae57f59cbbf6fcf1aecdf3a02baee5ff3494c85'
+)
+
+Deface::Override.new(
+    :virtual_path => "compute_resources_vms/form/_networks",
+    :name => "add_vm_type_to_networks_new_childs_form",
+    :replace => "erb[loud]:contains('new_child_fields_template')",
+    :partial => "compute_resources_vms/form/proxmox/add_vm_type_to_networks_new_childs_form",
+    :original => '4ba200e5e02810ade03827374de9b0b8b6a2f6a9' 
+)

data/app/overrides/compute_resources_vms/form/add_vm_type_to_nic_provider_specific_form.rb

@@ -0,0 +1,25 @@
+# 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/>.
+
+Deface::Override.new(
+    :virtual_path => "nic/_provider_specific_form",
+    :name => "add_vm_type_to_nic_provider_specific_form",
+    :replace => "erb[loud]:contains('f.fields_for')",
+    :closing_selector => "erb[silent]:contains('end')",
+    :partial => "compute_resources_vms/form/proxmox/add_vm_type_to_nic_provider_specific_form",
+    :original => '3c575e0e570cc620277fbffd61bfdc7c42bbdc77' 
+)