fog-kubevirt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: db04da9d9e8117993d2eb4fc4630d6e670e19906
+  data.tar.gz: 7dd7992382563c3ce868a8e694c743295c329595
+SHA512:
+  metadata.gz: 68653cae72af67f1d417718b95f89bcdc8fa96606fffbd0dd0035ead0a89b713ea801bd0e038f8ed5e49c7ee0bd14b56e1adb2cbdccda21f954d0d1b000b0533
+  data.tar.gz: c6b2b9f6d0bdeb9eb5e4a62962aa90fc8c654e81b8a182737935258b2fdfaa7003ca090e9d5b0c0b47819feabbbdf25b24c59877549e40fdba18c606ed85f607

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2018 Red Hat, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,45 @@
+# Fog::Kubevirt
+
+fog-kubevirt is an kubevirt provider for [fog](https://github.com/fog/fog).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fog-kubevirt'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fog-kubevirt
+
+## Usage
+
+Require the gem:
+```ruby
+require 'fog/kubevirt' 
+```
+
+Connect to kubevirt instance:
+```ruby
+
+compute = Fog::Compute.new(
+          :provider        => "kubevirt",
+          :kubevirt_token  => token,
+          :kubevirt_server => server,
+          :kubevirt_port   => port
+      )
+```
+
+## Contributing
+
+Please refer to [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+Please refer to [LICENSE.txt](LICENSE.txt).

data/lib/fog/bin/kubevirt.rb

@@ -0,0 +1,28 @@
+class Kubevirt < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Kubevirt
+      else
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+                    when :compute
+                      Fog::Compute.new(:provider => 'Kubevirt')
+                    else
+                      raise ArgumentError, "Unrecognized service: #{key.inspect}"
+                    end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Kubevirt.services
+    end
+  end
+end

data/lib/fog/compute/kubevirt.rb

@@ -0,0 +1,169 @@
+module Fog
+  module Compute
+    class Kubevirt < Fog::Service
+      requires   :kubevirt_token
+      recognizes :kubevirt_hostname, :kubevirt_port
+
+      model_path 'fog/compute/kubevirt/models'
+      model      :livevm
+      collection :livevms
+      model      :offlinevm
+      collection :offlinevms
+      model      :template
+      collection :templates
+      model      :volume
+      collection :volumes
+
+      request_path 'fog/compute/kubevirt/requests'
+
+      request :create_vm
+      request :create_offlinevm
+      request :create_pvc
+      request :destroy_vm
+      request :get_livevm
+      request :get_offlinevm
+      request :get_template
+      request :list_livevms
+      request :list_offlinevms
+      request :list_templates
+      request :update_offlinevm
+
+      module Shared
+        # converts kubeclient objects into hash for fog to consume
+        def object_to_hash(object)
+          result = object
+          case result
+          when OpenStruct
+            result = result.marshal_dump
+            result.each do |k, v|
+              result[k] = object_to_hash(v)
+            end
+          when Array
+            result = result.map { |v| object_to_hash(v) }
+          end
+
+          result
+        end
+      end
+
+      class Real
+        include Shared
+
+        #
+        # The API version and group of the Kubernetes core:
+        #
+        CORE_GROUP = ''.freeze
+        CORE_VERSION = 'v1'.freeze
+
+        #
+        # The API version and group of KubeVirt:
+        #
+        KUBEVIRT_GROUP = 'kubevirt.io'.freeze
+        KUBEVIRT_VERSION = 'v1alpha1'.freeze
+
+        def initialize(options={})
+          require 'kubeclient'
+
+          @kubevirt_token = options[:kubevirt_token]
+          @host  = options[:kubevirt_hostname]
+          @port  = options[:kubevirt_port]
+
+          @namespace = options[:kubevirt_namespace] || 'default'
+
+          # Prepare the TLS and authentication options that will be used for the standard Kubernetes API
+          # and also for the KubeVirt extension:
+          @opts = {
+            :ssl_options  => {
+              :verify_ssl => OpenSSL::SSL::VERIFY_NONE,
+            },
+            :auth_options => {
+              :bearer_token => @kubevirt_token
+            }
+          }
+
+          # Kubeclient needs different client objects for different API groups. We will keep in this hash the
+          # client objects, indexed by API path/version.
+          @clients = {}
+
+          @client = kubevirt_client()
+
+          # TODO expect a specific token
+          @oc_client = openshift_client()
+          @kube_client = kube_client()
+        end
+
+        private
+
+        def client
+          @client
+        end
+
+        def oc_client
+          @oc_client
+        end
+
+        def kube_client
+          @kubeclient
+        end
+
+        #
+        # Lazily creates the a client for the given Kubernetes API path and version.
+        #
+        # @param path [String] The Kubernetes API path.
+        # @param version [String] The Kubernetes API version.
+        # @return [Kubeclient::Client] The client for the given path and version.
+        #
+        def create_client(path, version)
+          # Return the client immediately if it has been created before:
+          key = path + '/' + version
+          client = @clients[key]
+          return client if client
+
+          # Create the client and save it:
+          url = URI::Generic.build(
+            :scheme => 'https',
+            :host   => @host,
+            :port   => @port,
+            :path   => path
+          )
+          client = Kubeclient::Client.new(
+            url.to_s,
+            version,
+            @opts
+          )
+          @clients[key] = client
+
+          # Return the client:
+          client
+        end
+
+        def openshift_client
+          create_client('/oapi', CORE_VERSION)
+        end
+
+        def kube_client
+          create_client('/api', CORE_VERSION)
+        end
+
+        def kubevirt_client
+          create_client('/apis/' + KUBEVIRT_GROUP, KUBEVIRT_VERSION)
+        end
+      end
+
+      class Mock
+        include Shared
+
+        def initialize(options={})
+        end
+
+        private
+
+        def client
+          return @client if defined?(@client)
+        end
+
+        # TODO provide mocking
+      end
+    end
+  end  
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Livevm < Fog::Model
+        identity :name
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :uid,              :aliases => 'metadata_uid'
+        attribute :owner_name,       :aliases => 'metadata_owner_name'
+        attribute :owner_uid,        :aliases => 'metadata_owner_uid'
+        attribute :cpu_cores,        :aliases => 'spec_cpu_cores'
+        attribute :memory,           :aliases => 'spec_memory'
+        attribute :disks,            :aliases => 'spec_disks'
+        attribute :volumes,          :aliases => 'spec_volumes'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          owner = metadata[:ownerReferences][0]
+          spec = object[:spec]
+          domain = spec[:domain]
+          {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :owner_name       => owner[:name],
+            :owner_uid        => owner[:uid],
+            :cpu_cores        => domain[:cpu][:cores],
+            :memory           => domain[:resources][:requests][:memory],
+            :disks            => domain[:devices][:disks],
+            :volumes          => spec[:volumes]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/livevm'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Livevms < Fog::Collection
+        model Fog::Compute::Kubevirt::Livevm
+
+        def all(filters = {})
+          load service.list_livevms(filters)
+        end
+
+        def get(name)
+          new service.get_livevm(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Offlinevm < Fog::Model
+        identity :name
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :uid,              :aliases => 'metadata_uid'
+        attribute :cpu_cores,        :aliases => 'spec_cpu_cores'
+        attribute :memory,           :aliases => 'spec_memory'
+        attribute :disks,            :aliases => 'spec_disks'
+        attribute :volumes,          :aliases => 'spec_volumes'
+
+
+        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.
+          offline_vm = service.get_raw_offlinevm(name)
+          offline_vm = offline_vm.deep_merge(
+            :spec => {
+              :running => true
+            }
+          )
+          service.update_offline_vm(offline_vm)
+        end
+
+        def stop(options = {})
+        end
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          spec = object[:spec][:template][:spec]
+          domain = spec[:domain]
+          {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :cpu_cores        => domain[:cpu][:cores],
+            :memory           => domain[:resources][:requests][:memory],
+            :disks            => domain[:devices][:disks],
+            :volumes          => spec[:volumes]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/offlinevm'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Offlinevms < Fog::Collection
+        model Fog::Compute::Kubevirt::Offlinevm
+
+        def all(filters = {})
+          load service.list_offlinevms(filters)
+        end
+
+        def get(name)
+          new service.get_offlinevm(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+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'
+        attribute :objects
+        attribute :parameters
+
+        def clone(options = {})
+          params = values(options)
+
+          # use persistent volume claims if any from a template and send
+          create_persistent_volume_claims(persistent_volume_claims_from_objects(objects), params, namespace)
+
+          # use offline vm definition from a template and send
+          create_offline_vm(offline_vm_from_objects(objects), params, namespace)
+        end
+
+        def self.parse(object)
+          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],
+          }
+        end
+
+        private
+
+        #
+        # Combines default values of the parameters defined in a template with values
+        # provided by the user on the UI.
+        #
+        # @param options [Hash] Hash containing values defined by the user on the UI.
+        #
+        def values(options)
+          default_params = {}
+          parameters.each do |param|
+            name = param[:name].downcase
+            value = options[name.to_sym]
+            if value && name == "memory"
+              value = value.to_s + 'Mi'
+            end
+
+            default_params[name] = value || param[:value]
+          end
+          default_params
+        end
+
+        #
+        # Creates an offline virtual machine within provided namespace.
+        #
+        # @param offline_vm [Hash] Offline virtual machine hash as defined in the template.
+        # @param params [Hash] Containing mapping of name and value.
+        # @param namespace [String] Namespace used to store the object.
+        #
+        def create_offline_vm(offline_vm, params, namespace)
+          offline_vm = param_substitution!(offline_vm, params)
+
+          offline_vm = offline_vm.deep_merge(
+            :metadata => {
+              :namespace => namespace
+            }
+          )
+
+          # Send the request to create the offline virtual machine:
+          offline_vm = service.create_offlinevm(offline_vm)
+        end
+
+        #
+        # Creates an persistent volume claims within provided namespace.
+        #
+        # @param pvcs Array[Hash] An array of pvc hashes as defined in the template.
+        # @param params [Hash] Containing mapping of name and value.
+        # @param namespace [String] Namespace used to store the object.
+        #
+        def create_persistent_volume_claims(pvcs, params, namespace)
+          pvcs.each do |pvc|
+            pvc = param_substitution!(pvc, params)
+
+            pvc = pvc.deep_merge(
+              :metadata => {
+                :namespace => namespace
+              }
+            )
+
+            # Send the request to create the persistent volume claim:
+            service.create_pvc(pvc)
+          end
+        end
+
+        #
+        # Returns object of `OfflineVirtualMachine` kind from provided objects.
+        #
+        # @param objects Array[Object] Objects defined in the template.
+        # @return [Hash] Offline virtual machine hash
+        #
+        def offline_vm_from_objects(objects)
+          vm = nil
+          objects.each do |object|
+            if object[:kind] == "OfflineVirtualMachine"
+              vm = object
+            end
+          end
+          # make sure there is one
+          raise ::Fog::Kubevirt::Errors::ServiceError if vm.nil?
+          vm
+        end
+
+        #
+        # Returns object of `PersistentVolumeClaim` kind from provided objects.
+        #
+        # @param objects Array[Object] Objects defined in the template.
+        # @return Array[Hash] An array of pvc hashes.
+        #
+        def persistent_volume_claims_from_objects(objects)
+          pvcs = []
+          objects.each do |object|
+            if object[:kind] == "PersistentVolumeClaim"
+              pvcs << object
+            end
+          end
+          pvcs
+        end
+
+        #
+        # Performs parameter substitution for specific object where we
+        # substitute ${params.key} with params[key].
+        #
+        # @param object [Hash | Array | String] Specific object where substitution takes place.
+        # @param params [Hash] Hash containing parameters to be substituted.
+        #
+        def param_substitution!(object, params)
+          result = object
+          case result
+          when Hash
+            result.each do |k, v|
+              result[k] = param_substitution!(v, params)
+            end
+          when Array
+            result.map { |v| param_substitution!(v, params) }
+          when String
+            result = sub_specific_object(params, object)
+          end
+          result
+        end
+
+        #
+        # Performs substitution on specific object.
+        #
+        # @params params [Hash] Containing parameter names and values used for substitution.
+        # @params object [String] Object on which substitution takes place.
+        # @returns [String] The outcome of substitution.
+        #
+        def sub_specific_object(params, object)
+          result = object
+          params.each_key do |name|
+            token = "${#{name.upcase}}"
+            next unless object.include?(token)
+            result = if params[name].kind_of?(String)
+                       object.sub!(token, params[name])
+                     else
+                       params[name]
+                     end
+          end
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/template'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Templates < Fog::Collection
+        model Fog::Compute::Kubevirt::Template
+
+        def all(filters = {})
+          load service.list_templates(filters)
+        end
+
+        def get(name)
+          new service.get_template(name)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,17 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def create_offlinevm(vm)
+          kubevirt_client.create_offline_virtual_machine(vm)
+        rescue KubeException
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_offlinevm(vm); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def create_pvc(pvc)
+          kube_client.create_persistent_volume_claim(pvc)
+        rescue Kubeclient::HttpError
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_pvc(attrs); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def create_vm(vm)
+          kubevirt_client.create_virtual_machine(vm)
+        rescue Kubeclient::HttpError
+          raise ::Fog::Kubevirt::Errors::AlreadyExistsError
+        end
+      end
+
+      class Mock
+        def create_vm(vm)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,41 @@
+require 'recursive_open_struct'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def get_livevm(name)
+          Livevm.parse object_to_hash( kubevirt_client.get_virtual_machine(name, 'default') )
+        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"}]}}
+          object = RecursiveOpenStruct.new(vm, recurse_over_arrays: true)
+          Livevm.parse object_to_hash(object)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def get_offlinevm(name)
+          Offlinevm.parse get_raw_offlinevm(name)
+        end
+
+        def get_raw_offlinevm(name)
+          object_to_hash( kubevirt_client.get_offline_virtual_machine(name, 'default') )
+        end
+      end
+
+      class Mock
+        def get_offlinevm(name)
+        end
+
+        def get_raw_offlinevm(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def get_template(name)
+          Template.parse object_to_hash( oc_client.get_template(name, 'default') )
+        end
+      end
+
+      class Mock
+        def get_template(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    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) }
+        end
+      end
+
+      class Mock
+        def list_livevms(_filters = {})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'recursive_open_struct'
+
+module Fog
+  module Compute
+    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) }
+        end
+      end
+
+      class Mock
+        def list_offlinevms(_filters = {})
+          offlinevms = [{ apiVersion: 'kubevirt.io/v1alpha1',
+                          kind: 'OfflineVirtualMachine',
+                          metadata: {
+                            clusterName: '',
+                            creationTimestamp: '2018-02-21T11:15:41Z',
+                            name: 'aaa',
+                            namespace: 'default',
+                            resourceVersion: '967810',
+                            selfLink: '/apis/kubevirt.io/v1alpha1/namespaces/default/offlinevirtualmachines/aaa',
+                            uid: '8d27ad76-16f8-11e8-95dc-525400b2cba8'
+                          },
+                          spec: {
+                            template: {
+                              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(offlinevms, recurse_over_arrays: true)
+          object.map { |kubevirt_obj| Offlinevm.parse object_to_hash(kubevirt_obj) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'recursive_open_struct'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def list_templates(_filters = {})
+          oc_client.get_templates(namespace: 'default').map { |kubevirt_obj| Template.parse object_to_hash(kubevirt_obj) }
+        end
+      end
+
+      class Mock
+        def list_templates(_filters = {})
+          templates = [{ metadata: { name: 'linux-vm-template',
+                                     namespace: 'default',
+                                     selfLink: '/oapi/v1/namespaces/default/templates/linux-vm-template',
+                                     uid: '610c434f-17bc-11e8-a9f9-525400a7f647',
+                                     resourceVersion: '9240',
+                                     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' }] }]
+          object = RecursiveOpenStruct.new(templates, recurse_over_arrays: true)
+          object.map { |kubevirt_obj| Template.parse object_to_hash(kubevirt_obj) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Real
+        def update_offline_vm(update)
+          kubevirt_client.update_offline_virtual_machine(update)
+        end
+      end
+
+      class Mock
+      	def update_offline_vm(update)
+      	end
+      end
+    end
+  end
+end

data/lib/fog/kubevirt.rb

@@ -0,0 +1,18 @@
+require 'fog/core'
+
+module Fog
+  module Compute
+    autoload :Kubevirt, File.expand_path('../compute/kubevirt', __FILE__)
+  end
+
+  module Kubevirt
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error; end
+      class AlreadyExistsError < Fog::Errors::Error; end
+    end
+
+    service(:compute, 'Compute')
+  end
+end

data/lib/fog/kubevirt/version.rb

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

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: fog-kubevirt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Kliczewski
+- Moti Asayag
+- Paulo Ribeiro
+- Wesley Beary
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fog-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.45'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.45'
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+description: This library can be used as a module for `fog`.
+email:
+- piotr.kliczewski@gmail.com
+- masayag@redhat.com
+- plribeiro3000@gmail.com
+- geemus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/fog/bin/kubevirt.rb
+- lib/fog/compute/kubevirt.rb
+- lib/fog/compute/kubevirt/models/livevm.rb
+- lib/fog/compute/kubevirt/models/livevms.rb
+- lib/fog/compute/kubevirt/models/offlinevm.rb
+- lib/fog/compute/kubevirt/models/offlinevms.rb
+- lib/fog/compute/kubevirt/models/template.rb
+- lib/fog/compute/kubevirt/models/templates.rb
+- lib/fog/compute/kubevirt/models/volume.rb
+- lib/fog/compute/kubevirt/models/volumes.rb
+- 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/get_livevm.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_offlinevms.rb
+- lib/fog/compute/kubevirt/requests/list_templates.rb
+- lib/fog/compute/kubevirt/requests/update_offlinevm.rb
+- lib/fog/kubevirt.rb
+- lib/fog/kubevirt/version.rb
+homepage: https://github.com/pkliczewski/fog-kubevirt
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Module for the 'fog' gem to support Kubevirt.
+test_files: []