fog-kubevirt 1.0.2 → 1.1.0

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

@@ -1,7 +1,11 @@
+require 'fog/kubevirt/compute/models/vm_data'
+
 module Fog
   module Kubevirt
     class Compute
       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'
 
@@ -22,6 +28,7 @@ module Fog
           status = object[:status]
           spec = object[:spec]
           domain = spec[:domain]
+          disks = parse_disks(domain[:devices][:disks])
           {
             :namespace        => metadata[:namespace],
             :name             => metadata[:name],
@@ -31,8 +38,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            => disks,
+            :volumes          => parse_volumes(spec[:volumes], disks),
+            :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/kubevirt/compute/models/vms.rb

@@ -27,6 +27,9 @@ module Fog
           new service.get_vm(name)
         end
 
+        def delete(name)
+          service.delete_vm(name, service.namespace)
+        end
 
         # Creates a virtual machine using provided paramters:
         # :vm_name [String] - name of a vm
@@ -49,7 +52,9 @@ module Fog
         #       :macAddress => '12:34:56:AB:CD:EF' }
         #   ]
         #
-        # One of :image or :pvc needs to be provided.
+        # @param [String] :image name of container disk.
+        #
+        # @param [Array] :volumes the volumes (Fog::Kubevirt::Compute::Volume) to be used by the VM
         #
         # @param [Hash] attributes containing details about vm about to be
         #   created.
@@ -57,23 +62,16 @@ module Fog
           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, {})
           networks = args.fetch(:networks, nil)
           interfaces = args.fetch(:interfaces, nil)
+          vm_volumes =  args.fetch(:volumes, nil)
 
-          if image.nil? && pvc.nil?
+          if vm_volumes.nil? || vm_volumes.empty?
             raise ::Fog::Kubevirt::Errors::ValidationError
           end
 
-          volumes = []
-          volume_name = vm_name.gsub(/[._]+/,'-') + "-disk-01"
-          if !image.nil?
-            volumes.push(:name => volume_name, :containerDisk => {:image => image})
-          else
-            volumes.push(:name => volume_name, :persistentVolumeClaim => {:claimName => pvc})
-          end
+          volumes, disks = add_vm_storage(vm_name, vm_volumes)
 
           unless init.empty?
             volumes.push(:cloudInitNoCloud => init, :name => "cloudinitvolume")
@@ -100,13 +98,7 @@ module Fog
                 :spec => {
                   :domain => {
                     :devices => {
-                      :disks => [
-                        {:disk => {
-                           :bus => "virtio"
-                         },
-                         :name => volume_name,
-                        }
-                      ]
+                      :disks => disks
                     },
                     :machine => {
                       :type => ""
@@ -168,9 +160,46 @@ module Fog
               }
             }
           ) unless interfaces.nil?
-
           service.create_vm(vm)
         end
+
+        def add_vm_storage(vm_name, vm_volumes)
+          normalized_vm_name = vm_name.gsub(/[._]+/,'-')
+          volumes, disks = [], []
+          vm_volumes.each_with_index do |v, idx|
+            volume_name = v.name || normalized_vm_name + "-disk-0" + idx.to_s
+            disk = {
+              :name => volume_name,
+              :disk => {}
+            }
+            disk[:bootOrder] = v.boot_order if v.boot_order
+
+            if v.type == 'containerDisk'
+              # set image
+              if v.config.nil?
+                volumes.push(:name => volume_name, :containerDisk => {:image => v.info})
+              else
+                volumes.push(:name => volume_name, v.type.to_sym => v.config)
+              end
+              disk[:disk][:bus] = v.bus || "virtio"
+            elsif v.type == 'persistentVolumeClaim'
+              # set claim
+              if v.config.nil?
+                volumes.push(:name => volume_name, :persistentVolumeClaim => {:claimName => v.info})
+              else
+                volumes.push(:name => volume_name, v.type.to_sym => v.config)
+              end
+              disk[:disk][:bus] = v.bus || "virtio"
+            else
+              # convert type into symbol and pass :config as volume content
+              volumes.push(:name => volume_name, v.type.to_sym => v.config)
+              disk[:disk][:bus] = v.bus if v.bus
+            end
+            disks.push(disk)
+          end
+
+          return volumes, disks
+        end
       end
     end
   end

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

@@ -1,80 +1,55 @@
+require 'fog/kubevirt/compute/models/pvc'
+
 module Fog
   module Kubevirt
     class Compute
+      # Volumes represents volumes exist on kubevirt for vms:
+      # If volume is attached to a VM by disk, it will contain the attachment properties
+      # Disk Attachment properties are: boot_order and bus (when avaiable).
+      # If the volume isn't attached to any VM, it will contain name, type and info.
+      # When the volume type is persistentVolumeClaim, it will contain also the claim entity
+      # In order to create a new volume, user have to create a Claim when wishes to use PVC
+      # by using the pvcs collection.
       class Volume < Fog::Model
-        identity :name
+          identity :name
 
-        attribute :resource_version, :aliases => 'metadata_resource_version'
-        attribute :uid,              :aliases => 'metadata_uid'
-        attribute :annotations,      :aliases => 'metadata_annotations'
-        attribute :labels,           :aliases => 'metadata_labels'
-		attribute :access_modes,	 :aliases => 'spec_access_modes'
-		attribute :mount_options,	 :aliases => 'spec_mount_options'
-		attribute :reclaim_policy,   :aliases => 'spec_reclaim_policy'
-		attribute :storage_class,    :aliases => 'spec_storage_class'
-        attribute :capacity,         :aliases => 'spec_capacity'
-        attribute :claim_ref,        :aliases => 'spec_claim_ref'
-        attribute :type,			 :aliases => 'spec_type'
-        attribute :config,			 :aliases => 'spec_config'
-        attribute :phase,            :aliases => 'status_phase'
-        attribute :reason,            :aliases => 'status_reason'
-        attribute :message,            :aliases => 'status_message'
+          # values: containerDisk, persistentVolumeClaim, emptyDisk,
+          #         ephemeral, cloudInitNoCloud, hostDisk, secret,
+          #         dataVolume, serviceAccount, configMap
+          attribute :type
 
-        def self.parse(object)
-          metadata = object[:metadata]
-          spec = object[:spec]
-          status = object[:status]
-          type = detect_type(spec)
+          # specific piece of information per volume type
+          # for containerDisk - contains the image
+          # for persistentVolumeClaim - contains the claim name
+          attribute :info
 
-          {
-            :name             => metadata[:name],
-            :resource_version => metadata[:resourceVersion],
-            :uid              => metadata[:uid],
-            :annotations      => metadata[:annotations],
-            :labels           => metadata[:labels],
-            :access_modes     => spec[:accessModes],
-            :mount_options    => spec[:mountOptions],
-            :reclaim_policy   => spec[:persistentVolumeReclaimPolicy],
-			:storage_class    => spec[:storageClassName],
-            :capacity         => spec.dig(:capacity, :storage),
-            :claim_ref        => spec[:claimRef],
-            :type             => type,
-            :config           => spec[type&.to_sym],
-            :phase            => status[:phase],
-            :reason           => status[:reason],
-            :message          => status[:message]
-          }
-        end
+          # holds the pvc entity if its type is persistentVolumeClaim
+          attribute :pvc
+
+          # Hash that holds volume type specific configurations, used for adding volume for a vm
+          # The set of config properties may change from type to type, see documentation for the supported
+          # keys of each volume type:
+          # https://kubevirt.io/user-guide/docs/latest/creating-virtual-machines/disks-and-volumes.html#volumes
+          attribute :config
+
+          # Disk attachment properties, relevant when volumes are fetched via the vm:
+
+          # the order (integer) of the device during boot sequence
+          attribute :boot_order
+
+          # detemines how the disk will be presented to the guest OS if available, supported values are:
+          # virtio, sata or scsi. See https://kubevirt.io/api-reference/master/definitions.html#_v1_disktarget
+          attribute :bus
+
+          def persisted?
+            !name.nil?
+          end
 
-        def self.detect_type(spec)
-            type = ''
-            type = 'awsElasticBlockStore' if spec.keys.include?(:awsElasticBlockStore)
-            type = 'azureDisk' if spec.keys.include?(:azureDisk)
-            type = 'azureFile' if spec.keys.include?(:azureFile)
-            type = 'cephfs' if spec.keys.include?(:cephfs)
-            type = 'configMap' if spec.keys.include?(:configMap)
-            type = 'csi' if spec.keys.include?(:csi)
-            type = 'downwardAPI' if spec.keys.include?(:downwardAPI)
-            type = 'emptyDir' if spec.keys.include?(:emptyDir)
-            type = 'fc' if spec.keys.include?(:fc)
-            type = 'flexVolume' if spec.keys.include?(:flexVolume)
-            type = 'flocker' if spec.keys.include?(:flocker)
-            type = 'gcePersistentDisk' if spec.keys.include?(:gcePersistentDisk)
-            type = 'glusterfs' if spec.keys.include?(:glusterfs)
-            type = 'hostPath' if spec.keys.include?(:hostPath)
-            type = 'iscsi' if spec.keys.include?(:iscsi)
-            type = 'local' if spec.keys.include?(:local)
-            type = 'nfs' if spec.keys.include?(:nfs)
-            type = 'persistentVolumeClaim' if spec.keys.include?(:persistentVolumeClaim)
-            type = 'projected' if spec.keys.include?(:projected)
-            type = 'portworxVolume' if spec.keys.include?(:portworxVolume)
-            type = 'quobyte' if spec.keys.include?(:quobyte)
-            type = 'rbd' if spec.keys.include?(:rbd)
-            type = 'scaleIO' if spec.keys.include?(:scaleIO)
-            type = 'secret' if spec.keys.include?(:secret)
-            type = 'storageos' if spec.keys.include?(:storageos)
-            type = 'vsphereVolume' if spec.keys.include?(:vsphereVolume)
-            type
+        def self.parse(object, disk)
+          byebug
+          volume = parse_object(object)
+          volume[:boot_order] = object[:bootOrder]
+          volume
         end
       end
     end

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

@@ -5,67 +5,12 @@ module Fog
   module Kubevirt
     class Compute
       class Volumes < Fog::Collection
-        attr_reader :kind, :resource_version
-
         model Fog::Kubevirt::Compute::Volume
 
-        def all(filters = {})
-          volumes = service.list_volumes(filters)
-          @kind = volumes.kind
-          @resource_version = volumes.resource_version
-          load volumes
-        end
-
-        def get(name)
-          new service.get_volume(name)
-        end
-
-        # Creates a volume using provided paramters:
-        # :name [String] - name of a volume
-        # :labels [Hash] - a hash of key,values representing the labels
-        # :storage_class [String] - the storage class name of the volume
-        # :capacity [String] - The capacity of the storage if applied
-        # :accessModes [Arr] - the access modes for the volume, values are specified here:
-        #    https://kubernetes.io/docs/concepts/storage/persistent-volumes/#access-modes
-        # :type [String] - the type of the storage
-        # :config [Hash] - storage specific configuration to be applied for the volume
-        #    correlated to the args[:type]
-        # @param [Hash] attributes containing details about volume to be created.
-        def create(args = {})
-          name = args[:name]
-          labels = args[:labels]
-
-          volume = {
-            :apiVersion => "v1",
-            :kind => "PersistentVolume",
-            :metadata => {
-              :name      => name
-            },
-            :spec => {
-              :storageClassName => args[:storage_class]
-            }
-          }
-
-          volume[:metadata][:labels] = labels if labels
-          volume[:spec][:capacity] = {
-            :storage => args[:capacity]
-          } if args[:capacity]
-
-          volume[:spec][:accessModes] = args[:access_modes] if args[:access_modes]
-          volume[:spec][args[:type].to_sym] = args[:config] if args[:type]
-
-          service.create_volume(volume)
-        end
-
-        def delete(name)
-          begin
-            volume = get(name)
-          rescue ::Fog::Kubevirt::Errors::ClientError
-            # the volume doesn't exist
-            volume = nil
-          end
+        attr_accessor :vm
 
-          service.delete_volume(name) unless volume.nil?
+        def all(vm_name = nil)
+          service.list_volumes(vm_name)
         end
       end
     end

data/lib/fog/kubevirt/compute/requests/{create_volume.rb → create_persistentvolume.rb}

@@ -2,7 +2,7 @@ module Fog
   module Kubevirt
     class Compute
       class Real
-        def create_volume(volume)
+        def create_persistentvolume(volume)
           kube_client.create_persistent_volume(volume)
         rescue ::Fog::Kubevirt::Errors::ClientError => err
           log.warn(err)
@@ -11,7 +11,7 @@ module Fog
       end
 
       class Mock
-        def create_volume(volume)
+        def create_persistentvolume(volume)
         end
       end
     end

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

@@ -0,0 +1,18 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Real
+        def create_storageclass(storageclass)
+          kube_storage_client.create_storage_class(storageclass)
+        rescue ::Fog::Kubevirt::Errors::ClientError => err
+          log.warn(err)
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_storage_class(attrs); end
+      end
+    end
+  end
+end

data/lib/fog/kubevirt/compute/requests/{delete_volume.rb → delete_persistentvolume.rb}

@@ -2,13 +2,13 @@ module Fog
   module Kubevirt
     class Compute
       class Real
-        def delete_volume(name)
+        def delete_persistentvolume(name)
           kube_client.delete_persistent_volume(name)
         end
       end
 
       class Mock
-        def delete_volume(name)
+        def delete_persistentvolume(name)
         end
       end
     end

data/lib/fog/kubevirt/compute/requests/{get_volume.rb → delete_storageclass.rb}

@@ -2,13 +2,13 @@ module Fog
   module Kubevirt
     class Compute
       class Real
-        def get_volume(name)
-          Volume.parse object_to_hash(kube_client.get_persistent_volume(name))
+        def delete_storageclass(name)
+          kube_storage_client.delete_storage_class(name)
         end
       end
 
       class Mock
-        def get_volume(name)
+        def delete_storage_class(name)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Fog
       end
 
       class Mock
-        def delete_vm(name)
+        def delete_vm(name, namespace)
         end
       end
     end

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

@@ -2,13 +2,13 @@ module Fog
   module Kubevirt
     class Compute
       class Real
-        def delete_vminstance(name, namespace)
-          kubevirt_client.delete_virtual_machine_instance(name, namespace)
+        def delete_vminstance(name)
+          kubevirt_client.delete_virtual_machine_instance(name, @namespace)
         end
       end
 
       class Mock
-        def delete_virtual_machine_instance(name, namespace = nil)
+        def delete_virtual_machine_instance(name)
         end
       end
     end