fog-kubevirt 1.0.1 → 1.0.2

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

@@ -32,8 +32,22 @@ module Fog
         # :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
+        # :image [String] - name of a container disk
         # :pvc [String] - name of a persistent volume claim
+        # :cloudinit [Hash] - number of items needed to configure cloud-init
+        # :networks[Array] - networks to which the vm should be connected, i.e:
+        #    [ { :name => 'default', :pod => {} } ,
+        #      { :name => 'ovs-red', :multus => { :networkName => 'red'} }
+        #    ]
+        #
+        # :interfaces[Array] - network interfaces for the vm, correlated to
+        #                      :networks section by network's name, i.e.:
+        #   [ { :name => 'default', :bridge => {} },
+        #     { :name       => 'red',  # correlated to networks[networkName]
+        #       :bridge     => {},
+        #       :bootOrder  => 1,      # 1 to boot from network interface
+        #       :macAddress => '12:34:56:AB:CD:EF' }
+        #   ]
         #
         # One of :image or :pvc needs to be provided.
         #
@@ -45,31 +59,27 @@ module Fog
           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)
 
           if image.nil? && pvc.nil?
             raise ::Fog::Kubevirt::Errors::ValidationError
           end
-          
-          volume = {}
 
+          volumes = []
+          volume_name = vm_name.gsub(/[._]+/,'-') + "-disk-01"
           if !image.nil?
-            volume = {
-              :name => vm_name,
-              :registryDisk => {
-                :image => image
-              }
-            }
+            volumes.push(:name => volume_name, :containerDisk => {:image => image})
           else
-            volume = {
-              :name => vm_name,
-              :persistentVolumeClaim => {
-                :claimName => pvc
-              }
-            }
+            volumes.push(:name => volume_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 => {
@@ -94,8 +104,7 @@ module Fog
                         {:disk => {
                            :bus => "virtio"
                          },
-                         :name => vm_name,
-                         :volumeName => vm_name
+                         :name => volume_name,
                         }
                       ]
                     },
@@ -109,7 +118,7 @@ module Fog
                     }
                   },
                   :terminationGracePeriodSeconds => 0,
-                  :volumes => [volume]
+                  :volumes => volumes
                 }
               }
             }
@@ -129,6 +138,37 @@ module Fog
             }
           ) unless cpus.nil?
 
+          vm[:spec][:template][:spec][:domain][:devices][:disks].push(
+            :disk => {
+              :bus => "virtio"
+            },
+            :name => "cloudinitvolume",
+          ) unless init.empty?
+
+          vm = deep_merge!(vm,
+            :spec => {
+              :template => {
+                :spec => {
+                  :networks => networks
+                }
+              }
+            }
+          ) unless networks.nil?
+
+          vm = deep_merge!(vm,
+            :spec => {
+              :template => {
+                :spec => {
+                  :domain => {
+                    :devices => {
+                      :interfaces => interfaces
+                    }
+                  }
+                }
+              }
+            }
+          ) unless interfaces.nil?
+
           service.create_vm(vm)
         end
       end

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

@@ -2,7 +2,80 @@ module Fog
   module Kubevirt
     class Compute
       class Volume < 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

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

@@ -5,7 +5,68 @@ 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
+
+          service.delete_volume(name) unless volume.nil?
+        end
       end
     end
   end

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

@@ -0,0 +1,37 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Real
+        include Shared
+
+        # creates netwrork attachment definition object
+        # @param net_att[Hash] contains the following elements:
+        # metadata[Hash]: the net-attachment-def metadata:
+        #   name[String]: the netwrork attachment definition definition
+        #   spec[Hash]: the specification of the attachment, contains:config
+        #     config[string]: the configuration of the attachment, i.e.
+        #      '{ :cniVersion => "0.3.1", :type => "ovs", :bridge => "red" }'
+        # Example of net_att:
+        # metadata: {
+        #             name: "ovs-red"},
+        #             spec: {
+        #               config: '{ cni_version: "0.3.1", type: "ovs", bridge: "red" }'
+        #           }
+        def create_networkattachmentdef(net_att)
+          if net_att.dig(:metadata, :namespace).nil?
+            net_att = deep_merge!(net_att, metadata: { namespace: @namespace })
+          end
+          kube_net_client.create_network_attachment_definition(net_att)
+        rescue ::Fog::Kubevirt::Errors::ClientError => err
+          log.warn(err)
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_networkattachmentdef(_net_att_def)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Fog
+  module Kubevirt
+    class Compute
+      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/kubevirt/compute/requests/create_vm.rb

@@ -3,6 +3,8 @@ module Fog
     class Compute
       class Real
         def create_vm(vm)
+          vm[:apiVersion] = kubevirt_client.version
+
           kubevirt_client.create_virtual_machine(vm)
         rescue ::Fog::Kubevirt::Errors::ClientError => err
           log.warn(err)

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

@@ -0,0 +1,19 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Real
+        def create_volume(volume)
+          kube_client.create_persistent_volume(volume)
+        rescue ::Fog::Kubevirt::Errors::ClientError => err
+          log.warn(err)
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_volume(volume)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Real
+        def delete_networkattachmentdef(name, namespace)
+          kube_net_client.delete_network_attachment_definition(name, namespace)
+        end
+      end
+
+      class Mock
+        def delete_networkattachmentdef(_name, _namespace)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+module Fog
+  module Kubevirt
+    class Compute
+      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/kubevirt/compute/requests/delete_volume.rb

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

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

@@ -0,0 +1,19 @@
+require 'recursive_open_struct'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Real
+        def get_networkattachmentdef(name)
+          net_attach_def = kube_net_client.get_network_attachment_definition(name, @namespace)
+          Networkattachmentdef.parse object_to_hash(net_attach_def)
+        end
+      end
+
+      class Mock
+        def get_networkattachmentdef(name)
+        end
+      end
+    end
+  end
+end