fog-vsphere 0.1.0

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

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

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Clusters < Fog::Collection
+        autoload :Cluster, File.expand_path('../cluster', __FILE__)
+
+        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

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Customfields < Fog::Collection
+        autoload :Customfield, File.expand_path('../customfield', __FILE__)
+
+        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

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

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Customvalues < Fog::Collection
+        autoload :Customvalue, File.expand_path('../customvalue', __FILE__)
+
+        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

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

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Datacenters < Fog::Collection
+        autoload :Datacenter, File.expand_path('../datacenter', __FILE__)
+
+        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

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

@@ -0,0 +1,21 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Datastores < Fog::Collection
+        autoload :Datastore, File.expand_path('../datastore', __FILE__)
+
+        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

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

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Folders < Fog::Collection
+        autoload :Folder, File.expand_path('../folder', __FILE__)
+
+        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

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

@@ -0,0 +1,66 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Interfaces < Fog::Collection
+        autoload :Interface, File.expand_path('../interface', __FILE__)
+
+        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