fog-kubevirt 0.1.6 → 0.1.7

data/lib/fog/compute/kubevirt/models/vm_data.rb

@@ -0,0 +1,163 @@
+module Fog
+  module Compute
+    class Kubevirt
+      module VmData
+
+        #
+        # Returns an array of parsed network interfaces
+        #
+        # @param object [Hash] A hash with raw interfaces data.
+        #
+        def parse_interfaces(object)
+          return {} if object.nil?
+          nics = []
+          object.each do |iface|
+            nic = VmNic.new
+            nic.name = iface[:name]
+            nic.mac_address = iface[:macAddress]
+            nic.type = 'bridge' if iface.keys.include?(:bridge)
+            nic.type = 'slirp' if iface.keys.include?(:slirp)
+            nics << nic
+          end
+
+          nics
+        end
+
+        #
+        # Returns an array of parsed networks
+        #
+        # @param object [Hash] A hash with raw networks data.
+        #
+        def parse_networks(object)
+          return {} if object.nil?
+          networks = []
+          object.each do |net|
+            network = VmNetwork.new
+            network.name = net[:name]
+            network.type = 'pod' if net.keys.include?(:pod)
+            network.type = 'multus' if net.keys.include?(:multus)
+            network.type = 'genie' if net.keys.include?(:genie)
+            networks << network
+          end
+
+          networks
+        end
+
+        #
+        # Returns an array of parsed disks
+        #
+        # @param object [Hash] A hash with raw disks data.
+        #
+        def parse_disks(object)
+          return {} if object.nil?
+          disks = []
+          object.each do |d|
+            disk = VmDisk.new
+            disk.name = d[:name]
+            disk.boot_order = d[:bootOrder]
+            disk.volume_name = d[:volumeName]
+
+            if d.keys.include?(:cdrom)
+              disk.type = 'cdrom'
+              disk.bus = d.dig(:cdrom, :bus)
+              disk.readonly = d.dig(:cdrom, :readonly)
+            elsif d.keys.include?(:disk)
+              disk.type = 'disk'
+              disk.bus = d.dig(:disk, :bus)
+              disk.readonly = d.dig(:disk, :readonly)
+            elsif d.keys.include?(:floppy)
+              disk.type = 'floppy'
+              disk.readonly = d.dig(:floppy, :readonly)
+            elsif d.keys.include?(:lun)
+              disk.type = 'lun'
+              disk.readonly = d.dig(:lun, :readonly)
+            end
+            disks << disk
+          end
+
+          disks
+        end
+
+        #
+        # Returns an array of parsed volumes
+        #
+        # @param object [Hash] A hash with raw volumes data.
+        #
+        def parse_volumes(object)
+          return {} if object.nil?
+          volumes = []
+          object.each do |v|
+            volume = VmVolume.new
+            volume.name = v[:name]
+            if v.keys.include?(:registryDisk)
+              volume.type = 'registryDisk'
+              volume.info = v.dig(:registryDisk, :image)
+            elsif v.keys.include?(:persistentVolumeClaim)
+              volume.type = 'persistentVolumeClaim'
+              volume.info = v.dig(:persistentVolumeClaim, :claimName)
+            elsif v.keys.include?(:emptyDisk)
+              volume.type = 'emptyDisk'
+              volume.info = v.dig(:emptyDisk, :capacity)
+            elsif v.keys.include?(:ephemeral)
+              volume.type = 'ephemeral'
+              volume.info = v.dig(:ephemeral, :persistentVolumeClaim, :claimName)
+            elsif v.keys.include?(:cloudInitNoCloud)
+              volume.type = 'cloudInitNoCloud'
+              volume.info = v.dig(:cloudInitNoCloud, :userDataBase64)
+            elsif v.keys.include?(:hostDisk)
+              volume.type = 'hostDisk'
+              volume.info = v.dig(:hostDisk, :path)
+            elsif v.keys.include?(:secret)
+              volume.type = 'secret'
+              volume.info = v.dig(:secret, :secretName)
+            elsif v.keys.include?(:dataVolume)
+              volume.type = 'dataVolume'
+              volume.info = v.dig(:dataVolume, :name)
+            elsif v.keys.include?(:serviceAccount)
+              volume.type = 'serviceAccount'
+              volume.info = v.dig(:serviceAccount, :serviceAccountName)
+            elsif v.keys.include?(:configMap)
+              volume.type = 'configMap'
+              volume.info = v.dig(:configMap, :name)
+            end
+            volumes << volume
+          end
+
+          volumes
+        end
+
+        class VmNic
+          attr_accessor :name,
+                        :mac_address,
+                        :type, # values: bridge, slirp
+                        :model,
+                        :ports,
+                        :boot_order
+        end
+
+        class VmNetwork
+          attr_accessor :name,
+                        :type # values: multus, pod, genie
+        end
+
+        class VmDisk
+          attr_accessor :name,
+                        :volume_name,
+                        :boot_order,
+                        :type, # values: cdrom, disk, floppy, lun
+                        :bus,
+                        :readonly
+        end
+
+        class VmVolume
+          attr_accessor :name,
+                        # values: registryDisk, persistentVolumeClaim, emptyDisk,
+                        #         ephemeral, cloudInitNoCloud, hostDisk, secret,
+                        #         dataVolume, serviceAccount, configMap
+                        :type,
+                        :info # specific piece of information per volume type
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/kubevirt/models/vminstance.rb

@@ -1,7 +1,11 @@
+require 'fog/compute/kubevirt/models/vm_data'
+
 module Fog
   module Compute
     class Kubevirt
       class Vminstance < Fog::Model
+        extend VmData
+
         identity :name
 
         attribute :namespace,        :aliases => 'metadata_namespace'
@@ -14,6 +18,8 @@ module Fog
         attribute :disks,            :aliases => 'spec_disks'
         attribute :volumes,          :aliases => 'spec_volumes'
         attribute :ip_address,       :aliases => 'status_interfaces_ip'
+        attribute :interfaces,       :aliases => 'spec_interfaces'
+        attribute :networks,         :aliases => 'spec_networks'
         attribute :node_name,        :aliases => 'status_node_name'
         attribute :status,           :aliases => 'status_phase'
 
@@ -31,8 +37,10 @@ module Fog
             :owner_uid        => metadata.dig(:ownerReferences, 0, :uid),
             :cpu_cores        => domain.dig(:cpu, :cores),
             :memory           => domain[:resources][:requests][:memory],
-            :disks            => domain[:devices][:disks],
-            :volumes          => spec[:volumes],
+            :disks            => parse_disks(domain[:devices][:disks]),
+            :volumes          => parse_volumes(spec[:volumes]),
+            :interfaces       => parse_interfaces(domain[:devices][:interfaces]),
+            :networks         => parse_networks(spec[:networks]),
             :ip_address       => status.dig(:interfaces, 0, :ipAddress),
             :node_name        => status[:nodeName],
             :status           => status[:phase]

data/lib/fog/compute/kubevirt/models/vms.rb

@@ -5,6 +5,8 @@ module Fog
   module Compute
     class Kubevirt
       class Vms < Fog::Collection
+        include Shared
+
         attr_reader :kind, :resource_version
 
         model Fog::Compute::Kubevirt::Vm
@@ -24,6 +26,114 @@ module Fog
         def get(name)
           new service.get_vm(name)
         end
+
+        # Creates a virtual machine using provided paramters:
+        # :vm_name [String] - name of a vm
+        # :cpus [String] - number of cpus
+        # :memory_size [String] - amount of memory
+        # :image [String] - name of a registry disk
+        # :pvc [String] - name of a persistent volume claim
+        # :cloudinit [Hash] - number of items needed to configure cloud-init
+        #
+        # One of :image or :pvc needs to be provided.
+        #
+        # @param [Hash] attributes containing details about vm about to be
+        #   created.
+        def create(args = {})
+          vm_name = args.fetch(:vm_name)
+          cpus = args.fetch(:cpus, nil)
+          memory_size = args.fetch(:memory_size)
+          image = args.fetch(:image, nil)
+          pvc = args.fetch(:pvc, nil)
+          init = args.fetch(:cloudinit, {})
+
+          if image.nil? && pvc.nil?
+            raise ::Fog::Kubevirt::Errors::ValidationError
+          end
+          
+          volumes = []
+
+          if !image.nil?
+            volumes.push(:name => vm_name, :registryDisk => {:image => image})
+          else
+            volumes.push(:name => vm_name, :persistentVolumeClaim => {:claimName => pvc})
+          end
+
+          unless init.empty?
+            volumes.push(:cloudInitNoCloud => init, :name => "cloudinitvolume")
+          end
+
+          vm = {
+            :apiVersion => service.class::KUBEVIRT_VERSION_LABEL,
+            :kind => "VirtualMachine",
+            :metadata => {
+              :labels => {
+                :"kubevirt.io/vm" => vm_name,
+              },
+              :name => vm_name,
+              :namespace => service.namespace,
+            },
+            :spec => {
+              :running => false,
+              :template => {
+                :metadata => {
+                  :creationTimestamp => nil,
+                  :labels => {
+                    :"kubevirt.io/vm" => vm_name
+                  }
+                },
+                :spec => {
+                  :domain => {
+                    :devices => {
+                      :disks => [
+                        {:disk => {
+                           :bus => "virtio"
+                         },
+                         :name => vm_name,
+                         :volumeName => vm_name
+                        }
+                      ]
+                    },
+                    :machine => {
+                      :type => ""
+                    },
+                    :resources => {
+                      :requests => {
+                        :memory => "#{memory_size}M"
+                      }
+                    }
+                  },
+                  :terminationGracePeriodSeconds => 0,
+                  :volumes => volumes
+                }
+              }
+            }
+          }
+
+          vm = deep_merge!(vm,
+            :spec => {
+              :template => {
+                :spec => {
+                  :domain => {
+                    :cpu => {
+                      :cores => cpus
+                    }
+                  }
+                }
+              }
+            }
+          ) unless cpus.nil?
+
+          vm[:spec][:template][:spec][:domain][:devices][:disks].push(
+            :disk => {
+              :bus => "virtio"
+            },
+            :name => "cloudinitdisk",
+            :volumeName => "cloudinitvolume"
+          ) unless init.empty?
+
+          service.create_vm(vm)
+        end
       end
     end
   end

data/lib/fog/compute/kubevirt/requests/create_service.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def create_service(srv)
+          kube_client.create_service(srv)
+        rescue ::Fog::Kubevirt::Errors::ClientError => err
+          log.warn(err)
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_service(srv); end
+      end
+    end
+  end
+end

data/lib/fog/compute/kubevirt/requests/delete_service.rb

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def delete_service(name, namespace)
+          kube_client.delete_service(name, namespace)
+        end
+      end
+
+      class Mock
+        def delete_service(name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/kubevirt/requests/get_server.rb

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def get_server(name)
+          vm = get_raw_vm(name)
+          populate_runtime_info(vm)
+          Server.parse vm
+        end
+
+        # Updates a given VM raw entity with vm instance info if exists
+        #
+        # @param vm [Hash] A hash with vm raw data.
+        def populate_runtime_info(vm)
+          vmi = get_vminstance(vm[:metadata][:name])
+          vm[:ip_address] = vmi[:ip_address]
+          vm[:node_name] = vmi[:node_name]
+          vm[:phase] = vmi[:status]
+          vm
+        rescue
+          # do nothing if vmi doesn't exist
+        end
+      end
+
+      class Mock
+        # TODO provide implementation
+        def get_server(name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/kubevirt/requests/get_service.rb

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def get_service(name)
+          Service.parse object_to_hash(kube_client.get_service(name, @namespace))
+        end
+      end
+
+      class Mock
+        def get_service(name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/kubevirt/requests/get_vm.rb

@@ -7,7 +7,7 @@ module Fog
         end
 
         def get_raw_vm(name)
-          object_to_hash( kubevirt_client.get_virtual_machine(name, @namespace) )
+          object_to_hash(kubevirt_client.get_virtual_machine(name, @namespace))
         end
       end
 

data/lib/fog/compute/kubevirt/requests/list_servers.rb

@@ -0,0 +1,25 @@
+require 'recursive_open_struct'
+require 'fog/compute/kubevirt/requests/get_server'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def list_servers(_filters = {})
+          vms = kubevirt_client.get_virtual_machines(namespace: @namespace)
+          entities = vms.map do |kubevirt_obj|
+            vm_obj = object_to_hash(kubevirt_obj)
+            populate_runtime_info(vm_obj)
+            Server.parse vm_obj
+          end
+          EntityCollection.new(vms.kind, vms.resourceVersion, entities)
+        end
+      end
+
+      class Mock
+        def list_servers(_filters = {})
+        end
+      end
+    end
+  end
+end