fog-kubevirt 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef12aa5c8c8f76da4468c2addf70d01f798fca2e
-  data.tar.gz: 59e0ce857ec78e72f2f47fce4b59b4789aee9bfe
+  metadata.gz: 3d98797096ddd6d2f4464998bcdbf56dcac2e9ab
+  data.tar.gz: eea11774097b4c70fe95ecbbef47847c454fa548
 SHA512:
-  metadata.gz: b715da932cbe7359039d796391e3fa1b149c7abafbd918d1c828bd761e026c3d5049d672fb11f0ff822c9faa86240b47e1536c7aa664c16d87df3be618be5482
-  data.tar.gz: f1d024c7a07089912a574cc0336475818ea71c284ff814a25bcc9edf4cf7047f0df2a114d54b82aa09af990b575a9aa73423a28defaeda70f5f24327e06b8719
+  metadata.gz: c2ea3b5710d1783c0e4710e625d2a8a8271afe322e196a52d59b27164dcf7f76a770fd95f5b77857a5447a6162a60bc96fbad78415d46c3511e005ce65a11aa0
+  data.tar.gz: 57e59e0eeb42b6542735181069436c234ca1c236fe179b44c8a45eebab6b44e682c247b7d917eacc079aa43dce2b4c18285ae54094c338d775203a8fab747451

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

@@ -1,39 +1,64 @@
 require 'delegate'
+require 'json'
+require 'rest-client'
 
 require "fog/core"
 
 module Fog
   module Kubevirt
     class Compute < Fog::Service
-      requires   :kubevirt_token
-      recognizes :kubevirt_hostname, :kubevirt_port, :kubevirt_namespace, :kubevirt_log
+      recognizes :kubevirt_token, :kubevirt_hostname, :kubevirt_port, :kubevirt_namespace, :kubevirt_log
 
       model_path 'fog/kubevirt/compute/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
+      collection :services
       model      :template
       collection :templates
       model      :volume
       collection :volumes
 
       request_path 'fog/kubevirt/compute/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
       request :update_vm
 
@@ -50,8 +75,9 @@ module Fog
         end
 
         class ExceptionWrapper
-          def initialize(client)
+          def initialize(client, version)
             @client = client
+            @version = version
           end
 
           def method_missing(symbol, *args)
@@ -71,6 +97,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
 
         #
@@ -122,17 +152,19 @@ module Fog
         include Shared
 
         #
-        # 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 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 group of the Kubernetes network extention:
+        #
+        NETWORK_GROUP = 'k8s.cni.cncf.io'.freeze
 
         def initialize(options={})
           require 'kubeclient'
@@ -146,17 +178,6 @@ module Fog
 
           @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 = {}
@@ -249,7 +270,7 @@ module Fog
             populate_notice_attributes(vminstance, notice)
             vminstance
           end
-          watch = kubevirt_client.watch_virtual_machines(opts)
+          watch = kubevirt_client.watch_virtual_machine_instances(opts)
 
           WatchWrapper.new(watch, mapper)
         end
@@ -296,7 +317,6 @@ module Fog
 
         private
 
-
         #
         # Populates required notice attributes
         #
@@ -310,47 +330,115 @@ 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.
+        # @return [Kubeclient::Client] The client for the given path.
         #
-        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:
+        def create_client(path)
           url = URI::Generic.build(
             :scheme => 'https',
             :host   => @host,
             :port   => @port,
             :path   => path
           )
+
+          if @kubevirt_token.to_s.empty?
+            create_client_from_config(path)
+          else
+            create_client_from_token(url)
+          end
+        end
+
+        def create_client_from_token(url)
+          # 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
+            }
+          }
+          version = detect_version(url.to_s, @opts[:ssl_options])
+          key = url.path + '/' + version
+
+          client = check_client(key)
+          return client if client
+
           client = Kubeclient::Client.new(
             url.to_s,
             version,
             @opts
           )
-          wrapped_client = ExceptionWrapper.new(client)
+
+          wrap_client(client, version, key)
+        end
+
+        def create_client_from_config(path)
+          config = Kubeclient::Config.read(ENV['KUBECONFIG'] || ENV['HOME']+'/.kube/config')
+          context = config.context
+          url = context.api_endpoint
+          version = detect_version(url + path, context.ssl_options)
+          key = path + '/' + version
+
+          client = check_client(key)
+          return client if client
+
+          client = Kubeclient::Client.new(
+            url + path,
+            version,
+            ssl_options: context.ssl_options,
+            auth_options: context.auth_options
+          )
+
+          wrap_client(client, version, key)
+        end
+
+        def check_client(key)
+          @clients[key]
+        end
+
+        def wrap_client(client, version, key)
+          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/kubevirt/compute/models/networkattachmentdef.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Kubevirt
+    class Compute
+      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/kubevirt/compute/models/networkattachmentdefs.rb

@@ -0,0 +1,59 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/networkattachmentdef'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Networkattachmentdefs < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::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/kubevirt/compute/models/pvc.rb

@@ -0,0 +1,59 @@
+module Fog
+  module Kubevirt
+    class Compute
+      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/kubevirt/compute/models/pvcs.rb

@@ -0,0 +1,76 @@
+require 'fog/core/collection'
+require 'fog/kubevirt/compute/models/pvc'
+
+module Fog
+  module Kubevirt
+    class Compute
+      class Pvcs < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Kubevirt::Compute::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