foreman_kubevirt 0.1.0

data/app/models/foreman_kubevirt/kubevirt.rb

@@ -0,0 +1,370 @@
+require 'foreman/exception'
+
+module ForemanKubevirt
+  class Kubevirt < ComputeResource
+    alias_attribute :hostname, :url
+    alias_attribute :token, :password
+    alias_attribute :namespace, :user
+    validates :hostname, :api_port, :namespace, :token, :presence => true
+    validate :test_connection
+
+    def ca_cert
+      attrs[:ca_cert]
+    end
+
+    def ca_cert=(key)
+      attrs[:ca_cert] = key
+    end
+
+    def api_port
+      attrs[:api_port]
+    end
+
+    def api_port=(key)
+      attrs[:api_port] = key
+    end
+
+    def capabilities
+      %i[build image new_volume]
+    end
+
+    def provided_attributes
+      { :uuid => :name, :mac => :mac }
+    end
+
+    def available_images
+      []
+    end
+
+    def self.provider_friendly_name
+      'KubeVirt'
+    end
+
+    def to_label
+      "#{name} (#{provider_friendly_name})"
+    end
+
+    def self.model_name
+      ComputeResource.model_name
+    end
+
+    def test_connection(_options = {})
+      client&.valid? && client&.virt_supported?
+    rescue StandardError => e
+      errors[:base] << e.message
+    end
+
+    def networks
+      client.networkattachmentdefs.all
+    rescue StandardError => e
+      logger.warn("Failed to retrieve network attachments definition from KubeVirt, make sure KubeVirt has CNI provider and NetworkAttachmentDefinition CRD deployed: #{e.message}")
+      []
+    end
+
+    def find_vm_by_uuid(uuid)
+      super
+    rescue Fog::Kubevirt::Errors::ClientError => e
+      Foreman::Logging.exception("Failed retrieving KubeVirt vm by uuid #{uuid}", e)
+      raise ActiveRecord::RecordNotFound
+    end
+
+    def volumes
+      client.volumes.all
+    end
+
+    def storage_classes
+      client.storageclasses.all
+    end
+
+    def storage_classes_for_select
+      storage_classes.map { |sc| OpenStruct.new(id: sc.name, description: "#{sc.name} (#{sc.provisioner})") }
+    end
+
+    def new_volume(attr = {})
+      return unless new_volume_errors.empty?
+
+      Fog::Kubevirt::Compute::Volume.new(attr)
+    end
+
+    def new_volume_errors
+      errors = []
+      errors.push _('no Persistent Volumes available on provider') if storage_classes.empty?
+      errors
+    end
+
+    def cni_providers
+      [[_("multus"), :multus], [_("genie"), :genie], [_("pod"), :pod]]
+    end
+
+    # @param args[Hash] contains VM creation parameters
+    #  cpu_cores[str] - the number of cpu cores
+    #  memory[str] - the memory for the VM
+    #  start[bool] - indicates if the vm should be started
+    #  name[str] - the name of the VM
+    #  interfaces_attributes[Hash] - the attributes for the interfaces, i.e.:
+    #    {
+    #      "0" => {
+    #               "network"      => "ovs-foreman",
+    #               "boot"         => "1",
+    #               "cni_provider" => "multus"
+    #             },
+    #      "1" => {
+    #               "cni_provider" => "pod"
+    #               "boot"         => "0"
+    #             }
+    #    }
+    #
+    # volumes_attributes[Hash] - the attributes for the persistent volume claims:
+    #   {
+    #     "1554394214729" => {
+    #                          "storage_class" => "local-storage",
+    #                          "name"          => "alvin-hinojosa1",
+    #                          "capacity"      => "3",
+    #                          "bootable"=>"true"
+    #                        },
+    #     "1554394230987" => {
+    #                          "storage_class" => "local-storage",
+    #                          "name"          => "alvin-hinojosa",
+    #                          "capacity"=>"2"
+    #                        }
+    #   }
+    def create_vm(args = {})
+      options = vm_instance_defaults.merge(args.to_hash.deep_symbolize_keys)
+      logger.debug("creating VM with the following options: #{options.inspect}")
+      volumes = []
+
+      image = args["image_id"]
+      volumes_attributes = args["volumes_attributes"]
+      raise "VM should be created based on Persistent Volume Claim or Image" unless (volumes_attributes.present? || image)
+
+      # Add image as volume to the virtual machine
+      image_provision = args["provision_method"] == "image"
+      if image_provision
+        volume = Fog::Kubevirt::Compute::Volume.new
+        raise "VM should be created based on an image" unless image
+
+        volume.info = image
+        volume.boot_order = 1
+        volume.type = 'containerDisk'
+        volumes << volume
+      end
+
+      volumes_attributes&.each_with_index do |(_, v), index|
+        # Add PVC as volumes to the virtual machine
+        pvc_name = options[:name].gsub(/[._]+/, '-') + "-claim-" + (index + 1).to_s
+        capacity = v["capacity"]
+        storage_class = v["storage_class"]
+        bootable = v["bootable"] && !image_provision
+
+        volume = create_vm_volume(pvc_name, capacity, storage_class, bootable)
+        volumes << volume
+      end
+
+      # FIXME: Add cloud-init support
+      # init = { 'userData' => "#!/bin/bash\necho \"fedora\" | passwd fedora --stdin"}
+
+      interfaces = []
+      networks = []
+
+      args["interfaces_attributes"].values.each do |iface|
+        if iface["cni_provider"] == 'pod'
+          nic = {
+            :bridge => {},
+            :name   => 'pod'
+          }
+
+          net = { :name => 'pod', :pod => {} }
+        else
+          nic = {
+            :bridge => {},
+            :name   => iface["network"]
+          }
+
+          cni = iface["cni_provider"].to_sym
+          net = {
+            :name => iface["network"],
+            cni   => { :networkName => iface["network"] }
+          }
+        end
+
+        # TODO: Consider replacing with 'free' boot order, also verify uniqueness
+        # there is a bug with bootOrder https://bugzilla.redhat.com/show_bug.cgi?id=1687341
+        # therefore adding to the condition not to boot from netwotk device if already asked
+        # to boot from disk
+        if iface["provision"] == true && volumes.select { |v| v.boot_order == 1 }.empty?
+          nic[:bootOrder] = 1
+        end
+        nic[:macAddress] = iface["mac"] if iface["mac"]
+        interfaces << nic
+        networks << net
+      end
+
+      begin
+        client.vms.create(:vm_name     => options[:name],
+                          :cpus        => options[:cpu_cores].to_i,
+                          :memory_size => options[:memory].to_i / 2**20,
+                          :volumes     => volumes,
+                          # :cloudinit   => init,
+                          :networks    => networks,
+                          :interfaces  => interfaces)
+        client.servers.get(options[:name])
+      rescue Fog::Kubevirt::Errors::ClientError => e
+        delete_pvcs(volumes)
+        raise e
+      end
+    end
+
+    def create_new_pvc(pvc_name, capacity, storage_class)
+      client.pvcs.create(:name          => pvc_name,
+                         :namespace     => namespace,
+                         :storage_class => storage_class,
+                         :access_modes  => ['ReadWriteOnce'],
+                         :requests      => { :storage => capacity + "G" })
+    end
+
+    def delete_pvcs(volumes)
+      volumes.each do |volume|
+        begin
+          client.pvcs.delete(volume.info) if volume.type == "persistentVolumeClaim"
+        rescue StandardError => e
+          logger.error("The PVC #{volume.info} couldn't be delete due to #{e.message}")
+        end
+      end
+    end
+
+    def create_vm_volume(pvc_name, capacity, storage_class, bootable)
+      create_new_pvc(pvc_name, capacity, storage_class)
+
+      volume = Fog::Kubevirt::Compute::Volume.new
+      volume.type = 'persistentVolumeClaim'
+      volume.info = pvc_name
+      volume.boot_order = 1 if bootable == "true"
+      volume
+    end
+
+    def destroy_vm(vm_uuid)
+      vm = find_vm_by_uuid(vm_uuid)
+      delete_pvcs(vm.volumes)
+      vm.destroy
+    rescue ActiveRecord::RecordNotFound
+      true
+    end
+
+    def host_compute_attrs(host)
+      attrs = super
+      attrs[:interfaces_attributes].each_value { |nic| nic["network"] = nil if nic["cni_provider"] == "pod" }
+      attrs
+    end
+
+    #
+    # Since 'name' is the identity/UUID of server/vm, we need to override
+    # default values that assign also value for 'name' so vm_exists? will
+    # return 'false'
+    def vm_instance_defaults
+      {
+        :memory    => 1024.megabytes,
+        :cpu_cores => '1'
+      }
+    end
+
+    def new_interface(attr = {})
+      Fog::Kubevirt::Compute::VmNic.new attr
+    end
+
+    #
+    # Overrding base class implementation since 'mac' is required for the created interface
+    #
+    def host_interfaces_attrs(host)
+      host.interfaces.select(&:physical?).each.with_index.reduce({}) do |hash, (nic, index)|
+        hash.merge(index.to_s => nic.compute_attributes.merge(ip: nic.ip, mac: nic.mac, provision: nic.provision))
+      end
+    end
+
+    #
+    # Overrding base class implementation since 'pvc' is required
+    #
+    def set_vm_volumes_attributes(vm, vm_attrs)
+      volumes = vm.volumes.collect do |vol|
+        next unless vol.type == 'persistentVolumeClaim'
+
+        begin
+          vol.pvc = client.pvcs.get(vol.info)
+          vol
+        rescue StandardError => e
+          # An import of a VM where one of its PVC doesn't exist
+          Foreman::Logging.exception("Import VM fail: The PVC #{vol.info} does not exist for VM #{vm.name}", e)
+          nil
+        end
+      end.compact
+      vm_attrs[:volumes_attributes] = Hash[volumes.each_with_index.map { |volume, idx| [idx.to_s, volume.attributes] }]
+
+      vm_attrs
+    end
+
+    def vm_compute_attributes(vm)
+      vm_attrs = super
+      interfaces = vm.interfaces || []
+      vm_attrs[:interfaces_attributes] = interfaces.each_with_index.each_with_object({}) do |(interface, index), hsh|
+        interface_attrs = {}
+        interface_attrs[:compute_attributes] = {}
+        interface_attrs[:mac] = interface.mac
+        interface_attrs[:compute_attributes][:network] = interface.network
+        interface_attrs[:compute_attributes][:cni_provider] = interface.cni_provider
+        hsh[index.to_s] = interface_attrs
+      end
+
+      vm_attrs
+    end
+
+    def associated_host(vm)
+      associate_by("mac", vm.mac)
+    end
+
+    # TODO: max supported values should be fetched according to namespace
+    #      capabilities: kubectl get limits namespace_name
+    def max_cpu_count
+      16
+    end
+
+    def max_socket_count
+      16
+    end
+
+    def max_memory
+      64.gigabytes
+    end
+
+    protected
+
+    def client
+      return @client if @client
+
+      @client ||= Fog::Kubevirt::Compute.new(
+        :kubevirt_hostname   => hostname,
+        :kubevirt_port       => api_port,
+        :kubevirt_namespace  => namespace,
+        :kubevirt_token      => token,
+        :kubevirt_log        => logger,
+        :kubevirt_verify_ssl => ca_cert.present?,
+        :kubevirt_ca_cert    => ca_cert
+      )
+    rescue OpenSSL::X509::CertificateError
+      raise_certification_failure_exception
+    rescue StandardError => e
+      if e.message =~ /SSL_connect.*certificate verify failed/ ||
+         e.message =~ /Peer certificate cannot be authenticated with given CA certificates/
+        raise_certification_failure_exception
+      else
+        raise e
+      end
+    end
+
+    def raise_certification_failure_exception
+      raise Foreman::FingerprintException.new(
+        N_("The remote system presented a public key signed by an unidentified certificate authority.
+           If you are sure the remote system is authentic, go to the compute resource edit page, press the 'Test Connection' button and submit"),
+          ca_cert
+      )
+    end
+  end
+end

data/app/views/api/v2/compute_resources/kubevirt.json.rabl

@@ -0,0 +1 @@
+attributes :hostname, :api_port, :namespace

data/app/views/compute_resources/form/_kubevirt.html.erb

@@ -0,0 +1,14 @@
+<%= text_f f, :hostname, :label => _("Hostname") %>
+<%= text_f f, :api_port, :label => _("API Port"), :required => true %>
+<%= text_f f, :namespace, :label => _("Namespace"), :required => true %>
+<%= password_f f, :password, :label => _("Token"), :required => true,
+              :keep_value => true, :unset => unset_password?,
+              :help_block => _("e.g. eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9..."),
+              :help_inline => documentation_button('5.2.10PasswordEncryption') %>
+
+<%= textarea_f f, :ca_cert, :label => _("X509 Certification Authorities"),
+  :placeholder => _("Optionally provide a CA, or a correctly ordered CA chain or a path to a file. If left blank - insecure.") %>
+
+ <div class="col-md-offset-2">
+   <%= test_connection_button_f(f, true) %>
+ </div>

data/app/views/compute_resources/show/_kubevirt.html.erb

@@ -0,0 +1,14 @@
+<tr>
+  <td><%= _("Hostname") %></td>
+  <td><%= @compute_resource.hostname %></td>
+</tr>
+
+<tr>
+  <td><%= _("API Port") %></td>
+  <td><%= @compute_resource.api_port %></td>
+</tr>
+
+<tr>
+  <td><%= _("Namespace") %></td>
+  <td><%= @compute_resource.user %></td>
+</tr>

data/app/views/compute_resources_vms/form/kubevirt/_base.html.erb

@@ -0,0 +1,27 @@
+<%= javascript_tag("$(document).on('ContentLoad', tfm.numFields.initAll)"); %>
+
+<%= text_f f, :name, :label => _('Name'), :label_size => "col-md-2", :disabled => !new_vm if show_vm_name? %>
+
+<%= counter_f f, :cpu_cores, :disabled => !new_vm, :label => _('CPUs'), :label_size => 'col-md-2', :'data-soft-max' => compute_resource.max_cpu_count %>
+
+<%= byte_size_f f, :memory, :disabled => !new_vm, :label => _('Memory'), :label_size => "col-md-2", :'data-soft-max' => compute_resource.max_memory %>
+
+<% checked = params[:host] && params[:host][:compute_attributes] && params[:host][:compute_attributes][:start] || '1' %>
+<%= checkbox_f f, :start, { :checked => (checked == '1'), :help_inline => _("Power ON this machine"), :label => _('Start'), :label_size => "col-md-2"} if new_vm && controller_name != "compute_attributes" %>
+
+
+<% unless local_assigns[:hide_image] %>
+  <%
+     arch ||= nil ; os ||= nil
+     images = possible_images(compute_resource, arch, os)
+  -%>
+
+  <div id='image_selection'>
+    <%= select_f f, :image_id, images, :uuid, :name,
+                 { :include_blank => (images.empty? || images.size == 1) ? false : _('Please select an image') },
+                 { :disabled => images.empty?, :label => _('Image'), :label_size => "col-md-2" } %>
+  </div>
+<% end %>
+
+<%= javascript_include_tag("foreman_kubevirt/nic_info.js") %>
+<%= javascript_include_tag("foreman_kubevirt/kubevirt.js") %>

data/app/views/compute_resources_vms/form/kubevirt/_network.html.erb

@@ -0,0 +1,15 @@
+<%= selectable_f f, :cni_provider, compute_resource.cni_providers, {},
+                    :class => "col-md-3 kubevirt-cni-provider",
+                    :disabled => !new_vm,
+                    :label => _('CNI Provider'),
+                    :label_size => "col-md-3",
+                    :onchange => "cniProviderSelected(this)" %>
+
+<%= select_f f, :network, compute_resource.networks,
+                :id,
+                :name,
+                {},
+                :disabled => !new_vm || f.object.cni_provider == 'pod',
+                :class => "col-md-3 kubevirt-network",
+                :label => _('Network'),
+                :label_size => "col-md-3" %>

data/app/views/compute_resources_vms/form/kubevirt/_volume.html.erb

@@ -0,0 +1,21 @@
+<% if f.object.type.nil? || f.object.type == 'persistentVolumeClaim' %>
+  <% storage_classes = compute_resource.storage_classes %>
+
+  <%= select_f f, :storage_class,
+                  compute_resource.storage_classes_for_select,
+                  :id,
+                  :description,
+                  { },
+                  :label => _('Storage Class'),
+                  :label_size => "col-md-2",
+                  :disabled => !new_vm,
+                  :class => "col-md-2" %>
+
+  <%= text_f f,:capacity, :label => _('Size (GB)'), :label_size => "col-md-2", :disabled => !new_vm, :class => "col-md-2 pvc-size" %>
+
+  <% bootable = f.object.boot_order.nil? ? false : f.object.bootable %>
+  <%= field(f, :bootable, :label => _('Bootable'), :label_size => "col-md-2") do
+    radio_button_f f, :bootable, {:disabled => !new_vm, :checked => bootable, :onclick => 'bootableRadio(this)',
+    :text => _('Only one volume can be bootable')}
+  end %>
+<% end %>

data/app/views/compute_resources_vms/index/_kubevirt.html.erb

@@ -0,0 +1,29 @@
+<thead>
+  <tr>
+    <th><%= _('Name') %></th>
+    <th><%= _('CPUs') %></th>
+    <th><%= _('Memory') %></th>
+    <th><%= _('Power') %></th>
+    <th><%= _('Actions') %></th>
+  </tr>
+</thead>
+<tbody>
+  <% @vms.each do |vm| %>
+    <tr>
+      <td><%= link_to_if_authorized vm.name, hash_for_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => vm.identity).merge(:auth_object => @compute_resource, :auth_action => 'view', :authorizer => authorizer) %></td>
+      <td><%= vm.cpu_cores %></td>
+      <td><%= vm.memory %></td>
+      <td>
+        <span <%= vm_power_class(vm.ready?) %>>
+          <%= vm_state(vm) %></span>
+      </td>
+      <td>
+        <%=
+            action_buttons(vm_power_action(vm, authorizer),
+                           vm_import_action(vm),
+                           display_delete_if_authorized(hash_for_compute_resource_vm_path(:compute_resource_id => @compute_resource, :id => vm.identity).merge(:auth_object => @compute_resource, :authorizer => authorizer)))
+        %>
+      </td>
+    </tr>
+  <% end %>
+</tbody>

data/app/views/compute_resources_vms/show/_kubevirt.html.erb

@@ -0,0 +1,55 @@
+<% title @vm.name %>
+
+<div class='col-md-12'>
+  <table class="<%= table_css_classes %>">
+    <thead>
+      <tr><th colspan="2"><%=_('Properties') %></th></tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td><%= _('Name') %></td>
+        <td><%= @vm.identity %></td>
+      </tr>
+      <tr>
+        <td><%= _('VCPU(s)') %></td>
+        <td><%= @vm.cpu_cores %></td>
+      </tr>
+      <tr>
+        <td><%= _('UUID') %></td>
+        <td><%= @vm.uid %></td>
+      </tr>
+      <tr>
+        <td><%= _('Memory') %></td>
+        <td><%= number_to_human_size @vm.memory %>
+        </td>
+      </tr>
+      <tr>
+        <td><%= _('Namespace') %></td>
+        <td><%= @vm.namespace %></td>
+      </tr>
+      <tr>
+        <td><%= _('Type') %></td>
+        <td><%= @vm.machine_type %></td>
+      </tr>
+
+      <% @vm.interfaces.each do |nic| %>
+        <tr>
+          <td><%= _('NIC') %></td>
+          <td><%= "#{nic.name} - #{nic.mac_address} (#{nic.type})" %></td>
+        </tr>
+      <% end %>
+
+      <% @vm.volumes.each do |vol| %>
+        <tr>
+          <td><%= _('Disk') %></td>
+          <td><%= "#{vol.name}  - #{vol.type} (#{vol.info})" %></td>
+        </tr>
+      <% end %>
+
+      <tr>
+        <td><%= _('Running on') %></td>
+        <td><%= link_to @compute_resource, compute_resource_path(@compute_resource) %></td>
+      </tr>
+    </tbody>
+  </table>
+</div>

data/app/views/images/form/_kubevirt.html.erb

@@ -0,0 +1,4 @@
+<%= text_f f, :username, :value => @image.username || "root", :help_inline => _("The user that is used to ssh into the instance, normally cloud-user, ec2-user, ubuntu, root etc") %>
+<%= password_f f, :password, :help_inline => _("Password to authenticate with - used for SSH finish step.") %>
+<%= checkbox_f f, :user_data, :help_inline => _("Does this image support user data input (e.g. via cloud-init)?") %>
+<%= image_field(f, :label => _("Image"), :help_inline => _("The name of the image in the registry.")) %>

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/foreman_kubevirt/engine.rb

@@ -0,0 +1,75 @@
+module ForemanKubevirt
+  class Engine < ::Rails::Engine
+    engine_name "foreman_kubevirt"
+    config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
+    initializer "foreman_kubevirt.register_plugin", :before => :finisher_hook do |_app|
+      Foreman::Plugin.register :foreman_kubevirt do
+        requires_foreman ">= 1.7"
+        compute_resource(ForemanKubevirt::Kubevirt)
+
+        parameter_filter(ComputeResource, :hostname, :url)
+        parameter_filter(ComputeResource, :namespace, :user)
+        parameter_filter(ComputeResource, :token, :password)
+        parameter_filter(ComputeResource, :ca_cert)
+        parameter_filter(ComputeResource, :api_port)
+      end
+    end
+
+    assets_to_precompile =
+      Dir.chdir(root) do
+        Dir['app/assets/javascripts/**/*', 'app/assets/stylesheets/**/*'].map do |f|
+          f.split(File::SEPARATOR, 4).last
+        end
+      end
+
+    initializer 'foreman_kubevirt.assets.precompile' do |app|
+      app.config.assets.precompile += assets_to_precompile
+    end
+
+    initializer 'foreman_kubevirt.filter_parameters' do |app|
+      app.config.filter_parameters += [:token]
+    end
+
+    initializer 'foreman_kubevirt.configure_assets', group: :assets do
+      SETTINGS[:foreman_kubevirt] = { assets: { precompile: assets_to_precompile } }
+    end
+
+    initializer "foreman_kubevirt.add_rabl_view_path" do
+      Rabl.configure do |config|
+        config.view_paths << ForemanKubevirt::Engine.root.join('app', 'views')
+      end
+    end
+
+    # Include concerns in this config.to_prepare block
+    config.to_prepare do
+      begin
+        require "fog/kubevirt"
+        require "fog/kubevirt/compute/models/server"
+        require File.expand_path("../../app/models/concerns/fog_extensions/kubevirt/server", __dir__)
+
+        ::Api::V2::ComputeResourcesController.send :include, ForemanKubevirt::Concerns::Api::ComputeResourcesControllerExtensions
+        Fog::Kubevirt::Compute::Server.send(:include, ::FogExtensions::Kubevirt::Server)
+
+        require "fog/kubevirt/compute/models/volume"
+        require File.expand_path("../../app/models/concerns/fog_extensions/kubevirt/volume", __dir__)
+        Fog::Kubevirt::Compute::Volume.send(:include, ::FogExtensions::Kubevirt::Volume)
+
+        require "fog/kubevirt/compute/models/vmnic"
+        require File.expand_path("../../app/models/concerns/fog_extensions/kubevirt/vmnic", __dir__)
+        Fog::Kubevirt::Compute::VmNic.send(:include, ::FogExtensions::Kubevirt::VmNic)
+
+        require "fog/kubevirt/compute/models/networkattachmentdef"
+        require File.expand_path("../../app/models/concerns/fog_extensions/kubevirt/network", __dir__)
+        Fog::Kubevirt::Compute::Networkattachmentdef.send(:include, ::FogExtensions::Kubevirt::Network)
+      rescue StandardError => e
+        Rails.logger.warn "Foreman-Kubevirt: skipping engine hook (#{e})"
+      end
+    end
+
+    initializer "foreman_kubevirt.register_gettext", after: :load_config_initializers do |_app|
+      locale_dir = File.join(File.expand_path("../..", __dir__), "locale")
+      locale_domain = "foreman_kubevirt"
+      Foreman::Gettext::Support.add_text_domain locale_domain, locale_dir
+    end
+  end
+end

data/lib/foreman_kubevirt/version.rb

@@ -0,0 +1,3 @@
+module ForemanKubevirt
+  VERSION = '0.1.0'.freeze
+end

data/lib/foreman_kubevirt.rb

@@ -0,0 +1,4 @@
+require 'foreman_kubevirt/engine'
+
+module ForemanKubevirt
+end