fog-kubevirt 1.0.1 → 1.0.2

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

@@ -0,0 +1,42 @@
+require 'fog/compute/models/server'
+require 'fog/kubevirt/compute/models/vm_base'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Server < Fog::Compute::Server
+        include Shared
+        include VmAction
+        extend VmBase
+        define_properties
+
+        attribute :state, :aliases => 'phase'
+        attribute :ip_address
+        attribute :node_name
+
+        def destroy(options = {})
+          stop(options)
+          service.delete_vm(name, namespace)
+        end
+
+        def ready?
+          running?(status) && running?(state) && !ip_address.empty?
+        end
+
+        def self.parse(object)
+          server = parse_object(object)
+          server[:state] = object[:phase]
+          server[:node_name] = object[:node_name]
+          server[:ip_address] = object[:ip_address]
+          server
+        end
+
+        private
+
+        def running?(status)
+          !status.nil? && 'running'.casecmp(status).zero?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/server'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Servers < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::Server
+
+        def all(filters = {})
+          servers = service.list_servers(filters)
+          @kind = servers.kind
+          @resource_version = servers.resource_version
+          load servers
+        end
+
+        def get(id)
+          new service.get_server(id)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { stopped? }
+          server.start
+          server
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Service < Fog::Model
+        identity :name
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :cluster_ip,       :aliases => 'spec_cluster_ip'
+        attribute :node_port,        :aliases => 'spec_ports_node_port'
+        attribute :port,             :aliases => 'spec_ports_port'
+        attribute :target_port,      :aliases => 'spec_ports_target_port'
+        attribute :selector,         :aliases => 'spec_selector'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          spec = object[:spec]
+          ports = spec[:ports][0]
+          selector = spec[:selector]
+          srv = {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :cluster_ip       => spec[:clusterIP],
+            :node_port        => ports[:nodePort],
+            :port             => ports[:port],
+            :target_port      => ports[:target_port],
+          }
+          srv[:selector] = selector[:special] unless selector.nil?
+
+          srv
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/service'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Services < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::Service
+
+        def all(filters = {})
+          begin
+            srvs = service.list_services(filters)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # we assume that we get 404
+            srvs = []
+          end
+          @kind = srvs.kind
+          @resource_version = srvs.resource_version
+          load srvs
+        end
+
+        def get(name)
+          new service.get_service(name)
+        end
+
+        # Creates a service using provided paramters:
+        # :name [String] - name of a service
+        # :port [int] - a port which will be exposed on node and cluster
+        # :target_port [int] - a vmi port which will be forwarded
+        # :vmi_name [String] - name of a vmi to be selected
+        # :service_type [String] - service type used to create service
+        #
+        # @param [Hash] attributes containing details about service to be
+        #   created.
+        def create(args = {})
+          port = args[:port]
+          name = args[:name]
+          target_port = args[:target_port]
+          vmi_name = args[:vmi_name]
+          service_type = args[:service_type]
+
+          srv = {
+            :apiVersion => "v1",
+            :kind => "Service",
+            :metadata => {
+              :name      => name,
+              :namespace => service.namespace
+            },
+            :spec => {
+              :externalTrafficPolicy => "Cluster",
+              :ports => [
+                {:nodePort   => port,
+                 :port       => port,
+                 :protocol   => "TCP",
+                 :targetPort => target_port
+                }
+              ],
+              :selector => {
+                :"kubevirt.io/vm" => vmi_name
+              },
+              :type => service_type
+            }
+          }
+
+          service.create_service(srv)
+        end
+
+        def delete(name)
+          begin
+            srv = get(name)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # the service doesn't exist
+            srv = nil
+          end
+
+          service.delete_service(name, service.namespace) unless srv.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -1,69 +1,15 @@
+require 'fog/kubevirt/compute/models/vm_base'
+
 module Fog
   module Kubevirt
     class Compute
       class Vm < Fog::Model
-        include Shared
-
-        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'
-
-
-        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
+        include VmAction
+        extend VmBase
+        define_properties
 
         def self.parse(object)
-          metadata = object[:metadata]
-          spec = object[:spec][:template][:spec]
-          domain = spec[:domain]
-          owner = metadata[:ownerReferences]
-          annotations = metadata[:annotations]
-          cpu = domain[:cpu]
-          vm = {
-            :namespace        => metadata[:namespace],
-            :name             => metadata[:name],
-            :resource_version => metadata[:resourceVersion],
-            :uid              => metadata[:uid],
-            :labels           => metadata[:labels],
-            :memory           => domain[:resources][:requests][:memory],
-            :disks            => domain[:devices][:disks],
-            :volumes          => spec[:volumes],
-            :status           => object[:spec][:running].to_s == "true" ? "running" : "stopped"
-          }
-          vm[:owner_reference] = owner unless owner.nil?
-          vm[:annotations] = annotations unless annotations.nil?
-          vm[:cpu_cores] = cpu[:cores] unless cpu.nil?
-
-          vm
+          parse_object(object)
         end
       end
     end

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

@@ -0,0 +1,75 @@
+module Fog
+  module Kubevirt
+    class Compute
+      module VmBase
+        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'
+        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)
+          vm = {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :labels           => metadata[:labels],
+            :disks            => domain[:devices][:disks],
+            :volumes          => spec[:volumes],
+            :status           => object[:spec][:running].to_s == "true" ? "running" : "stopped",
+          }
+          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/kubevirt/compute/models/vm_data.rb

@@ -0,0 +1,164 @@
+module Fog
+  module Kubevirt
+    class Compute
+      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]
+            disk.volume_name = d[:volumeName]
+
+            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.
+        #
+        def parse_volumes(object)
+          return {} if object.nil?
+          volumes = []
+          object.each do |v|
+            volume = VmVolume.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
+            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,
+                        :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
+end