fog-kubevirt 0.3.0 → 1.0.1

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

@@ -1,61 +0,0 @@
-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.rb

@@ -1,17 +0,0 @@
-require 'fog/compute/kubevirt/models/vm_base'
-
-module Fog
-  module Compute
-    class Kubevirt
-      class Vm < Fog::Model
-        include VmAction
-        extend VmBase
-        define_properties
-
-        def self.parse(object)
-          parse_object(object)
-        end
-      end
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-require 'fog/compute/kubevirt/models/vm_data'
-
-module Fog
-  module Compute
-    class Kubevirt
-      module VmBase
-        include VmData
-
-        def define_properties
-          identity :name
-
-          attribute :namespace,        :aliases => 'metadata_namespace'
-          attribute :resource_version, :aliases => 'metadata_resource_version'
-          attribute :uid,              :aliases => 'metadata_uid'
-          attribute :labels,           :aliases => 'metadata_labels'
-          attribute :owner_reference,  :aliases => 'metadata_owner_reference'
-          attribute :annotations,      :aliases => 'metadata_annotations'
-          attribute :cpu_cores,        :aliases => 'spec_cpu_cores'
-          attribute :memory,           :aliases => 'spec_memory'
-          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)
-          metadata = object[:metadata]
-          spec = object[:spec][:template][:spec]
-          domain = spec[:domain]
-          owner = metadata[:ownerReferences]
-          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            => 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",
-            :machine_type     => domain.dig(:machine, :type)
-          }
-          vm[:owner_reference] = owner unless owner.nil?
-          vm[:annotations] = annotations unless annotations.nil?
-          vm[:cpu_cores] = cpu[:cores] unless cpu.nil?
-          vm[:memory] = mem unless mem.nil?
-
-          vm
-        end
-      end
-
-      module VmAction
-        include Shared
-
-        def start(options = {})
-          # Change the `running` attribute to `true` so that the virtual machine controller will take it and
-          # create the virtual machine instance.
-          vm = service.get_raw_vm(name)
-          vm = deep_merge!(vm,
-            :spec => {
-              :running => true
-            }
-          )
-          service.update_vm(vm)
-        end
-
-        def stop(options = {})
-          vm = service.get_raw_vm(name)
-          vm = deep_merge!(vm,
-            :spec => {
-              :running => false
-            }
-          )
-          service.update_vm(vm)
-        end
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-require 'fog/compute/kubevirt/models/volume'
-
-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]
-
-            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.
-        # @param disks [Array] the disks of the vm associated to the volumes
-        #
-        def parse_volumes(object, disks)
-          return {} if object.nil?
-          volumes = []
-          object.each do |v|
-            volume = Volume.new
-            volume.name = v[:name]
-            if v.keys.include?(:containerDisk)
-              volume.type = 'containerDisk'
-              volume.info = v.dig(:containerDisk, :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
-
-            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
-
-          volumes
-        end
-
-        class VmNic
-          attr_accessor :name,
-                        :mac_address,
-                        :type, # values: bridge, slirp
-                        :model,
-                        :ports,
-                        :boot_order
-          alias :mac :mac_address
-        end
-
-        class VmNetwork
-          attr_accessor :name,
-                        :type # values: multus, pod, genie
-        end
-
-        class VmDisk
-          attr_accessor :name,
-                        :boot_order,
-                        :type, # values: cdrom, disk, floppy, lun
-                        :bus,
-                        :readonly
-        end
-      end
-    end
-  end
-end

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

@@ -1,206 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/kubevirt/models/vm'
-
-module Fog
-  module Compute
-    class Kubevirt
-      class Vms < Fog::Collection
-        include Shared
-
-        attr_reader :kind, :resource_version
-
-        model Fog::Compute::Kubevirt::Vm
-
-        def all(filters = {})
-          begin
-            vms = service.list_vms(filters)
-          rescue ::Fog::Kubevirt::Errors::ClientError
-            # we assume that we get 404
-            vms = []
-          end
-          @kind = vms.kind
-          @resource_version = vms.resource_version
-          load vms
-        end
-
-        def get(name)
-          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
-        # :cpus [String] - number of cpus
-        # :memory_size [String] - amount of memory
-        # :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' }
-        #   ]
-        #
-        # @param [String] :image name of container disk.
-        #
-        # @param [Array] :volumes the volumes (Fog::Compute::Kubevirt::Volume) to be used by the VM
-        #
-        # @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)
-          init = args.fetch(:cloudinit, {})
-          networks = args.fetch(:networks, nil)
-          interfaces = args.fetch(:interfaces, nil)
-          vm_volumes =  args.fetch(:volumes, nil)
-
-          if vm_volumes.nil? || vm_volumes.empty?
-            raise ::Fog::Kubevirt::Errors::ValidationError
-          end
-
-          volumes, disks = add_vm_storage(vm_name, vm_volumes)
-
-          unless init.empty?
-            volumes.push(:cloudInitNoCloud => init, :name => "cloudinitvolume")
-          end
-
-          vm = {
-            :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 => disks
-                    },
-                    :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 => "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
-
-        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
-end