fog-kubevirt 0.3.0 → 1.0.1

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

@@ -1,73 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/kubevirt/models/persistentvolume'
-
-module Fog
-  module Compute
-    class Kubevirt
-      class Persistentvolumes < Fog::Collection
-        attr_reader :kind, :resource_version
-
-        model Fog::Compute::Kubevirt::Persistentvolume
-
-        def all(filters = {})
-          volumes = service.list_persistentvolumes(filters)
-          @kind = volumes.kind
-          @resource_version = volumes.resource_version
-          load volumes
-        end
-
-        def get(name)
-          new service.get_persistentvolume(name)
-        end
-
-        # Creates a volume using provided paramters:
-        # :name [String] - name of a volume
-        # :labels [Hash] - a hash of key,values representing the labels
-        # :storage_class [String] - the storage class name of the volume
-        # :capacity [String] - The capacity of the storage if applied
-        # :accessModes [Arr] - the access modes for the volume, values are specified here:
-        #    https://kubernetes.io/docs/concepts/storage/persistent-volumes/#access-modes
-        # :type [String] - the type of the storage
-        # :config [Hash] - storage specific configuration to be applied for the volume
-        #    correlated to the args[:type]
-        # @param [Hash] attributes containing details about volume to be created.
-        def create(args = {})
-          name = args[:name]
-          labels = args[:labels]
-
-          volume = {
-            :apiVersion => "v1",
-            :kind => "PersistentVolume",
-            :metadata => {
-              :name      => name
-            },
-            :spec => {
-              :storageClassName => args[:storage_class]
-            }
-          }
-
-          volume[:metadata][:labels] = labels if labels
-          volume[:spec][:capacity] = {
-            :storage => args[:capacity]
-          } if args[:capacity]
-
-          volume[:spec][:accessModes] = args[:access_modes] if args[:access_modes]
-          volume[:spec][args[:type].to_sym] = args[:config] if args[:type]
-
-          service.create_persistentvolume(volume)
-        end
-
-        def delete(name)
-          begin
-            volume = get(name)
-          rescue ::Fog::Kubevirt::Errors::ClientError
-            # the volume doesn't exist
-            volume = nil
-          end
-
-          service.delete_persistentvolume(name) unless volume.nil?
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,44 +0,0 @@
-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
-
-        # 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)
-        end
-
-        def self.parse(object)
-          server = parse_object(object)
-          server[:state] = 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

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

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

@@ -1,83 +0,0 @@
-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/storageclass.rb

@@ -1,33 +0,0 @@
-module Fog
-  module Compute
-    class Kubevirt
-      class Storageclass < Fog::Model
-        # Metadata
-        identity :name
-        attribute :resource_version,  :aliases => 'metadata_resource_version'
-        attribute :uid,               :aliases => 'metadata_uid'
-
-        attribute :mount_options
-        attribute :parameters
-        attribute :provisioner
-        attribute :reclaim_policy
-        attribute :volume_binding_mode
-
-        def self.parse(object)
-          metadata = object[:metadata]
-          {
-            :name                => metadata[:name],
-            :resource_version    => metadata[:resourceVersion],
-            :uid                 => metadata[:uid],
-
-            :parameters          => object[:parameters],
-            :mount_options       => object[:mountOptions],
-            :provisioner         => object[:provisioner],
-            :reclaim_policy      => object[:reclaimPolicy],
-            :volume_binding_mode => object[:volumeBindingMode]
-          }
-        end
-      end
-    end
-  end
-end