fog-kubevirt 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db04da9d9e8117993d2eb4fc4630d6e670e19906
-  data.tar.gz: 7dd7992382563c3ce868a8e694c743295c329595
+  metadata.gz: 503961b1ff1942c2afe14fb611d555cbe7f3020d
+  data.tar.gz: 63e5dd9843c6d843394a830d2aa725cc6511b605
 SHA512:
-  metadata.gz: 68653cae72af67f1d417718b95f89bcdc8fa96606fffbd0dd0035ead0a89b713ea801bd0e038f8ed5e49c7ee0bd14b56e1adb2cbdccda21f954d0d1b000b0533
-  data.tar.gz: c6b2b9f6d0bdeb9eb5e4a62962aa90fc8c654e81b8a182737935258b2fdfaa7003ca090e9d5b0c0b47819feabbbdf25b24c59877549e40fdba18c606ed85f607
+  metadata.gz: 646e2fcf922326488c8e98885624f0315ab876b9c2beed165783b4bcaeae12f8ca8ed8bfb69c98de8cb4b6a0ed6d3397d2f6e80b57a816c30baf88998ff539ec
+  data.tar.gz: 572ac0f6197416be7f96a5c2d5054d5788ef337d809a1e84dca69ecba87ac82a4de35a49091320730622a42b363fc316d3756231a4f3789cb2fa62238ef3487e

data/lib/fog/compute/kubevirt.rb

@@ -1,12 +1,19 @@
+require 'delegate'
+require 'logger'
+
+require "fog/core"
+
 module Fog
   module Compute
     class Kubevirt < Fog::Service
       requires   :kubevirt_token
-      recognizes :kubevirt_hostname, :kubevirt_port
+      recognizes :kubevirt_hostname, :kubevirt_port, :kubevirt_namespace, :kubevirt_log
 
       model_path 'fog/compute/kubevirt/models'
       model      :livevm
       collection :livevms
+      model      :node
+      collection :nodes
       model      :offlinevm
       collection :offlinevms
       model      :template
@@ -19,16 +26,38 @@ module Fog
       request :create_vm
       request :create_offlinevm
       request :create_pvc
-      request :destroy_vm
+      request :delete_livevm
+      request :delete_offlinevm
       request :get_livevm
+      request :get_node
       request :get_offlinevm
       request :get_template
       request :list_livevms
+      request :list_nodes
       request :list_offlinevms
       request :list_templates
       request :update_offlinevm
 
       module Shared
+
+        class EntityCollection < DelegateClass(Array)
+          attr_reader :kind, :resource_version, :uid, :type
+
+          def initialize(kind, resource_version, uid, type, entities)
+            @kind = kind
+            @resource_version = resource_version
+            @uid = uid
+            @type = type
+            super(entities)
+          end
+        end
+
+        #
+        # Label name which identifies operation system information
+        #
+        OS_LABEL = 'kubevirt.io/os'.freeze
+        OS_LABEL_SYMBOL = :'kubevirt.io/os'
+
         # converts kubeclient objects into hash for fog to consume
         def object_to_hash(object)
           result = object
@@ -44,9 +73,31 @@ module Fog
 
           result
         end
+
+        # Copied from rails:
+        # File activesupport/lib/active_support/core_ext/hash/deep_merge.rb, line 21
+        # The method was changed to look like this in v4.0.0 of rails
+        def deep_merge!(source_hash, other_hash, &block)
+          other_hash.each_pair do |current_key, other_value|
+            this_value = source_hash[current_key]
+
+            source_hash[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+                                         this_value = deep_merge!(this_value, other_value, &block)
+                                       else
+                                         if block_given? && key?(current_key)
+                                           block.call(current_key, this_value, other_value)
+                                         else
+                                           other_value
+                                         end
+                                       end
+          end
+
+          source_hash
+        end
       end
 
       class Real
+        require "ostruct"
         include Shared
 
         #
@@ -65,8 +116,11 @@ module Fog
           require 'kubeclient'
 
           @kubevirt_token = options[:kubevirt_token]
-          @host  = options[:kubevirt_hostname]
-          @port  = options[:kubevirt_port]
+          @host = options[:kubevirt_hostname]
+          @port = options[:kubevirt_port]
+
+          @log = options[:kubevirt_log]
+          @log ||= Logger.new(STDOUT)
 
           @namespace = options[:kubevirt_namespace] || 'default'
 
@@ -84,26 +138,149 @@ module Fog
           # Kubeclient needs different client objects for different API groups. We will keep in this hash the
           # client objects, indexed by API path/version.
           @clients = {}
+        end
 
-          @client = kubevirt_client()
+        def virt_supported?
+          virt_enabled = false
+
+          begin
+            virt_enabled = kubevirt_client.api["versions"].any? { |ver| ver["groupVersion"]&.start_with?(KUBEVIRT_GROUP) }
+          rescue => err
+            # we failed to communicate or to evaluate the version format
+            @log.warn("Failed to detect kubevirt on provider with error: #{err.message}")
+          end
 
-          # TODO expect a specific token
-          @oc_client = openshift_client()
-          @kube_client = kube_client()
+          virt_enabled
         end
 
-        private
+        def valid?
+          kube_client.api_valid?
+        end
 
-        def client
-          @client
+        class WatchWrapper
+
+          def initialize(watch, mapper)
+            @watch = watch
+            @mapper = mapper
+          end
+
+          def each
+            @watch.each do |notice|
+              yield @mapper.call(notice)
+            end
+          end
+
+          def finish
+            @watch.finish
+          end
         end
 
-        def oc_client
-          @oc_client
+        #
+        # Returns a watcher for nodes.
+        #
+        # @param opts [Hash] A hash with options for the watcher.
+        # @return [WatchWrapper] The watcher.
+        #
+        def watch_nodes(opts = {})
+          mapper = Proc.new do |notice|
+            node = OpenStruct.new(Node.parse(notice.object)) if notice.object.kind == 'Node'
+            node ||= OpenStruct.new
+
+            populate_notice_attributes(node, notice)
+            node
+          end
+          watch = kube_client.watch_nodes(opts)
+
+          WatchWrapper.new(watch, mapper)
         end
 
-        def kube_client
-          @kubeclient
+        #
+        # Returns a watcher for offline virtual machines.
+        #
+        # @param opts [Hash] A hash with options for the watcher.
+        # @return [WatchWrapper] The watcher.
+        #
+        def watch_offline_vms(opts = {})
+          mapper = Proc.new do |notice|
+            offlinevm = OpenStruct.new(Offlinevm.parse(notice.object)) if notice.object.kind == 'OfflineVirtualMachine'
+            offlinevm ||= OpenStruct.new
+
+            populate_notice_attributes(offlinevm, notice)
+            offlinevm
+          end
+          watch = kubevirt_client.watch_offline_virtual_machines(opts)
+
+          WatchWrapper.new(watch, mapper)
+        end
+
+        #
+        # Returns a watcher for live virtual machines.
+        #
+        # @param opts [Hash] A hash with options for the watcher.
+        # @return [WatchWrapper] The watcher.
+        #
+        def watch_live_vms(opts = {})
+          mapper = Proc.new do |notice|
+            livevm = OpenStruct.new(Livevm.parse(notice.object)) if notice.object.kind == 'VirtualMachine'
+            livevm ||= OpenStruct.new
+
+            populate_notice_attributes(livevm, notice)
+            livevm
+          end
+          watch = kubevirt_client.watch_virtual_machines(opts)
+
+          WatchWrapper.new(watch, mapper)
+        end
+
+        #
+        # Returns a watcher for templates.
+        #
+        # @param opts [Hash] A hash with options for the watcher.
+        # @return [WatchWrapper] The watcher.
+        #
+        def watch_templates(opts = {})
+          mapper = Proc.new do |notice|
+            template = OpenStruct.new(Template.parse(notice.object)) if notice.object.kind == 'Template'
+            template ||= OpenStruct.new
+
+            populate_notice_attributes(template, notice)
+            template
+          end
+          watch = openshift_client.watch_templates(opts)
+
+          WatchWrapper.new(watch, mapper)
+        end
+
+        #
+        # Calculates the URL of the SPICE proxy server.
+        #
+        # @return [String] The URL of the spice proxy server.
+        #
+        def spice_proxy_url
+          service = kube_client.get_service('spice-proxy', @namespace)
+          host = service.spec.externalIPs.first
+          port = service.spec.ports.first.port
+          url = URI::Generic.build(
+            :scheme => 'http',
+            :host   => host,
+            :port   => port,
+          )
+          url.to_s
+        end
+
+        private
+
+
+        #
+        # Populates required notice attributes
+        #
+        # @param object entity to populate
+        # @param notice the source of the data to populate from
+        def populate_notice_attributes(object, notice)
+          object.metadata = notice.object.metadata
+          object.type = notice.type
+          object.code = notice.object.code
+          object.kind = notice.object.kind
         end
 
         #
@@ -148,6 +325,10 @@ module Fog
         def kubevirt_client
           create_client('/apis/' + KUBEVIRT_GROUP, KUBEVIRT_VERSION)
         end
+
+        def log
+          @log
+        end
       end
 
       class Mock

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

@@ -13,9 +13,12 @@ module Fog
         attribute :memory,           :aliases => 'spec_memory'
         attribute :disks,            :aliases => 'spec_disks'
         attribute :volumes,          :aliases => 'spec_volumes'
+        attribute :ip_address,       :aliases => 'status_interfaces_ip'
+        attribute :node_name,        :aliases => 'status_node_name'
 
         def self.parse(object)
           metadata = object[:metadata]
+          status = object[:status]
           owner = metadata[:ownerReferences][0]
           spec = object[:spec]
           domain = spec[:domain]
@@ -29,7 +32,9 @@ module Fog
             :cpu_cores        => domain[:cpu][:cores],
             :memory           => domain[:resources][:requests][:memory],
             :disks            => domain[:devices][:disks],
-            :volumes          => spec[:volumes]
+            :volumes          => spec[:volumes],
+            :ip_address       => status.dig(:interfaces, 0, :ipAddress),
+            :node_name        => status[:nodeName]
           }
         end
       end

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

@@ -5,15 +5,35 @@ module Fog
   module Compute
     class Kubevirt
       class Livevms < Fog::Collection
+        attr_reader :kind, :resourceVersion
+
         model Fog::Compute::Kubevirt::Livevm
 
         def all(filters = {})
-          load service.list_livevms(filters)
+          vms = service.list_livevms(filters)
+          kind = vms.kind
+          resourceVersion = vms.resourceVersion
+          load vms
         end
 
         def get(name)
           new service.get_livevm(name)
         end
+
+        def destroy(name, namespace)
+          begin
+            live_vm = get(name)
+          rescue KubeException
+            # the live virtual machine doesn't exist
+            live_vm = nil
+          end
+
+          # delete offline vm
+          service.delete_offlinevm(name, namespace)
+
+          # delete live vm
+          service.delete_livevm(name, namespace) unless live_vm.nil?
+        end
       end
     end
   end

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

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Node < Fog::Model
+        identity :name
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :uid,              :aliases => 'metadata_uid'
+        attribute :os_image,         :aliases => 'status_node_info_os_image'
+        attribute :operating_system, :aliases => 'status_node_info_operating_system'
+        attribute :kernel_version,   :aliases => 'status_node_info_kernel_version'
+        attribute :hostname,         :aliases => 'status_addresses_hostname'
+        attribute :ip_address,       :aliases => 'status_addresses_ip'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          status = object[:status]
+          info = status[:nodeInfo]
+
+          addresses = status[:addresses]
+          hostname = addresses.detect { |address| address[:type] == 'Hostname' }[:address]
+          ip = addresses.detect { |address| address[:type] == 'InternalIP' }[:address]
+          {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :os_image         => info[:osImage],
+            :operating_system => info[:operatingSystem],
+            :kernel_version   => info[:kernelVersion],
+            :hostname         => hostname,
+            :ip_address       => ip
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/node'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Nodes < Fog::Collection
+        attr_reader :kind, :resourceVersion
+
+        model Fog::Compute::Kubevirt::Node
+
+        def all(filters = {})
+          nodes = service.list_nodes(filters)
+          kind = nodes.kind
+          resourceVersion = nodes.resourceVersion
+          load nodes
+        end
+
+        def get(name)
+          new service.get_node(name)
+        end
+      end
+    end
+  end
+end

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

@@ -2,11 +2,16 @@ module Fog
   module Compute
     class Kubevirt
       class Offlinevm < 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'
@@ -14,10 +19,10 @@ module Fog
 
 
         def start(options = {})
-          # Change the `running` attribute to `true` so that the offline virtual machine controller will take it and create
-          # the live virtual machine.
+          # Change the `running` attribute to `true` so that the offline virtual machine controller will take it and
+          # create the live virtual machine.
           offline_vm = service.get_raw_offlinevm(name)
-          offline_vm = offline_vm.deep_merge(
+          offline_vm = deep_merge!(offline_vm,
             :spec => {
               :running => true
             }
@@ -26,6 +31,13 @@ module Fog
         end
 
         def stop(options = {})
+          offline_vm = service.get_raw_offlinevm(name)
+          offline_vm = deep_merge!(offline_vm,
+            :spec => {
+              :running => false
+            }
+          )
+          service.update_offline_vm(offline_vm)
         end
 
         def self.parse(object)
@@ -37,6 +49,9 @@ module Fog
             :name             => metadata[:name],
             :resource_version => metadata[:resourceVersion],
             :uid              => metadata[:uid],
+            :labels           => metadata[:labels],
+            :annotations      => metadata[:annotations],
+            :owner_reference  => metadata[:ownerReferences],
             :cpu_cores        => domain[:cpu][:cores],
             :memory           => domain[:resources][:requests][:memory],
             :disks            => domain[:devices][:disks],

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

@@ -5,10 +5,15 @@ module Fog
   module Compute
     class Kubevirt
       class Offlinevms < Fog::Collection
+        attr_reader :kind, :resourceVersion
+
         model Fog::Compute::Kubevirt::Offlinevm
 
         def all(filters = {})
-          load service.list_offlinevms(filters)
+          ovms = service.list_offlinevms(filters)
+          kind = ovms.kind
+          resourceVersion = ovms.resourceVersion
+          load ovms
         end
 
         def get(name)

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

@@ -2,14 +2,16 @@ module Fog
   module Compute
     class Kubevirt
       class Template < Fog::Model
-        identity :name,              aliases: 'metadata_name'
-
-        attribute :namespace,        aliases: 'metadata_namespace'
-        attribute :description,      aliases: 'metadata_description'
-        attribute :tags,             aliases: 'metadata_tags'
-        attribute :labels,           aliases: 'metadata_labels'
-        attribute :resource_version, aliases: 'metadata_resource_version'
-        attribute :uid,              aliases: 'metadata_uid'
+        include Shared
+        identity :name,              :aliases => 'metadata_name'
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :description,      :aliases => 'metadata_description'
+        attribute :tags,             :aliases => 'metadata_tags'
+        attribute :labels,           :aliases => 'metadata_labels'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :uid,              :aliases => 'metadata_uid'
+        attribute :annotations,      :aliases => 'metadata_annotations'
         attribute :objects
         attribute :parameters
 
@@ -27,16 +29,17 @@ module Fog
           metadata = object[:metadata]
           annotations = metadata[:annotations]
           {
-            namespace: metadata[:namespace],
-            name: metadata[:name],
-            description: annotations[:description],
-            tags: annotations[:tags],
-            labels: metadata[:labels],
-            resource_version: metadata[:resourceVersion],
-            uid: metadata[:uid],
-            objects: object[:objects],
-            parameters: object[:parameters],
-          }
+            :namespace        => metadata[:namespace],
+            :annotations      => metadata[:annotations],
+            :name             => metadata[:name],
+            :labels           => metadata[:labels],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :objects          => object[:objects],
+            :parameters       => object[:parameters],
+            :description      => annotations && annotations[:description],
+            :tags             => annotations && annotations[:tags]
+          }.compact
         end
 
         private
@@ -70,13 +73,24 @@ module Fog
         #
         def create_offline_vm(offline_vm, params, namespace)
           offline_vm = param_substitution!(offline_vm, params)
-
-          offline_vm = offline_vm.deep_merge(
+          os_labels = labels || {}
+          offline_vm = deep_merge!(offline_vm,
+            :spec     => {
+              :running  => false
+            },
             :metadata => {
               :namespace => namespace
             }
           )
 
+          offline_vm = deep_merge!(offline_vm,
+            :metadata => {
+              :labels => {
+                OS_LABEL => os_labels[OS_LABEL_SYMBOL]
+              }
+            }
+          ) if os_labels[OS_LABEL_SYMBOL]
+
           # Send the request to create the offline virtual machine:
           offline_vm = service.create_offlinevm(offline_vm)
         end
@@ -92,7 +106,7 @@ module Fog
           pvcs.each do |pvc|
             pvc = param_substitution!(pvc, params)
 
-            pvc = pvc.deep_merge(
+            pvc = deep_merge!(pvc,
               :metadata => {
                 :namespace => namespace
               }
@@ -182,4 +196,4 @@ module Fog
       end
     end
   end
-end
+end

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

@@ -5,10 +5,15 @@ module Fog
   module Compute
     class Kubevirt
       class Templates < Fog::Collection
+        attr_reader :kind, :resourceVersion
+
         model Fog::Compute::Kubevirt::Template
 
         def all(filters = {})
-          load service.list_templates(filters)
+          temps = service.list_templates(filters)
+          kind = temps.kind
+          resourceVersion = temps.resourceVersion
+          load temps
         end
 
         def get(name)

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

@@ -4,7 +4,8 @@ module Fog
       class Real
         def create_offlinevm(vm)
           kubevirt_client.create_offline_virtual_machine(vm)
-        rescue KubeException
+        rescue KubeException => err
+          log.warn(err)
           raise ::Fog::Kubevirt::Errors::AlreadyExistsError
         end
       end

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

@@ -5,6 +5,7 @@ module Fog
         def create_pvc(pvc)
           kube_client.create_persistent_volume_claim(pvc)
         rescue Kubeclient::HttpError
+          log.warn(err)
           raise ::Fog::Kubevirt::Errors::AlreadyExistsError
         end
       end

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

@@ -5,6 +5,7 @@ module Fog
         def create_vm(vm)
           kubevirt_client.create_virtual_machine(vm)
         rescue Kubeclient::HttpError
+          log.warn(err)
           raise ::Fog::Kubevirt::Errors::AlreadyExistsError
         end
       end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def delete_livevm(name, namespace)
+          kubevirt_client.delete_virtual_machine(name, namespace)
+        end
+      end
+
+      class Mock
+        def delete_livevm(name, namespace = nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def delete_offlinevm(name, namespace)
+          kubevirt_client.delete_offline_virtual_machine(name, namespace)
+        end
+      end
+
+      class Mock
+        def delete_offlinevm(name)
+        end
+      end
+    end
+  end
+end

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

@@ -5,37 +5,56 @@ module Fog
     class Kubevirt
       class Real
         def get_livevm(name)
-          Livevm.parse object_to_hash( kubevirt_client.get_virtual_machine(name, 'default') )
+          # namespace is defined on the Real object
+          Livevm.parse object_to_hash( kubevirt_client.get_virtual_machine(name, @namespace) )
         end
       end
 
       class Mock
         def get_livevm(name)
-          vm = {:apiVersion=>"kubevirt.io/v1alpha1",
-                :kind=>"VirtualMachine",
-                :metadata=>{:clusterName=>"",
-                            :creationTimestamp=>"2018-02-23T10:12:47Z",
-                            :name=>"demo",
-                            :namespace=>"default",
-                            :ownerReferences=>[{:apiVersion=>"kubevirt.io/v1alpha1",
-                                                :kind=>"OfflineVirtualMachine",
-                                                :name=>"demo",
-                                                :uid=>"57e279c1-17ee-11e8-a9f9-525400a7f647"}],
-                            :resourceVersion=>"84873",
-                            :selfLink=>"/apis/kubevirt.io/v1alpha1/namespaces/default/virtualmachines/demo",
-                            :uid=>"1906421f-1882-11e8-b539-525400a7f647"},
-                :spec=>{:domain=>{:cpu=>{:cores=>"4"},
-                                  :devices=>{:disks=>[{:disk=>{:dev=>"vda"}, :name=>"registrydisk", :volumeName=>"registryvolume"},
-                                                      {:disk=>{:dev=>"vdb"}, :name=>"cloudinitdisk", :volumeName=>"cloudinitvolume"}]},
-                                  :machine=>{:type=>"q35"},
-                                  :resources=>{:requests=>{:memory=>"512Mi"}}},
-                        :volumes=>[{:name=>"registryvolume", :registryDisk=>{:image=>"kubevirt/fedora-cloud-registry-disk-demo:latest"}},
-                                   {:cloudInitNoCloud=>{:userDataBase64=>"I2Nsb3VkLWNvbmZpZwpwYXNzd29yZDogYXRvbWljCnNzaF9wd2F1dGg6IFRydWUKY2hwYXNzd2Q6IHsgZXhwaXJlOiBGYWxzZSB9Cg=="},
-                                    :name=>"cloudinitvolume"}]}}
+          vm = { :apiVersion => "kubevirt.io/v1alpha1",
+                 :kind       => "VirtualMachine",
+                 :metadata   => { :clusterName       => "",
+                                  :creationTimestamp => "2018-02-23T10:12:47Z",
+                                  :name              => "demo",
+                                  :namespace         => "default",
+                                  :ownerReferences   => [{ :apiVersion      => "kubevirt.io/v1alpha1",
+                                                           :kind            => "OfflineVirtualMachine",
+                                                           :name            => "demo",
+                                                           :uid             => "57e279c1-17ee-11e8-a9f9-525400a7f647"
+                                                         }
+                                                        ],
+                                  :resourceVersion   => "84873",
+                                  :selfLink          => "/apis/kubevirt.io/v1alpha1/namespaces/default/virtualmachines/demo",
+                                  :uid               => "1906421f-1882-11e8-b539-525400a7f647"
+                                },
+                 :spec       => { :domain => { :cpu     => { :cores => "4" },
+                                               :devices => { :disks => [{ :disk       => { :dev => "vda" },
+                                                                          :name       => "registrydisk",
+                                                                          :volumeName => "registryvolume"
+                                                                        },
+                                                                        { :disk       => { :dev => "vdb" },
+                                                                          :name       => "cloudinitdisk",
+                                                                          :volumeName => "cloudinitvolume"
+                                                                        }
+                                                                       ]
+                                                           },
+                                               :machine    => { :type => "q35" },
+                                               :resources  => { :requests => { :memory => "512Mi" }}
+                                             },
+                                  :volumes => [ { :name         => "registryvolume",
+                                                  :registryDisk => { :image => "kubevirt/fedora-cloud-registry-disk-demo:latest" }
+                                                },
+                                                { :cloudInitNoCloud => { :userDataBase64 => "I2Nsb3VkLWNvbmZpZwpwYXNzd29yZDogYXRvbWljCnNzaF9wd2F1dGg6IFRydWUKY2hwYXNzd2Q6IHsgZXhwaXJlOiBGYWxzZSB9Cg==" },
+                                                  :name             => "cloudinitvolume"
+                                                }
+                                              ]
+                                  }
+               }
           object = RecursiveOpenStruct.new(vm, recurse_over_arrays: true)
           Livevm.parse object_to_hash(object)
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,112 @@
+require 'recursive_open_struct'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def get_node(name)
+          Node.parse object_to_hash( kube_client.get_node(name) )
+        end
+      end
+
+      class Mock
+        def get_livevm(name)
+          node = {:apiVersion => "v1",
+                  :kind => "Node",
+                  :metadata => {
+                    :annotations => {
+                      :volumes.kubernetes.io/controller-managed-attach-detach => "true"
+                    },
+                    :creationTimestamp => "2018-04-09T15:34:26Z",
+                    :labels => {
+                      :beta.kubernetes.io/arch => "amd64", :beta.kubernetes.io/os => "linux",
+                      :kubernetes.io/hostname => "master", :node-role.kubernetes.io/master => "true",
+                      :openshift-infra => "apiserver", :region => "infra", :zone => "default"
+                    },
+                    :name => "master",
+                    :resourceVersion => "1514501",
+                    :selfLink => "/api/v1/nodes/master",
+                    :uid => "7c4102a6-3c0b-11e8-ad43-525400a36119"
+                  },
+                  :spec => {
+                    :externalID => "master"
+                  },
+                  :status => {
+                    :addresses => [
+                      {:address => "192.168.200.2", :type => "InternalIP"},
+                      {:address => "master", :type => "Hostname"}
+                    ],
+                    :allocatable => {:cpu => "2", :memory => "2739328Ki", :pods => "20"},
+                    :capacity => {:cpu => "2", :memory => "2841728Ki", :pods => "20"},
+                    :conditions => [
+                      {
+                        :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-09T15:34:26Z",
+                        :message => "kubelet has sufficient disk space available", :reason => "KubeletHasSufficientDisk",
+                        :status => "False", :type => "OutOfDisk"
+                      },
+                      {
+                        :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-09T15:34:26Z",
+                        :message => "kubelet has sufficient memory available", :reason => "KubeletHasSufficientMemory",
+                        :status => "False", :type => "MemoryPressure"
+                      },
+                      {
+                        :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-19T12:56:17Z",
+                        :message => "kubelet has disk pressure", :reason => "KubeletHasDiskPressure",
+                        :status => "True", :type => "DiskPressure"
+                      },
+                      {
+                        :lastHeartbeatTime => "2018-04-20T09:37:45Z", :lastTransitionTime => "2018-04-20T07:08:18Z",
+                        :message => "kubelet is posting ready status", :reason => "KubeletReady",
+                        :status => "True", :type => "Ready"
+                      }
+                    ],
+                    :daemonEndpoints => {
+                      :kubeletEndpoint => {
+                        :Port => 10250
+                      }
+                    },
+                    :images => [
+                      {
+                        :names => ["docker.io/openshift/openvswitch@sha256:2783e9bc552ea8c4ea725a9f88e353330243b010925c274561ba045974ce4000",
+                                   "docker.io/openshift/openvswitch:v3.9.0-alpha.4"], :sizeBytes => 1474465582
+                      },
+                      {
+                        :names => ["docker.io/openshift/node@sha256:e092f1267535714070761844a62cdd38ce05e63a836ee55196953b8ac69527ba",
+                                   "docker.io/openshift/node:v3.9.0-alpha.4"], :sizeBytes => 1472685816
+                      },
+                      {
+                        :names => ["docker.io/openshift/origin@sha256:4a3d8819499307c57dbb7d244b719c0e45068ca54727ef30b53a361cbe7d9430",
+                                   "docker.io/openshift/origin:v3.9.0-alpha.4"], :sizeBytes => 1257103966
+                      },
+                      {
+                        :names => ["docker.io/ansibleplaybookbundle/apb-base@sha256:639d623b8185dd1471d38d2cc554efe7e2440a69d9a44cefa6b5565e8cc0d89c",
+                                   "docker.io/ansibleplaybookbundle/apb-base:latest"], :sizeBytes => 658504560
+                      },
+                      {
+                        :names => ["registry.fedoraproject.org/latest/etcd@sha256:0656877d3888ca8b385bfc720fede845de185f0b5d29a0bbc7a2fb8c6fc8137a",
+                                   "registry.fedoraproject.org/latest/etcd:latest"], :sizeBytes => 308700638
+                      },
+                      {
+                        :names => ["docker.io/fedora@sha256:7e2fc11763119c0cc0781400bb571bf2033c45469ebe286f1f090ba0dcffc32e",
+                                   "docker.io/fedora:26"], :sizeBytes => 231669643
+                      },
+                      {
+                        :names => ["docker.io/openshift/origin-pod@sha256:ba180ba987ad1f07187c35e2369923b04fb8969a4344064feb38de508d65c385",
+                                   "docker.io/openshift/origin-pod:v3.9.0-alpha.4"], :sizeBytes => 228576414
+                      }
+                    ],
+                    :nodeInfo => {
+                      :architecture => "amd64", :bootID => "c2c59d3a-79d4-4661-acff-daf685ae4edc", :containerRuntimeVersion => "docker://1.13.1",
+                      :kernelVersion => "3.10.0-693.21.1.el7.x86_64", :kubeProxyVersion => "v1.9.1+a0ce1bc657", :kubeletVersion => "v1.9.1+a0ce1bc657",
+                      :machineID => "52c01ad890e84b15a1be4be18bd64ecd", :operatingSystem => "linux", :osImage => "CentOS Linux 7 (Core)",
+                      :systemUUID => "52C01AD8-90E8-4B15-A1BE-4BE18BD64ECD"
+                    }
+                  }
+          }
+          object = RecursiveOpenStruct.new(node, recurse_over_arrays: true)
+          Node.parse object_to_hash(object)
+        end
+      end
+    end
+  end
+end

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

@@ -7,11 +7,12 @@ module Fog
         end
 
         def get_raw_offlinevm(name)
-          object_to_hash( kubevirt_client.get_offline_virtual_machine(name, 'default') )
+          object_to_hash( kubevirt_client.get_offline_virtual_machine(name, @namespace) )
         end
       end
 
       class Mock
+        # TODO provide implementation
         def get_offlinevm(name)
         end
 

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

@@ -3,11 +3,12 @@ module Fog
     class Kubevirt
       class Real
         def get_template(name)
-          Template.parse object_to_hash( oc_client.get_template(name, 'default') )
+          Template.parse object_to_hash( openshift_client.get_template(name, @namespace) )
         end
       end
 
       class Mock
+        # TODO provide implementation
         def get_template(name)
         end
       end

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

@@ -3,14 +3,19 @@ module Fog
     class Kubevirt
       class Real
         def list_livevms(_filters = {})
-          kubevirt_client.get_virtual_machines(namespace: 'default').map { |kubevirt_obj| Livevm.parse object_to_hash(kubevirt_obj) }
+          vms = kubevirt_client.get_virtual_machines(namespace: @namespace)
+          entities = vms.map do |kubevirt_obj|
+            Livevm.parse object_to_hash(kubevirt_obj)
+          end
+          EntityCollection.new(vms.kind, vms.resourceVersion, vms.metadata.uid, vms.metadata.type, entities)
         end
       end
 
       class Mock
+        # TODO provide implementation
         def list_livevms(_filters = {})
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def list_nodes(_filters = {})
+          nodes = kube_client.get_nodes
+          entities = nodes.map { |kubevirt_obj| Node.parse object_to_hash(kubevirt_obj) }
+          EntityCollection.new(nodes.kind, nodes.resourceVersion, vms.metadata.uid, vms.metadata.type, entities)
+        end
+      end
+
+      class Mock
+        # TODO provide implementation
+        def list_nodes(_filters = {})
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,11 @@ module Fog
     class Kubevirt
       class Real
         def list_offlinevms(_filters = {})
-          kubevirt_client.get_offline_virtual_machines(namespace: 'default').map { |kubevirt_obj| Offlinevm.parse object_to_hash(kubevirt_obj) }
+          ovms = kubevirt_client.get_offline_virtual_machines(namespace: @namespace)
+          entities = ovms.map do |kubevirt_obj|
+            Offlinevm.parse object_to_hash(kubevirt_obj)
+          end
+          EntityCollection.new(ovms.kind, ovms.resourceVersion, ovms.metadata.uid, ovms.metadata.type, entities)
         end
       end
 
@@ -28,15 +32,15 @@ module Fog
                                                 devices: { disks: [{ disk: { dev: 'vda' },
                                                                      name: 'registrydisk',
                                                                      volumeName: 'registryvolume' },
-                                                                   { disk: { dev: 'vdb' },
-                                                                     name: 'cloudinitdisk',
-                                                                     volumeName: 'cloudinitvolume' }] },
-                                                machine: { type: 'q35' },
-                                                resources: { requests: { memory: '512Mi' } } },
-                                      volumes: [{ name: 'registryvolume',
-                                                  registryDisk: { image: 'kubevirt/fedora-cloud-registry-disk-demo:latest' } },
-                                                { cloudInitNoCloud: { userDataBase64: 'I2Nsb3VkLWNvbmZpZwpwYXNzd29yZDogYXRvbWljCnNzaF9wd2F1dGg6IFRydWUKY2hwYXNzd2Q6IHsgZXhwaXJlOiBGYWxzZSB9Cg==' },
-                                                  name: 'cloudinitvolume' }] }
+                                                                     { disk: { dev: 'vdb' },
+                                                                       name: 'cloudinitdisk',
+                                                                       volumeName: 'cloudinitvolume' }] },
+                                                                       machine: { type: 'q35' },
+                                                                       resources: { requests: { memory: '512Mi' } } },
+                            volumes: [{ name: 'registryvolume',
+                                        registryDisk: { image: 'kubevirt/fedora-cloud-registry-disk-demo:latest' } },
+                            { cloudInitNoCloud: { userDataBase64: 'I2Nsb3VkLWNvbmZpZwpwYXNzd29yZDogYXRvbWljCnNzaF9wd2F1dGg6IFRydWUKY2hwYXNzd2Q6IHsgZXhwaXJlOiBGYWxzZSB9Cg==' },
+                              name: 'cloudinitvolume' }] }
                             }
                           } }]
           object = RecursiveOpenStruct.new(offlinevms, recurse_over_arrays: true)

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

@@ -5,7 +5,11 @@ module Fog
     class Kubevirt
       class Real
         def list_templates(_filters = {})
-          oc_client.get_templates(namespace: 'default').map { |kubevirt_obj| Template.parse object_to_hash(kubevirt_obj) }
+          temps = openshift_client.get_templates(namespace: @namespace)
+          entities = temps.map do |kubevirt_obj|
+            Template.parse object_to_hash(kubevirt_obj)
+          end
+          EntityCollection.new(temps.kind, temps.resourceVersion, temps.metadata.uid, temps.metadata.type, entities)
         end
       end
 
@@ -19,25 +23,26 @@ module Fog
                                      creationTimestamp: '2018-02-22T10:37:28Z',
                                      labels: { :"miq.github.io/kubevirt-is-vm-template" => 'true',
                                                :"miq.github.io/kubevirt-os" => 'rhel-7' },
-                                     annotations: { description: 'OCP kubevirt linux, template',
-                                                    tags: 'kubevirt,ocp,template,linux' } },
-                         objects: [{ apiVersion: 'kubevirt.io/v1alpha1',
-                                     kind: 'OfflineVirtualMachine',
-                                     metadata: { name: '${NAME}' },
-                                     spec: { template: { spec: { domain:
-                                        { cpu: { cores: '${CPU_CORES}' },
-                                          devices: { disks: [{ disk: { dev: 'vda' }, name: 'disk0', volumeName: 'disk0-pvc' }] },
-                                          machine: { type: 'q35' },
-                                          resources: { requests: { memory: '${MEMORY}' } } },
-                                     volumes: [{ name: 'disk0-pvc', persistentVolumeClaim: { claimName: 'linux-vm-pvc-${NAME}' } }] } } } },
-                                   { apiVersion: 'v1',
-                                     kind: 'PersistentVolumeClaim',
-                                     metadata: { name: 'linux-vm-pvc-${NAME}' },
-                                     spec: { accessModes: ['ReadWriteOnce'],
-                                             resources: { requests: { storage: '10Gi' } } } }],
-                         parameters: [{ name: 'NAME', description: 'Name for the new VM' },
-                                      { name: 'MEMORY', description: 'Amount of memory', value: '4096Mi' },
-                                      { name: 'CPU_CORES', description: 'Amount of cores', value: '4' }] }]
+                                               annotations: { description: 'OCP kubevirt linux, template',
+                                                              tags: 'kubevirt,ocp,template,linux' }
+                                   },
+                                                              objects: [{ apiVersion: 'kubevirt.io/v1alpha1',
+                                                                          kind: 'OfflineVirtualMachine',
+                                                                          metadata: { name: '${NAME}' },
+                                                                          spec: { template: { spec: { domain:
+                                                                                                      { cpu: { cores: '${CPU_CORES}' },
+                                                                                                        devices: { disks: [{ disk: { dev: 'vda' }, name: 'disk0', volumeName: 'disk0-pvc' }] },
+                                                                                                        machine: { type: 'q35' },
+                                                                                                        resources: { requests: { memory: '${MEMORY}' } } },
+          volumes: [{ name: 'disk0-pvc', persistentVolumeClaim: { claimName: 'linux-vm-pvc-${NAME}' } }] } } } },
+          { apiVersion: 'v1',
+            kind: 'PersistentVolumeClaim',
+            metadata: { name: 'linux-vm-pvc-${NAME}' },
+            spec: { accessModes: ['ReadWriteOnce'],
+                    resources: { requests: { storage: '10Gi' } } } }],
+          parameters: [{ name: 'NAME', description: 'Name for the new VM' },
+                       { name: 'MEMORY', description: 'Amount of memory', value: '4096Mi' },
+                       { name: 'CPU_CORES', description: 'Amount of cores', value: '4' }] }]
           object = RecursiveOpenStruct.new(templates, recurse_over_arrays: true)
           object.map { |kubevirt_obj| Template.parse object_to_hash(kubevirt_obj) }
         end

data/lib/fog/kubevirt/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Kubevirt
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fog-kubevirt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Piotr Kliczewski
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-18 00:00:00.000000000 Z
+date: 2018-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,8 @@ files:
 - lib/fog/compute/kubevirt.rb
 - lib/fog/compute/kubevirt/models/livevm.rb
 - lib/fog/compute/kubevirt/models/livevms.rb
+- lib/fog/compute/kubevirt/models/node.rb
+- lib/fog/compute/kubevirt/models/nodes.rb
 - lib/fog/compute/kubevirt/models/offlinevm.rb
 - lib/fog/compute/kubevirt/models/offlinevms.rb
 - lib/fog/compute/kubevirt/models/template.rb
@@ -122,11 +124,14 @@ files:
 - lib/fog/compute/kubevirt/requests/create_offlinevm.rb
 - lib/fog/compute/kubevirt/requests/create_pvc.rb
 - lib/fog/compute/kubevirt/requests/create_vm.rb
-- lib/fog/compute/kubevirt/requests/destroy_vm.rb
+- lib/fog/compute/kubevirt/requests/delete_livevm.rb
+- lib/fog/compute/kubevirt/requests/delete_offlinevm.rb
 - lib/fog/compute/kubevirt/requests/get_livevm.rb
+- lib/fog/compute/kubevirt/requests/get_node.rb
 - lib/fog/compute/kubevirt/requests/get_offlinevm.rb
 - lib/fog/compute/kubevirt/requests/get_template.rb
 - lib/fog/compute/kubevirt/requests/list_livevms.rb
+- lib/fog/compute/kubevirt/requests/list_nodes.rb
 - lib/fog/compute/kubevirt/requests/list_offlinevms.rb
 - lib/fog/compute/kubevirt/requests/list_templates.rb
 - lib/fog/compute/kubevirt/requests/update_offlinevm.rb

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

@@ -1,15 +0,0 @@
-module Fog
-  module Compute
-    class Kubevirt
-      class Real
-        def destroy_vm(options = {})
-        end
-      end
-
-      class Mock
-        def destroy_vm(options = {})
-        end
-      end
-    end
-  end
-end