fog-kubevirt 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa2d9409a7b3472593ad9f4851e75b1e702d6be9
-  data.tar.gz: bb3258447667e18c78273407587d4adbf25ff308
+  metadata.gz: 25a9419e80245eff2f02bac207711317b6503432
+  data.tar.gz: 530e0f33df50161f668f78bc57d25b00c1b10951
 SHA512:
-  metadata.gz: a866f0a383c98f3f08e913374d9b0d4d7a57059423848ce96628119ff20bf122d2d459cb5ed5888793a11e4a6ff2044604ca7f531a1c004a28b167468c4b7b07
-  data.tar.gz: 4c972287cffa8afcc7b81730115daf8bbe5052124dda86d62c92fa95b3abfc04074812b9ce9bae29c863687712577a26bee539896c9757191a057b73b6890a36
+  metadata.gz: f5c986661f483f6c05e9b20f4b8d7ce2b04fa4e079d6b0e228d6fe69698e9ed9197c072a1e49661b87cff6d76a8782cdaf9e46fe30d54053dd0ddf3db95cfe4c
+  data.tar.gz: 807de8ea60c22dde2538805218be5eb80105b081701cb65ad470636a9f01012d4d3c209b860092ba9ecc1e96c3f5c715690d7e679298a7ab7d7cd0eb86123b87

data/lib/fog/compute/kubevirt.rb

@@ -19,12 +19,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
@@ -34,33 +38,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
@@ -167,6 +176,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'
 
@@ -355,7 +369,7 @@ module Fog
             create_client_from_config(path)
           else
             create_client_from_token(url)
-          end          
+          end
         end
 
         def create_client_from_token(url)
@@ -429,7 +443,7 @@ module Fog
           # 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
 
@@ -449,6 +463,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/compute/kubevirt/models/persistentvolume.rb

@@ -0,0 +1,82 @@
+module Fog
+  module Compute
+    class Kubevirt
+      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/compute/kubevirt/models/persistentvolumes.rb

@@ -0,0 +1,73 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/persistentvolume'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Persistentvolumes < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Compute::Kubevirt::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/compute/kubevirt/models/storageclass.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class Kubevirt
+      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/compute/kubevirt/models/storageclasses.rb

@@ -0,0 +1,61 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/storageclass'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Storageclasses < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Compute::Kubevirt::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/compute/kubevirt/models/vm_base.rb

@@ -33,14 +33,15 @@ 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            => parse_disks(domain[:devices][:disks]),
-            :volumes          => parse_volumes(spec[:volumes]),
+            :disks            => disks,
+            :volumes          => parse_volumes(spec[:volumes], disks),
             :interfaces       => parse_interfaces(domain[:devices][:interfaces]),
             :networks         => parse_networks(spec[:networks]),
             :status           => object[:spec][:running].to_s == "true" ? "running" : "stopped",

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

@@ -1,3 +1,5 @@
+require 'fog/compute/kubevirt/models/volume'
+
 module Fog
   module Compute
     class Kubevirt
@@ -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,27 +151,11 @@ module Fog
 
         class VmDisk
           attr_accessor :name,
-                        :volume_name,
                         :boot_order,
                         :type, # values: cdrom, disk, floppy, lun
                         :bus,
                         :readonly
         end
-
-        class VmVolume < Fog::Model
-          identity :name
-          attribute :id
-          # values: containerDisk, persistentVolumeClaim, emptyDisk,
-          #         ephemeral, cloudInitNoCloud, hostDisk, secret,
-          #         dataVolume, serviceAccount, configMap
-          attribute :type
-
-          attribute :info # specific piece of information per volume type
-
-          def persisted?
-            !name.nil?
-          end
-        end
       end
     end
   end