fog-kubevirt 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b65d74062fb0f9340314202ab14a52c69a189982
-  data.tar.gz: 906dfdd1e950645873c3b1e60efbe82b0249f1a8
+  metadata.gz: 0eae64c2d198ea65729e7f1c66986096a49381fa
+  data.tar.gz: e92414ce86e90a85c3db8ae77a900217e710bad3
 SHA512:
-  metadata.gz: 313419d7958e41aebfb58eee48c7c112d0952e83879af282e2aef789064c67c4ea9602c235a2fd509ac61d692064dd2a77a42d616e212278b32702a695c91820
-  data.tar.gz: 7381f9b3b41739b0ff6335a1a9a1003f8ef9478a0c4fc67ca45f425e6a7ba4d1e422261704cb2d1d61bb28a117e4ed669e4e6a66ec01d5854c0665d9bcc4d00a
+  metadata.gz: 54daf2d0f13edd1f6493d97df1a00ddcd18d4327ddce709c112c7dba80cab7daf3e5cab4f83225038792969dc08e7b9de083c9d5723d5f8d36376736dd7aca5d
+  data.tar.gz: e25fa5d0391f3ca87fa2104ba2f4970db66b2d0c2d82043fbfb0c453a8d3c5440569e464f96a22bd06e7e1753195cbb186363cfa356dd86c3a3da2dc76ddd65c

data/lib/fog/compute/kubevirt.rb

@@ -6,7 +6,8 @@ module Fog
   module Compute
     class Kubevirt < Fog::Service
       requires   :kubevirt_token
-      recognizes :kubevirt_hostname, :kubevirt_port, :kubevirt_namespace, :kubevirt_log
+      recognizes :kubevirt_hostname, :kubevirt_port, :kubevirt_namespace, \
+                 :kubevirt_log, :kubevirt_verify_ssl, :kubevirt_ca_cert
 
       model_path 'fog/compute/kubevirt/models'
       model      :vminstance
@@ -15,6 +16,10 @@ module Fog
       collection :nodes
       model      :vm
       collection :vms
+      model      :server
+      collection :servers
+      model      :service
+      collection :services
       model      :template
       collection :templates
       model      :volume
@@ -25,15 +30,21 @@ module Fog
       request :create_vm
       request :create_vminstance
       request :create_pvc
+      request :create_service
+      request :delete_service
       request :delete_vminstance
       request :delete_vm
       request :get_vminstance
       request :get_node
       request :get_vm
+      request :get_server
+      request :get_service
       request :get_template
       request :list_vminstances
       request :list_nodes
       request :list_vms
+      request :list_servers
+      request :list_services
       request :list_templates
       request :update_vm
 
@@ -121,17 +132,18 @@ module Fog
         require "ostruct"
         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 = 'v1alpha2'.freeze
+        KUBEVIRT_VERSION_LABEL = KUBEVIRT_GROUP + '/' + KUBEVIRT_VERSION
+
+        #
+        # The API version and group of the Kubernetes core:
+        #
+        CORE_GROUP = ''.freeze
+        CORE_VERSION = 'v1'.freeze
 
         def initialize(options={})
           require 'kubeclient'
@@ -144,13 +156,8 @@ module Fog
           @log ||= ::Logger.new(STDOUT)
 
           @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,
-            },
+            :ssl_options  => obtain_ssl_options(options),
             :auth_options => {
               :bearer_token => @kubevirt_token
             }
@@ -289,6 +296,10 @@ module Fog
           url.to_s
         end
 
+        def namespace
+          @namespace
+        end
+
         private
 
 
@@ -351,6 +362,41 @@ module Fog
         def log
           @log
         end
+
+        #
+        # Prepare the TLS and authentication options that will be used for the
+        # standard Kubernetes API and also for the KubeVirt extension
+        #
+        # @param options [Hash] a hash with connection options
+        #
+        def obtain_ssl_options(options)
+          verify_ssl = options[:kubevirt_verify_ssl]
+          if verify_ssl == true
+            ca = options[:kubevirt_ca_cert] || ""
+            ca = IO.read(ca) if File.file?(ca)
+            certs = ca.split(/(?=-----BEGIN)/).reject(&:empty?).collect do |pem|
+              OpenSSL::X509::Certificate.new(pem)
+            end
+
+            cert_store = OpenSSL::X509::Store.new
+            certs.each do |cert|
+              cert_store.add_cert(cert)
+            end
+
+            ssl_options = {
+              :verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+              :cert_store => cert_store
+            }
+          elsif verify_ssl == false || verify_ssl.to_s.empty?
+            ssl_options = {
+              :verify_ssl => OpenSSL::SSL::VERIFY_NONE
+            }
+          else
+            ssl_options = {
+              :verify_ssl => verify_ssl
+            }
+          end
+        end
       end
 
       class Mock
@@ -368,5 +414,5 @@ module Fog
         # TODO provide mocking
       end
     end
-  end  
+  end
 end

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

@@ -0,0 +1,42 @@
+require 'fog/compute/models/server'
+require 'fog/compute/kubevirt/models/vm_base'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Server < Fog::Compute::Server
+        include Shared
+        include VmAction
+        extend VmBase
+        define_properties
+
+        attribute :state, :aliases => 'phase'
+        attribute :ip_address
+        attribute :node_name
+
+        def destroy(options = {})
+          stop(options)
+          service.delete_vm(name, namespace)
+        end
+
+        def ready?
+          running?(status) && running?(state) && !ip_address.empty?
+        end
+
+        def self.parse(object)
+          server = parse_object(object)
+          server[:status] = object[:phase]
+          server[:node_name] = object[:node_name]
+          server[:ip_address] = object[:ip_address]
+          server
+        end
+
+        private
+
+        def running?(status)
+          !status.nil? && 'running'.casecmp(status).zero?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/server'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Servers < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Compute::Kubevirt::Server
+
+        def all(filters = {})
+          servers = service.list_servers(filters)
+          @kind = servers.kind
+          @resource_version = servers.resource_version
+          load servers
+        end
+
+        def get(id)
+          new service.get_server(id)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { stopped? }
+          server.start
+          server
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Kubevirt
+      class Service < Fog::Model
+        identity :name
+
+        attribute :namespace,        :aliases => 'metadata_namespace'
+        attribute :resource_version, :aliases => 'metadata_resource_version'
+        attribute :cluster_ip,       :aliases => 'spec_cluster_ip'
+        attribute :node_port,        :aliases => 'spec_ports_node_port'
+        attribute :port,             :aliases => 'spec_ports_port'
+        attribute :target_port,      :aliases => 'spec_ports_target_port'
+        attribute :selector,         :aliases => 'spec_selector'
+
+        def self.parse(object)
+          metadata = object[:metadata]
+          spec = object[:spec]
+          ports = spec[:ports][0]
+          selector = spec[:selector]
+          srv = {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :cluster_ip       => spec[:clusterIP],
+            :node_port        => ports[:nodePort],
+            :port             => ports[:port],
+            :target_port      => ports[:target_port],
+          }
+          srv[:selector] = selector[:special] unless selector.nil?
+
+          srv
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'fog/core/collection'
+require 'fog/compute/kubevirt/models/service'
+
+module Fog
+  module Compute
+    class Kubevirt
+      class Services < Fog::Collection
+        attr_reader :kind, :resource_version
+
+        model Fog::Compute::Kubevirt::Service
+
+        def all(filters = {})
+          begin
+            srvs = service.list_services(filters)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # we assume that we get 404
+            srvs = []
+          end
+          @kind = srvs.kind
+          @resource_version = srvs.resource_version
+          load srvs
+        end
+
+        def get(name)
+          new service.get_service(name)
+        end
+
+        # Creates a service using provided paramters:
+        # :name [String] - name of a service
+        # :port [int] - a port which will be exposed on node and cluster
+        # :target_port [int] - a vmi port which will be forwarded
+        # :vmi_name [String] - name of a vmi to be selected
+        # :service_type [String] - service type used to create service
+        #
+        # @param [Hash] attributes containing details about service to be
+        #   created.
+        def create(args = {})
+          port = args[:port]
+          name = args[:name]
+          target_port = args[:target_port]
+          vmi_name = args[:vmi_name]
+          service_type = args[:service_type]
+
+          srv = {
+            :apiVersion => "v1",
+            :kind => "Service",
+            :metadata => {
+              :name      => name,
+              :namespace => service.namespace
+            },
+            :spec => {
+              :externalTrafficPolicy => "Cluster",
+              :ports => [
+                {:nodePort   => port,
+                 :port       => port,
+                 :protocol   => "TCP",
+                 :targetPort => target_port
+                }
+              ],
+              :selector => {
+                :"kubevirt.io/vm" => vmi_name
+              },
+              :type => service_type
+            }
+          }
+
+          service.create_service(srv)
+        end
+
+        def delete(name)
+          begin
+            srv = get(name)
+          rescue ::Fog::Kubevirt::Errors::ClientError
+            # the service doesn't exist
+            srv = nil
+          end
+
+          service.delete_service(name, service.namespace) unless srv.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -1,62 +1,15 @@
+require 'fog/compute/kubevirt/models/vm_base'
+
 module Fog
   module Compute
     class Kubevirt
       class Vm < Fog::Model
-        include Shared
-
-        identity :name
-
-        attribute :namespace,        :aliases => 'metadata_namespace'
-        attribute :resource_version, :aliases => 'metadata_resource_version'
-        attribute :uid,              :aliases => 'metadata_uid'
-        attribute :labels,           :aliases => 'metadata_labels'
-        attribute :owner_reference,  :aliases => 'metadata_owner_reference'
-        attribute :annotations,      :aliases => 'metadata_annotations'
-        attribute :cpu_cores,        :aliases => 'spec_cpu_cores'
-        attribute :memory,           :aliases => 'spec_memory'
-        attribute :disks,            :aliases => 'spec_disks'
-        attribute :volumes,          :aliases => 'spec_volumes'
-
-
-        def start(options = {})
-          # Change the `running` attribute to `true` so that the virtual machine controller will take it and
-          # create the virtual machine instance.
-          vm = service.get_raw_vm(name)
-          vm = deep_merge!(vm,
-            :spec => {
-              :running => true
-            }
-          )
-          service.update_vm(vm)
-        end
-
-        def stop(options = {})
-          vm = service.get_raw_vm(name)
-          vm = deep_merge!(vm,
-            :spec => {
-              :running => false
-            }
-          )
-          service.update_vm(vm)
-        end
+        include VmAction
+        extend VmBase
+        define_properties
 
         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],
-            :labels           => metadata[:labels],
-            :annotations      => metadata[:annotations],
-            :owner_reference  => metadata[:ownerReferences],
-            :cpu_cores        => domain[:cpu][:cores],
-            :memory           => domain[:resources][:requests][:memory],
-            :disks            => domain[:devices][:disks],
-            :volumes          => spec[:volumes]
-          }
+          parse_object(object)
         end
       end
     end

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

@@ -0,0 +1,83 @@
+require 'fog/compute/kubevirt/models/vm_data'
+
+module Fog
+  module Compute
+    class Kubevirt
+      module VmBase
+        include VmData
+
+        def define_properties
+          identity :name
+
+          attribute :namespace,        :aliases => 'metadata_namespace'
+          attribute :resource_version, :aliases => 'metadata_resource_version'
+          attribute :uid,              :aliases => 'metadata_uid'
+          attribute :labels,           :aliases => 'metadata_labels'
+          attribute :owner_reference,  :aliases => 'metadata_owner_reference'
+          attribute :annotations,      :aliases => 'metadata_annotations'
+          attribute :cpu_cores,        :aliases => 'spec_cpu_cores'
+          attribute :memory,           :aliases => 'spec_memory'
+          attribute :disks,            :aliases => 'spec_disks'
+          attribute :volumes,          :aliases => 'spec_volumes'
+          attribute :status,           :aliases => 'spec_running'
+          attribute :interfaces,       :aliases => 'spec_interfaces'
+          attribute :networks,         :aliases => 'spec_networks'
+          attribute :machine_type,     :aliases => 'spec_machine_type'
+        end
+
+        def parse_object(object)
+          metadata = object[:metadata]
+          spec = object[:spec][:template][:spec]
+          domain = spec[:domain]
+          owner = metadata[:ownerReferences]
+          annotations = metadata[:annotations]
+          cpu = domain[:cpu]
+          mem = domain.dig(:resources, :requests, :memory)
+          vm = {
+            :namespace        => metadata[:namespace],
+            :name             => metadata[:name],
+            :resource_version => metadata[:resourceVersion],
+            :uid              => metadata[:uid],
+            :labels           => metadata[:labels],
+            :disks            => parse_disks(domain[:devices][:disks]),
+            :volumes          => parse_volumes(spec[:volumes]),
+            :interfaces       => parse_interfaces(domain[:devices][:interfaces]),
+            :networks         => parse_networks(spec[:networks]),
+            :state            => object[:spec][:running].to_s == "true" ? "running" : "stopped",
+            :machine_type     => domain.dig(:machine, :type)
+          }
+          vm[:owner_reference] = owner unless owner.nil?
+          vm[:annotations] = annotations unless annotations.nil?
+          vm[:cpu_cores] = cpu[:cores] unless cpu.nil?
+          vm[:memory] = mem unless mem.nil?
+
+          vm
+        end
+      end
+
+      module VmAction
+        def start(options = {})
+          # Change the `running` attribute to `true` so that the virtual machine controller will take it and
+          # create the virtual machine instance.
+          vm = service.get_raw_vm(name)
+          vm = deep_merge!(vm,
+            :spec => {
+              :running => true
+            }
+          )
+          service.update_vm(vm)
+        end
+
+        def stop(options = {})
+          vm = service.get_raw_vm(name)
+          vm = deep_merge!(vm,
+            :spec => {
+              :running => false
+            }
+          )
+          service.update_vm(vm)
+        end
+      end
+    end
+  end
+end