fog-kubevirt 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d98797096ddd6d2f4464998bcdbf56dcac2e9ab
-  data.tar.gz: eea11774097b4c70fe95ecbbef47847c454fa548
+  metadata.gz: ee0eacc3688d804fe65c3b1aad58a83598ea1464
+  data.tar.gz: 3bb93e156ebcfd91ab968472aa820bad4be79f24
 SHA512:
-  metadata.gz: c2ea3b5710d1783c0e4710e625d2a8a8271afe322e196a52d59b27164dcf7f76a770fd95f5b77857a5447a6162a60bc96fbad78415d46c3511e005ce65a11aa0
-  data.tar.gz: 57e59e0eeb42b6542735181069436c234ca1c236fe179b44c8a45eebab6b44e682c247b7d917eacc079aa43dce2b4c18285ae54094c338d775203a8fab747451
+  metadata.gz: b923222a67ec3decae7a438a62ddcaf47c6f2ea9b242479e0359398a253c715300aada3ea9024a97b2ed41a8df694ca304d019d1c1f7653e91cb84f8db57adae
+  data.tar.gz: d4fac11a34371874e4c2a59983cc1168c8ae5e3a09617a63cd74eb51553951beb0f9f0d38fae5c25f58f9ccba485facee7f21b8f88d2404a6787266e7a3a2096

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

@@ -18,12 +18,16 @@ module Fog
       collection :nodes
       model      :vm
       collection :vms
+      model      :persistentvolume
+      collection :persistentvolumes
       model      :pvc
       collection :pvcs
       model      :server
       collection :servers
       model      :service
       collection :services
+      model      :storageclass
+      collection :storageclasses
       model      :template
       collection :templates
       model      :volume
@@ -33,33 +37,38 @@ module Fog
       request :create_networkattachmentdef
       request :create_vm
       request :create_vminstance
+      request :create_persistentvolume
       request :create_pvc
       request :create_service
-      request :create_volume
+      request :create_storageclass
       request :delete_networkattachmentdef
+      request :delete_persistentvolume
       request :delete_pvc
       request :delete_service
+      request :delete_storageclass
       request :delete_vminstance
       request :delete_vm
-      request :delete_volume
       request :get_vminstance
       request :get_networkattachmentdef
       request :get_node
+      request :get_persistentvolume
       request :get_pvc
       request :get_vm
-      request :get_volume
       request :get_server
       request :get_service
+      request :get_storageclass
       request :get_template
       request :list_vminstances
       request :list_nodes
       request :list_networkattachmentdefs
       request :list_vms
+      request :list_persistentvolumes
       request :list_pvcs
-      request :list_volumes
       request :list_servers
       request :list_services
+      request :list_storageclasses
       request :list_templates
+      request :list_volumes
       request :update_vm
 
       module Shared
@@ -166,6 +175,11 @@ module Fog
         #
         NETWORK_GROUP = 'k8s.cni.cncf.io'.freeze
 
+        #
+        # The API group of the Kubernetes network extention:
+        #
+        STORAGE_GROUP = 'storage.k8s.io'.freeze
+
         def initialize(options={})
           require 'kubeclient'
 
@@ -416,12 +430,16 @@ module Fog
             ssl_client_key: ssl_options[:client_key],
           }
 
-          response = ::JSON.parse(RestClient::Resource.new(url, options).get)
+          begin
+            response = ::JSON.parse(RestClient::Resource.new(url, options).get)
+          rescue => e
+            raise ::Fog::Kubevirt::Errors::ClientError, e
+          end
 
           # version detected based on
           # https://github.com/kubernetes-incubator/apiserver-builder/blob/master/docs/concepts/aggregation.md#viewing-discovery-information
           preferredVersion = response["preferredVersion"]
-          return preferredVersion["version"] if preferredVersion 
+          return preferredVersion["version"] if preferredVersion
           response["versions"][0]
         end
 
@@ -441,6 +459,10 @@ module Fog
           create_client('/apis/' + NETWORK_GROUP)
         end
 
+        def kube_storage_client
+          create_client('/apis/' + STORAGE_GROUP)
+        end
+
         def log
           @log
         end

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

@@ -0,0 +1,82 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Persistentvolume < Fog::Model
+        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'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          spec = object[:spec]
+          status = object[:status]
+          type = detect_type(spec)
+
+          {
+            :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
+
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/persistentvolume'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Persistentvolumes < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::Persistentvolume
+
+        def all(filters = {})
+          volumes = service.list_persistentvolumes(filters)
+          @kind = volumes.kind
+          @resource_version = volumes.resource_version
+          load volumes
+        end
+
+        def get(name)
+          new service.get_persistentvolume(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_persistentvolume(volume)
+        end
+
+        def delete(name)
+          begin
+            volume = get(name)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # the volume doesn't exist
+            volume = nil
+          end
+
+          service.delete_persistentvolume(name) unless volume.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Storageclass < Fog::Model
+        # Metadata
+        identity :name
+        attribute :resource_version,  :aliases => 'metadata_resource_version'
+        attribute :uid,               :aliases => 'metadata_uid'
+
+        attribute :mount_options
+        attribute :parameters
+        attribute :provisioner
+        attribute :reclaim_policy
+        attribute :volume_binding_mode
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          {
+            :name                => metadata[:name],
+            :resource_version    => metadata[:resourceVersion],
+            :uid                 => metadata[:uid],
+
+            :parameters          => object[:parameters],
+            :mount_options       => object[:mountOptions],
+            :provisioner         => object[:provisioner],
+            :reclaim_policy      => object[:reclaimPolicy],
+            :volume_binding_mode => object[:volumeBindingMode]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/storageclass'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Storageclasses < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::Storageclass
+
+        def all(filters = {})
+          storageclasses = service.list_storageclasses(filters)
+          @kind = storageclasses.kind
+          @resource_version = storageclasses.resource_version
+          load storageclasses
+        end
+
+        def get(name)
+          new service.get_storageclass(name)
+        end
+
+        # Creates a storage class using provided paramters:
+        # https://kubernetes.io/docs/concepts/storage/storage-classes
+        # :name [String] - name of a storage class
+        # :parameters [Object] - parameters for the provisioner that should create volumes of this storage class
+        # :mount_options [Arr] - mount options for the dynamically provisioned PersistentVolumes of this storage class.
+        # :provisioner [String] - the type of the provisioner
+        # :volume_binding_mode [String] - indicates how PersistentVolumeClaims should be provisioned and bound
+        # :reclaim_policy [String] - the reclaim policy of the created PVs (Defaults to Delete).
+        def create(args = {})
+          storageclass = {
+            :apiVersion => "storage.k8s.io/v1",
+            :kind => "StorageClass",
+            :metadata => {
+              :name      => args[:name],
+            },
+            :parameters          => args[:parameters],
+            :mount_options       => args[:mount_options],
+            :provisioner         => args[:provisioner],
+            :volume_binding_mode => args[:volume_binding_mode],
+            :reclaim_policy      => args[:reclaim_policy]
+          }
+
+          service.create_storageclass(storageclass)
+        end
+
+        def delete(name)
+          begin
+            storageclass = get(name)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # the storageclass doesn't exist
+            storageclass = nil
+          end
+
+          service.delete_storageclass(name) unless storageclass.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,11 @@
+require 'fog/kubevirt/compute/models/vm_data'
+
 module Fog
   module Kubevirt
     class Compute
       module VmBase
+        include VmData
+
         def define_properties
           identity :name
 
@@ -16,6 +20,9 @@ module Fog
           attribute :disks,            :aliases => 'spec_disks'
           attribute :volumes,          :aliases => 'spec_volumes'
           attribute :status,           :aliases => 'spec_running'
+          attribute :interfaces,       :aliases => 'spec_interfaces'
+          attribute :networks,         :aliases => 'spec_networks'
+          attribute :machine_type,     :aliases => 'spec_machine_type'
         end
 
         def parse_object(object)
@@ -26,15 +33,19 @@ module Fog
           annotations = metadata[:annotations]
           cpu = domain[:cpu]
           mem = domain.dig(:resources, :requests, :memory)
+          disks = parse_disks(domain[:devices][:disks])
           vm = {
             :namespace        => metadata[:namespace],
             :name             => metadata[:name],
             :resource_version => metadata[:resourceVersion],
             :uid              => metadata[:uid],
             :labels           => metadata[:labels],
-            :disks            => domain[:devices][:disks],
-            :volumes          => spec[:volumes],
+            :disks            => disks,
+            :volumes          => parse_volumes(spec[:volumes], disks),
             :status           => object[:spec][:running].to_s == "true" ? "running" : "stopped",
+            :interfaces       => parse_interfaces(domain[:devices][:interfaces]),
+            :networks         => parse_networks(spec[:networks]),
+            :machine_type     => domain.dig(:machine, :type)
           }
           vm[:owner_reference] = owner unless owner.nil?
           vm[:annotations] = annotations unless annotations.nil?

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

@@ -1,3 +1,5 @@
+require 'fog/kubevirt/compute/models/volume'
+
 module Fog
   module Kubevirt
     class Compute
@@ -55,7 +57,6 @@ module Fog
             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'
@@ -82,12 +83,13 @@ module Fog
         # Returns an array of parsed volumes
         #
         # @param object [Hash] A hash with raw volumes data.
+        # @param disks [Array] the disks of the vm associated to the volumes
         #
-        def parse_volumes(object)
+        def parse_volumes(object, disks)
           return {} if object.nil?
           volumes = []
           object.each do |v|
-            volume = VmVolume.new
+            volume = Volume.new
             volume.name = v[:name]
             if v.keys.include?(:containerDisk)
               volume.type = 'containerDisk'
@@ -120,6 +122,12 @@ module Fog
               volume.type = 'configMap'
               volume.info = v.dig(:configMap, :name)
             end
+
+            volume.config = v[volume.type.to_sym]
+            disk = disks.select { |d| d.name == volume.name }.first
+            volume.boot_order = disk.boot_order
+            volume.bus = disk.bus if disk.respond_to?(:bus)
+
             volumes << volume
           end
 
@@ -143,21 +151,11 @@ module Fog
 
         class VmDisk
           attr_accessor :name,
-                        :volume_name,
                         :boot_order,
                         :type, # values: cdrom, disk, floppy, lun
                         :bus,
                         :readonly
         end
-
-        class VmVolume
-          attr_accessor :name,
-                        # values: containerDisk, persistentVolumeClaim, emptyDisk,
-                        #         ephemeral, cloudInitNoCloud, hostDisk, secret,
-                        #         dataVolume, serviceAccount, configMap
-                        :type,
-                        :info # specific piece of information per volume type
-        end
       end
     end
   end