fog 1.31.0 → 1.37.0

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

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

@@ -1,67 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/interface'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Interfaces < Fog::Collection
-        model Fog::Compute::Vsphere::Interface
-
-        attribute :server_id
-
-        def all(filters = {})
-          requires :server_id
-
-          case server
-            when Fog::Compute::Vsphere::Server
-              load service.list_vm_interfaces(server.id)
-            when Fog::Compute::Vsphere::Template
-              load service.list_template_interfaces(server.id)
-            else
-            raise 'interfaces should have vm or template'
-          end
-
-          self.each { |interface| interface.server_id = server.id }
-          self
-        end
-
-        def get(id)
-          requires :server_id
-
-          case server
-            when Fog::Compute::Vsphere::Server
-              interface = service.get_vm_interface(server.id, :key => id, :mac=> id, :name => id)
-            when Fog::Compute::Vsphere::Template
-              interface = service.get_template_interfaces(server.id, :key => id, :mac=> id, :name => id)
-            else
-
-            raise 'interfaces should have vm or template'
-          end
-
-          if interface
-            Fog::Compute::Vsphere::Interface.new(interface.merge(:server_id => server.id, :service => service))
-          else
-            nil
-          end
-        end
-
-        def new(attributes = {})
-          if server_id
-            super({ :server_id => server_id  }.merge(attributes))
-          else
-            super
-          end
-        end
-
-        def server
-          return nil if server_id.nil?
-          service.servers.get(server_id)
-        end
-
-        def server=(new_server)
-          server_id = new_server.id
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Interfacetype < Fog::Model
-        identity :id
-
-#        attribute :class
-        attribute :name
-        attribute :datacenter
-        attribute :servertype
-
-        def initialize(attributes={} )
-          super attributes
-        end
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require 'fog/core/collection'
-require 'fog/vsphere/models/compute/interfacetype'
-
-module Fog
-  module Compute
-    class Vsphere
-      class Interfacetypes < Fog::Collection
-        model Fog::Compute::Vsphere::Interfacetype
-        attr_accessor :datacenter
-        attr_accessor :servertype
-
-        def all(filters = { })
-          requires :servertype
-          case servertype
-            when Fog::Compute::Vsphere::Servertype
-               load service.list_interface_types(filters.merge({
-                                                      :datacenter => datacenter,
-                                                      :servertype => servertype.id
-                                                 }))
-            else
-               raise 'interfacetypes should have a servertype'
-          end
-        end
-
-        def get(id)
-          requires :servertype
-          requires :datacenter
-          new service.get_interface_type id, servertype, datacenter
-        rescue Fog::Compute::Vsphere::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class Network < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :datacenter
-        attribute :accessible # reachable by at least one hypervisor
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,19 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class ResourcePool < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :cluster
-        attribute :datacenter
-        attribute :configured_memory_mb
-        attribute :overall_status
-
-        def to_s
-          name
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,16 +0,0 @@
-module Fog
-  module Compute
-    class Vsphere
-      class SCSIController < Fog::Model
-        attribute :shared_bus
-        attribute :type
-        attribute :unit_number
-        attribute :key
-
-        def to_s
-          "#{type} ##{key}: shared: #{shared_bus}, unit_number: #{unit_number}"
-        end
-      end
-    end
-  end
-end