fog 1.36.0 → 1.37.0

data/lib/fog/vsphere/core.rb

@@ -1,39 +0,0 @@
-require 'fog/core'
-
-module Fog
-  module Vsphere
-    extend Fog::Provider
-
-    module Errors
-      class ServiceError < Fog::Errors::Error; end
-      class SecurityError < ServiceError; end
-      class NotFound < ServiceError; end
-    end
-
-    service(:compute, 'Compute')
-
-    # This helper was originally added as Fog.class_as_string and moved to core but only used here
-    def self.class_from_string classname, defaultpath=""
-      if classname and classname.is_a? String then
-        chain = classname.split("::")
-        klass = Kernel
-        chain.each do |klass_string|
-          klass = klass.const_get klass_string
-        end
-        if klass.is_a? Class then
-          klass
-        elsif defaultpath != nil then
-          class_from_string((defaultpath.split("::")+chain).join("::"), nil)
-        else
-          nil
-        end
-      elsif classname and classname.is_a? Class then
-        classname
-      else
-        nil
-      end
-    rescue NameError
-      defaultpath != nil ? class_from_string((defaultpath.split("::")+chain).join("::"), nil) : nil
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/cluster.rb

@@ -1,28 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Cluster < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :datacenter
-        attribute :num_host
-        attribute :num_cpu_cores
-        attribute :overall_status
-        attribute :full_path
-
-        def resource_pools(filters = { })
-          self.attributes[:resource_pools] ||= id.nil? ? [] : service.resource_pools({
-                                                                                          :service => service,
-                                                                                          :cluster    => name,
-                                                                                          :datacenter => datacenter
-                                                                                        }.merge(filters))
-        end
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/clusters.rb

@@ -1,23 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/cluster'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Clusters < Fog::Collection
-        model Fog::Compute::Vsphere::Cluster
-        attr_accessor :datacenter
-
-        def all(filters = {})
-          requires :datacenter
-          load service.list_clusters(filters.merge(:datacenter => datacenter))
-        end
-
-        def get(id)
-          requires :datacenter
-          new service.get_cluster(id, datacenter)
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/customfield.rb

@@ -1,16 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Customfield < Fog::Model
-        identity :key
-
-        attribute :name
-        attribute :type
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/customfields.rb

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/customfield'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Customfields < Fog::Collection
-        model Fog::Compute::Vsphere::Customfield
-
-        attr_accessor :vm
-
-        def all(filters = {})
-          load service.list_customfields()
-        end
-
-        def get(key)
-          load(service.list_customfields()).find do | cv |
-            cv.key == ((key.is_a? String) ? key.to_i : key)
-          end
-        end
-     end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/customvalue.rb

@@ -1,14 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Customvalue < Fog::Model
-        attribute :value
-        attribute :key
-
-        def to_s
-          value
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/customvalues.rb

@@ -1,34 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/customvalue'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Customvalues < Fog::Collection
-        model Fog::Compute::Vsphere::Customvalue
-
-        attr_accessor :vm
-
-        def all(filters = {})
-          requires :vm
-          case vm
-            when Fog::Compute::Vsphere::Server
-              load service.list_vm_customvalues(vm.id)
-            else
-            raise 'customvalues should have vm'
-          end
-        end
-
-        def get(key)
-          requires :vm
-          case vm
-            when Fog::Compute::Vsphere::Server
-              load service.list_vm_customvalues(vm.id)
-            else
-            raise 'customvalues should have vm'
-          end.find { | cv | cv.key == key }
-        end
-     end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/datacenter.rb

@@ -1,44 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Datacenter < Fog::Model
-        identity :id
-        attribute :name
-        attribute :path
-        attribute :status
-
-        def clusters filters = { }
-          service.clusters({ :datacenter => path.join("/") }.merge(filters))
-        end
-
-        def networks filters = { }
-          service.networks({ :datacenter => path.join("/") }.merge(filters))
-        end
-
-        def datastores filters = { }
-          service.datastores({ :datacenter => path.join("/") }.merge(filters))
-        end
-
-        def vm_folders filters = { }
-          service.folders({ :datacenter => path.join("/"), :type => :vm }.merge(filters))
-        end
-
-        def virtual_machines filters = {}
-          service.servers({ :datacenter => path.join("/") }.merge(filters))
-        end
-
-        def servertypes filters={}
-          service.servertypes({:datacenter => name }.merge(filters))
-        end
-
-        def customfields filters = {}
-          service.customfields({ :datacenter => path.join("/")}.merge(filters))
-        end
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/datacenters.rb

@@ -1,20 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/datacenter'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Datacenters < Fog::Collection
-        model Fog::Compute::Vsphere::Datacenter
-
-        def all(filters = {})
-          load service.list_datacenters(filters)
-        end
-
-        def get(name)
-          new service.get_datacenter(name)
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/datastore.rb

@@ -1,21 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Datastore < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :datacenter
-        attribute :type
-        attribute :freespace
-        attribute :accessible # reachable by at least one hypervisor
-        attribute :capacity
-        attribute :uncommitted
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/datastores.rb

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/datastore'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Datastores < Fog::Collection
-        model Fog::Compute::Vsphere::Datastore
-        attr_accessor :datacenter
-
-        def all(filters = {})
-          load service.list_datastores(filters.merge(:datacenter => datacenter))
-        end
-
-        def get(id)
-          requires :datacenter
-          new service.get_datastore(id, datacenter)
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/folder.rb

@@ -1,24 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Folder < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :parent
-        attribute :datacenter
-        attribute :path
-        attribute :type
-
-        def vms
-          return [] if type.to_s != 'vm'
-          service.servers(:folder => path, :datacenter => datacenter)
-        end
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/folders.rb

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/folder'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Folders < Fog::Collection
-        model Fog::Compute::Vsphere::Folder
-        attr_accessor :datacenter, :type, :path
-
-        def all(filters = { })
-          requires :datacenter
-          requires :type
-          load service.list_folders(filters.merge(:datacenter => datacenter, :type => type, :path => path))
-        end
-
-        def get(id)
-          requires :datacenter
-          new service.get_folder(id, datacenter, type)
-        end
-      end
-    end
-  end
-end

data/lib/fog/vsphere/models/compute/interface.rb

@@ -1,91 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Interface < Fog::Model
-        SAVE_MUTEX = Mutex.new
-
-        identity :mac
-        alias_method :id, :mac
-
-        attribute :network
-        attribute :name
-        attribute :status
-        attribute :summary
-        attribute :type
-        attribute :key
-        attribute :virtualswitch
-        attribute :server_id
-
-        def initialize(attributes = {})
-          # Assign server first to prevent race condition with persisted?
-          self.server_id = attributes.delete(:server_id)
-
-          if attributes.key? :type then
-            if attributes[:type].is_a? String then
-              attributes[:type] = Fog::Vsphere.class_from_string(attributes[:type], "RbVmomi::VIM")
-            end
-          else
-            attributes[:type] = Fog::Vsphere.class_from_string("VirtualE1000", "RbVmomi::VIM")
-          end
-
-          super defaults.merge(attributes)
-        end
-
-        def to_s
-          name
-        end
-
-        def server
-          requires :server_id
-          service.servers.get(server_id)
-        end
-
-        def destroy
-          requires :server_id, :key, :type
-
-          service.destroy_vm_interface(server_id, :key => key, :type => type)
-        end
-
-        def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
-          requires :server_id, :type, :network
-
-          # Our approach of finding the newly created interface is rough.  We assume that the :key value always increments
-          # and thus the highest :key value must correspond to the created interface.  Since this has an inherent race
-          # condition we need to gate the saves.
-          SAVE_MUTEX.synchronize do
-            data = service.add_vm_interface(server_id, attributes)
-
-            if data['task_state'] == 'success'
-              # We have to query vSphere to get the interface attributes since the task handle doesn't include that info.
-              created = server.interfaces.all.sort_by(&:key).last
-
-              self.mac = created.mac
-              self.name = created.name
-              self.status = created.status
-              self.summary = created.summary
-              self.key = created.key
-              self.virtualswitch = created.virtualswitch
-
-              true
-            else
-              false
-            end
-          end
-        end
-
-        private
-
-        def defaults
-          default_type=Fog.credentials[:default_nic_type] || RbVmomi::VIM::VirtualE1000
-          {
-            :name=>"Network adapter",
-            :network=>"VM Network",
-            :summary=>"VM Network",
-            :type=> Fog::Vsphere.class_from_string(default_type, "RbVmomi::VIM"),
-          }
-        end
-      end
-    end
-  end
-end