fog-kubevirt 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ce96c8011542dbc39b76e8754b57bd708a1c1e6
-  data.tar.gz: 0cda9190f6c0bbb60d5acf1b47b487b7ae273741
+  metadata.gz: 1de135b0b0723b41c540c9bc1247b67d1f8176ef
+  data.tar.gz: 8845f174d0923e0224e0683c710d0a5219608c7b
 SHA512:
-  metadata.gz: c8ab23a99601911709e4d24495da5b00da048d7a61dff8287a79dff42850ba4f6b2fb853590f77125bfedba4860bb6e3aef8de9dd53bd799b5f126020bca697f
-  data.tar.gz: f0fd54f70d37c1fb7669a2101e5c8ecc08e2d35be275977acba208efdd442b9dc6cabae66ebd67a4acf519941e3fec9c328e27fd5fbe82d431633e61e8d4555c
+  metadata.gz: ea3d49cf4931797629028d01cea8332d78f57c90b130e8d362e0bd1002d19e539ceee45280f2a6d16c2da45fa11e40da14da12cdb31a9bc2da2af6038bd3560f
+  data.tar.gz: 06ad5911dc8b3c7f110f33992ee61e19403f4643b0d97607000dff270e20036ad6b2414f54b72a545f606c927d15c93237d25915aebcdf176fb5327c13549218

data/lib/fog/compute/kubevirt.rb

@@ -1,4 +1,6 @@
 require 'delegate'
+require 'json'
+require 'rest-client'
 
 require "fog/core"
 
@@ -12,10 +14,14 @@ module Fog
       model_path 'fog/compute/kubevirt/models'
       model      :vminstance
       collection :vminstances
+      model      :networkattachmentdef
+      collection :networkattachmentdefs
       model      :node
       collection :nodes
       model      :vm
       collection :vms
+      model      :pvc
+      collection :pvcs
       model      :server
       collection :servers
       model      :service
@@ -26,23 +32,33 @@ module Fog
       collection :volumes
 
       request_path 'fog/compute/kubevirt/requests'
-
+      request :create_networkattachmentdef
       request :create_vm
       request :create_vminstance
       request :create_pvc
       request :create_service
+      request :create_volume
+      request :delete_networkattachmentdef
+      request :delete_pvc
       request :delete_service
       request :delete_vminstance
       request :delete_vm
+      request :delete_volume
       request :get_vminstance
+      request :get_networkattachmentdef
       request :get_node
+      request :get_pvc
       request :get_vm
+      request :get_volume
       request :get_server
       request :get_service
       request :get_template
       request :list_vminstances
       request :list_nodes
+      request :list_networkattachmentdefs
       request :list_vms
+      request :list_pvcs
+      request :list_volumes
       request :list_servers
       request :list_services
       request :list_templates
@@ -61,8 +77,9 @@ module Fog
         end
 
         class ExceptionWrapper
-          def initialize(client)
+          def initialize(client, version)
             @client = client
+            @version = version
           end
 
           def method_missing(symbol, *args)
@@ -82,6 +99,10 @@ module Fog
           def respond_to_missing?(method_name, include_private = false)
             @client.respond_to?(symbol, include_all) || super
           end
+
+          def version
+            @version
+          end
         end
 
         #
@@ -133,17 +154,19 @@ module Fog
         include Shared
 
         #
-        # The API version and group of KubeVirt:
+        # The API group of KubeVirt:
         #
         KUBEVIRT_GROUP = 'kubevirt.io'.freeze
-        KUBEVIRT_VERSION = 'v1alpha2'.freeze
-        KUBEVIRT_VERSION_LABEL = KUBEVIRT_GROUP + '/' + KUBEVIRT_VERSION
 
         #
-        # The API version and group of the Kubernetes core:
+        # The API group of the Kubernetes core:
         #
         CORE_GROUP = ''.freeze
-        CORE_VERSION = 'v1'.freeze
+
+        #
+        # The API group of the Kubernetes network extention:
+        #
+        NETWORK_GROUP = 'k8s.cni.cncf.io'.freeze
 
         def initialize(options={})
           require 'kubeclient'
@@ -302,7 +325,6 @@ module Fog
 
         private
 
-
         #
         # Populates required notice attributes
         #
@@ -316,18 +338,12 @@ module Fog
         end
 
         #
-        # Lazily creates the a client for the given Kubernetes API path and version.
+        # Lazily creates the a client for the given Kubernetes API path.
         #
         # @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
-
+        def create_client(path)
           # Create the client and save it:
           url = URI::Generic.build(
             :scheme => 'https',
@@ -335,28 +351,56 @@ module Fog
             :port   => @port,
             :path   => path
           )
+
+          version = detect_version(url.to_s, @opts[:ssl_options])
+          key = path + '/' + version
+          client = @clients[key]
+          return client if client
+
           client = Kubeclient::Client.new(
             url.to_s,
             version,
             @opts
           )
-          wrapped_client = ExceptionWrapper.new(client)
+          wrapped_client = ExceptionWrapper.new(client, version)
           @clients[key] = wrapped_client
 
           # Return the client:
           wrapped_client
         end
 
+        def detect_version(url, ssl_options)
+          options = {
+            ssl_ca_file: ssl_options[:ca_file],
+            ssl_cert_store: ssl_options[:cert_store],
+            verify_ssl: ssl_options[:verify_ssl],
+            ssl_client_cert: ssl_options[:client_cert],
+            ssl_client_key: ssl_options[:client_key],
+          }
+
+          response = ::JSON.parse(RestClient::Resource.new(url, options).get)
+
+          # version detected based on
+          # https://github.com/kubernetes-incubator/apiserver-builder/blob/master/docs/concepts/aggregation.md#viewing-discovery-information
+          preferredVersion = response["preferredVersion"]
+          return preferredVersion["version"] if preferredVersion 
+          response["versions"][0]
+        end
+
         def openshift_client
-          create_client('/oapi', CORE_VERSION)
+          create_client('/oapi')
         end
 
         def kube_client
-          create_client('/api', CORE_VERSION)
+          create_client('/api')
         end
 
         def kubevirt_client
-          create_client('/apis/' + KUBEVIRT_GROUP, KUBEVIRT_VERSION)
+          create_client('/apis/' + KUBEVIRT_GROUP)
+        end
+
+        def kube_net_client
+          create_client('/apis/' + NETWORK_GROUP)
         end
 
         def log

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

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Networkattachmentdef < Fog::Model
+        identity :name
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :uid,              :aliases => 'metadata_uid'
+        attribute :config,           :aliases => 'spec_config'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :config           => object[:spec][:config]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/networkattachmentdef'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Networkattachmentdefs < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Compute::Kubevirt::Networkattachmentdef
+
+        def all(filters = {})
+          networkattachmentdefs = service.list_networkattachmentdefs(filters)
+          @kind = networkattachmentdefs.kind
+          @resource_version = networkattachmentdefs.resource_version
+          load networkattachmentdefs
+        end
+
+        def get(name)
+          new service.get_networkattachmentdef(name)
+        end
+
+        # Creates network attachment definition using provided parameters:
+        # name[String] - name of the network attachment
+        # config[String] - the configuration of the attachment, i.e.:
+        #   '{ :cniVersion => "0.3.1", :type => "ovs", :bridge => "red" }'
+        #
+        # @param args[Hash] contains attachment definition
+        def create(args = {})
+          name = args[:name]
+          config = args[:config]
+
+          net_att_def = {
+            :metadata => {
+              :name      => name,
+              :namespace => service.namespace
+            },
+            :spec => {
+              :config => config
+            }
+          }
+
+          service.create_networkattachmentdef(net_att_def)
+        end
+
+        def delete(name)
+          begin
+            net_att_def = get(name)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # the network attachment definition doesn't exist
+            net_att_def = nil
+          end
+
+          service.delete_networkattachmentdef(name, service.namespace) unless net_att_def.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Pvc < Fog::Model
+        # Metadata
+        identity :name
+        attribute :resource_version,  :aliases => 'metadata_resource_version'
+        attribute :uid,               :aliases => 'metadata_uid'
+        attribute :namespace,         :aliases => 'metadata_namespace'
+
+        # Spec
+        attribute :access_modes,      :aliases => 'spec_access_modes'
+        attribute :storage_class,     :aliases => 'spec_storage_class'
+        attribute :volume_mode,       :aliases => 'spec_volume_mode'
+        attribute :volume_name,       :aliases => 'spec_volume_name'
+
+        # Spec - selector
+        attribute :match_expressions, :aliases => 'spec_match_expressions'
+        attribute :match_labels,      :aliases => 'spec_match_labels'
+
+        # Spec - resources
+        attribute :limits,            :aliases => 'spec_limits'
+        attribute :requests,          :aliases => 'spec_requests'
+
+        # Status
+        attribute :phase,             :aliases => 'status_phase'
+        attribute :reason,            :aliases => 'status_reason'
+        attribute :message,           :aliases => 'status_message'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          spec = object[:spec]
+          status = object[:status]
+
+          {
+            :name              => metadata[:name],
+            :resource_version  => metadata[:resourceVersion],
+            :uid               => metadata[:uid],
+            :namespace         => metadata[:namespace],
+
+            :access_modes      => spec[:accessModes],
+            :storage_class     => spec[:storageClassName],
+            :volume_mode       => spec[:volumeMode],
+            :volume_name       => spec[:volumeName],
+
+            :match_expressions => spec.dig(:selector, :matchExpressions),
+            :match_labels      => spec.dig(:selector, :matchLabels),
+            :limits            => spec.dig(:resources, :limits),
+            :requests          => spec.dig(:resources, :requests),
+
+            :phase             => status[:phase],
+            :reason            => status[:reason],
+            :message           => status[:message]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/pvc'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Pvcs < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Compute::Kubevirt::Pvc
+
+        def all(filters = {})
+          pvcs = service.list_pvcs(filters)
+          @kind = pvcs.kind
+          @resource_version = pvcs.resource_version
+          load pvcs
+        end
+
+        def get(name)
+          new service.get_pvc(name)
+        end
+
+        # Creates a pvc using provided paramters:
+        # https://kubernetes.io/docs/concepts/storage/persistent-volumes/#persistentvolumeclaims
+        # :name [String] - name of a pvc
+        # :namespace [String] - the namespace of the PVC, should be the same as POD's pvc
+        # :storage_class [String] - the storage class name of the pvc
+        # :volume_name [String] - The volume name to
+        # :volume_mode [String] - Filesystem or block device
+        # :accessModes [Arr] - the access modes for the volume, values are specified here:
+        # :requests [Hash] - the request for storage resource, i.e. { :storage => "20Gi" }
+        # :limits [Hash] - the maximum amount of storage to consume, i.e. { :storage => "20Gi" }
+        # :match_labels [Hash] - label query over volumes for binding
+        # :match_expressions [Hash] - list of label selector requirements
+        # @param [Hash] attributes containing details about pvc to be created.
+        def create(args = {})
+          name = args[:name]
+
+          pvc = {
+            :apiVersion => "v1",
+            :kind => "PersistentVolumeClaim",
+            :metadata => {
+              :name      => name,
+              :namespace => args[:namespace]
+            },
+            :spec => {
+              :storageClassName => args[:storage_class],
+              :resources        => {},
+              :selector         => {},
+            }
+          }
+
+          pvc[:spec][:resources].merge!(:requests => args[:requests]) if args[:requests]
+          pvc[:spec][:resources].merge!(:limits => args[:limits]) if args[:limits]
+          pvc[:spec][:selector].merge!(:matchLabels => args[:match_labels]) if args[:match_labels]
+          pvc[:spec][:selector].merge!(:matchExpressions => args[:match_expressions]) if args[:match_expressions]
+          pvc[:spec][:accessModes] = args[:access_modes] if args[:access_modes]
+          pvc[:spec][:volumeMode] = args[:volume_mode] if args[:volume_mode]
+          pvc[:spec][:volumeName] = args[:volume_name] if args[:volume_name]
+          service.create_pvc(pvc)
+        end
+
+        def delete(name)
+          begin
+            pvc = get(name)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # the pvc doesn't exist
+            pvc = nil
+          end
+
+          service.delete_pvc(name) unless pvc.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -19,8 +19,10 @@ module Fog
           service.delete_vm(name, namespace)
         end
 
+        # TODO: Once IP Addresses are reported to any networks, we should consider also
+        # the availabity of it (by extending the condition with !ip_address.empty?)
         def ready?
-          running?(status) && running?(state) && !ip_address.empty?
+          running?(status) && running?(state)
         end
 
         def self.parse(object)

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

@@ -89,9 +89,9 @@ module Fog
           object.each do |v|
             volume = VmVolume.new
             volume.name = v[:name]
-            if v.keys.include?(:registryDisk)
-              volume.type = 'registryDisk'
-              volume.info = v.dig(:registryDisk, :image)
+            if v.keys.include?(:containerDisk)
+              volume.type = 'containerDisk'
+              volume.info = v.dig(:containerDisk, :image)
             elsif v.keys.include?(:persistentVolumeClaim)
               volume.type = 'persistentVolumeClaim'
               volume.info = v.dig(:persistentVolumeClaim, :claimName)
@@ -133,6 +133,7 @@ module Fog
                         :model,
                         :ports,
                         :boot_order
+          alias :mac :mac_address
         end
 
         class VmNetwork
@@ -151,7 +152,7 @@ module Fog
 
         class VmVolume
           attr_accessor :name,
-                        # values: registryDisk, persistentVolumeClaim, emptyDisk,
+                        # values: containerDisk, persistentVolumeClaim, emptyDisk,
                         #         ephemeral, cloudInitNoCloud, hostDisk, secret,
                         #         dataVolume, serviceAccount, configMap
                         :type,