fog-kubevirt 0.3.0 → 1.0.1

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

@@ -0,0 +1,71 @@
+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
+
+        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
+        end
+      end
+    end
+  end
+end

data/lib/fog/{compute/kubevirt → kubevirt/compute}/models/vminstance.rb

@@ -1,11 +1,7 @@
-require 'fog/compute/kubevirt/models/vm_data'
-
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Vminstance < Fog::Model
-        extend VmData
-
         identity :name
 
         attribute :namespace,        :aliases => 'metadata_namespace'
@@ -18,8 +14,6 @@ module Fog
         attribute :disks,            :aliases => 'spec_disks'
         attribute :volumes,          :aliases => 'spec_volumes'
         attribute :ip_address,       :aliases => 'status_interfaces_ip'
-        attribute :interfaces,       :aliases => 'spec_interfaces'
-        attribute :networks,         :aliases => 'spec_networks'
         attribute :node_name,        :aliases => 'status_node_name'
         attribute :status,           :aliases => 'status_phase'
 
@@ -28,7 +22,6 @@ module Fog
           status = object[:status]
           spec = object[:spec]
           domain = spec[:domain]
-          disks = parse_disks(domain[:devices][:disks])
           {
             :namespace        => metadata[:namespace],
             :name             => metadata[:name],
@@ -38,10 +31,8 @@ module Fog
             :owner_uid        => metadata.dig(:ownerReferences, 0, :uid),
             :cpu_cores        => domain.dig(:cpu, :cores),
             :memory           => domain[:resources][:requests][:memory],
-            :disks            => disks,
-            :volumes          => parse_volumes(spec[:volumes], disks),
-            :interfaces       => parse_interfaces(domain[:devices][:interfaces]),
-            :networks         => parse_networks(spec[:networks]),
+            :disks            => domain[:devices][:disks],
+            :volumes          => spec[:volumes],
             :ip_address       => status.dig(:interfaces, 0, :ipAddress),
             :node_name        => status[:nodeName],
             :status           => status[:phase]

data/lib/fog/{compute/kubevirt → kubevirt/compute}/models/vminstances.rb

@@ -1,13 +1,13 @@
 require 'fog/core/collection'
-require 'fog/compute/kubevirt/models/vminstance'
+require 'fog/kubevirt/compute/models/vminstance'
 
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Vminstances < Fog::Collection
         attr_reader :kind, :resource_version
 
-        model Fog::Compute::Kubevirt::Vminstance
+        model Fog::Kubevirt::Compute::Vminstance
 
         def all(filters = {})
           begin

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

@@ -0,0 +1,137 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/vm'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Vms < Fog::Collection
+        include Shared
+
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::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
+
+
+        # 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 registry disk
+        # :pvc [String] - name of a persistent volume claim
+        #
+        # One of :image or :pvc needs to be provided.
+        #
+        # @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)
+          image = args.fetch(:image, nil)
+          pvc = args.fetch(:pvc, nil)
+
+          if image.nil? && pvc.nil?
+            raise ::Fog::Kubevirt::Errors::ValidationError
+          end
+          
+          volume = {}
+
+          if !image.nil?
+            volume = {
+              :name => vm_name,
+              :registryDisk => {
+                :image => image
+              }
+            }
+          else
+            volume = {
+              :name => vm_name,
+              :persistentVolumeClaim => {
+                :claimName => pvc
+              }
+            }
+          end
+
+          vm = {
+            :apiVersion => service.class::KUBEVIRT_VERSION_LABEL,
+            :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 => [
+                        {:disk => {
+                           :bus => "virtio"
+                         },
+                         :name => vm_name,
+                         :volumeName => vm_name
+                        }
+                      ]
+                    },
+                    :machine => {
+                      :type => ""
+                    },
+                    :resources => {
+                      :requests => {
+                        :memory => "#{memory_size}M"
+                      }
+                    }
+                  },
+                  :terminationGracePeriodSeconds => 0,
+                  :volumes => [volume]
+                }
+              }
+            }
+          }
+
+          vm = deep_merge!(vm,
+            :spec => {
+              :template => {
+                :spec => {
+                  :domain => {
+                    :cpu => {
+                      :cores => cpus
+                    }
+                  }
+                }
+              }
+            }
+          ) unless cpus.nil?
+
+          service.create_vm(vm)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Fog
+  module Kubevirt
+    class Compute
+      class Volume < Fog::Model
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/volume'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Volumes < Fog::Collection
+        model Fog::Kubevirt::Compute::Volume
+      end
+    end
+  end
+end

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/create_pvc.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def create_pvc(pvc)
           kube_client.create_persistent_volume_claim(pvc)

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/create_vm.rb

@@ -1,9 +1,8 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    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/{compute/kubevirt → kubevirt/compute}/requests/create_vminstance.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
 
         def create_vminstance(vm)

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/delete_vm.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def delete_vm(name, namespace)
           kubevirt_client.delete_virtual_machine(name, namespace)
@@ -8,7 +8,7 @@ module Fog
       end
 
       class Mock
-        def delete_vm(name, namespace)
+        def delete_vm(name)
         end
       end
     end

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/delete_vminstance.rb

@@ -1,14 +1,14 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
-        def delete_vminstance(name)
-          kubevirt_client.delete_virtual_machine_instance(name, @namespace)
+        def delete_vminstance(name, namespace)
+          kubevirt_client.delete_virtual_machine_instance(name, namespace)
         end
       end
 
       class Mock
-        def delete_virtual_machine_instance(name)
+        def delete_virtual_machine_instance(name, namespace = nil)
         end
       end
     end

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/get_node.rb

@@ -1,8 +1,8 @@
 require 'recursive_open_struct'
 
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def get_node(name)
           Node.parse object_to_hash( kube_client.get_node(name) )

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/get_template.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def get_template(name)
           Template.parse object_to_hash( openshift_client.get_template(name, @namespace) )

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/get_vm.rb

@@ -1,13 +1,13 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def get_vm(name)
           Vm.parse get_raw_vm(name)
         end
 
         def get_raw_vm(name)
-          object_to_hash(kubevirt_client.get_virtual_machine(name, @namespace))
+          object_to_hash( kubevirt_client.get_virtual_machine(name, @namespace) )
         end
       end
 

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/get_vminstance.rb

@@ -1,8 +1,8 @@
 require 'recursive_open_struct'
 
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def get_vminstance(name)
           # namespace is defined on the Real object
@@ -30,8 +30,8 @@ module Fog
                                 },
                  :spec       => { :domain => { :cpu     => { :cores => "4" },
                                                :devices => { :disks => [{ :disk       => { :dev => "vda" },
-                                                                          :name       => "containerDisk",
-                                                                          :volumeName => "containervolume"
+                                                                          :name       => "registrydisk",
+                                                                          :volumeName => "registryvolume"
                                                                         },
                                                                         { :disk       => { :dev => "vdb" },
                                                                           :name       => "cloudinitdisk",
@@ -42,8 +42,8 @@ module Fog
                                                :machine    => { :type => "q35" },
                                                :resources  => { :requests => { :memory => "512Mi" }}
                                              },
-                                  :volumes => [ { :name         => "containervolume",
-                                                  :containerDisk => { :image => "kubevirt/fedora-cloud-registry-disk-demo:latest" }
+                                  :volumes => [ { :name         => "registryvolume",
+                                                  :registryDisk => { :image => "kubevirt/fedora-cloud-registry-disk-demo:latest" }
                                                 },
                                                 { :cloudInitNoCloud => { :userDataBase64 => "I2Nsb3VkLWNvbmZpZwpwYXNzd29yZDogYXRvbWljCnNzaF9wd2F1dGg6IFRydWUKY2hwYXNzd2Q6IHsgZXhwaXJlOiBGYWxzZSB9Cg==" },
                                                   :name             => "cloudinitvolume"

data/lib/fog/{compute/kubevirt → kubevirt/compute}/requests/list_nodes.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class Kubevirt
+  module Kubevirt
+    class Compute
       class Real
         def list_nodes(_filters = {})
           nodes = kube_client.get_nodes