fog 1.7.0 → 1.8.0

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

@@ -0,0 +1,23 @@
+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 connection.list_datacenters(filters)
+        end
+
+        def get(name)
+          new connection.get_datacenter(name)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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 connection.list_datastores(filters.merge(:datacenter => datacenter))
+        end
+
+        def get(id)
+          requires :datacenter
+          new connection.get_datastore(id, datacenter)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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'
+          connection.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,27 @@
+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 connection.list_folders(filters.merge(:datacenter => datacenter, :type => type, :path => path))
+        end
+
+        def get(id)
+          requires :datacenter
+          new connection.get_folder(id, datacenter, type)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Vsphere
+
+      class Interface < Fog::Model
+
+        identity :mac
+
+        attribute :network
+        attribute :name
+        attribute :status
+        attribute :summary
+        attribute :type
+
+        def initialize(attributes={} )
+          super defaults.merge(attributes)
+        end
+
+        def to_s
+          name
+        end
+
+        private
+
+        def defaults
+          {
+            :name=>"Network adapter",
+            :network=>"VM Network",
+            :summary=>"VM Network",
+            :type=> RbVmomi::VIM::VirtualE1000,
+          }
+        end
+
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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
+
+        attr_accessor :vm
+
+        def all(filters = {})
+          requires :vm
+          case vm
+            when Fog::Compute::Vsphere::Server
+              load connection.list_vm_interfaces(vm.id)
+            when Fog::Compute::Vsphere::Template
+              load connection.list_template_interfaces(vm.id)
+            else
+            raise 'interfaces should have vm or template'
+          end
+        end
+
+        def get(id)
+          new connection.get_interface(id)
+        end
+
+     end
+    end
+  end
+end

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

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

@@ -0,0 +1,25 @@
+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 = {})
+          load connection.list_networks(filters.merge(:datacenter => datacenter))
+        end
+
+        def get(id)
+          requires :datacenter
+          new connection.get_network(id, datacenter)
+        end
+
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,26 @@
+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 connection.list_resource_pools(filters.merge(:datacenter => datacenter, :cluster => cluster))
+        end
+
+        def get(id)
+          requires :datacenter
+          requires :cluster
+          new connection.get_resource_pool(id, cluster, datacenter)
+        end
+
+      end
+    end
+  end
+end

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

@@ -20,8 +20,6 @@ module Fog
         attribute :name
         # UUID may be the same from VM to VM if the user does not select (I copied it)
         attribute :uuid
-        # Instance UUID should be unique across a vCenter deployment.
-        attribute :instance_uuid
         attribute :hostname
         attribute :operatingsystem
         attribute :ipaddress,     :aliases => 'public_ip_address'
@@ -30,12 +28,26 @@ module Fog
         attribute :tools_version
         attribute :mac_addresses, :aliases => 'macs'
         attribute :hypervisor,    :aliases => 'host'
-        attribute :is_a_template
         attribute :connection_state
         attribute :mo_ref
         attribute :path
         attribute :memory_mb
         attribute :cpus
+        attribute :interfaces
+        attribute :volumes
+        attribute :overall_status, :aliases => 'status'
+        attribute :cluster
+        attribute :datacenter
+        attribute :resource_pool
+        attribute :instance_uuid # move this --> id
+        attribute :guest_id
+
+        def initialize(attributes={} )
+          super defaults.merge(attributes)
+          self.instance_uuid ||= id # TODO: remvoe instance_uuid as it can be replaced with simple id
+          initialize_interfaces
+          initialize_volumes
+        end
 
         def vm_reconfig_memory(options = {})
           requires :instance_uuid, :memory
@@ -81,16 +93,8 @@ module Fog
           connection.vm_migrate('instance_uuid' => instance_uuid, 'priority' => options[:priority])
         end
 
-        def create(options ={})
-          requires :name, :path
-          new_vm = self.class.new(create_results['vm_attributes'])
-          new_vm.collection = self.collection
-          new_vm.connection = self.connection
-          new_vm
-        end
-
         def clone(options = {})
-          requires :name, :path
+          requires :name, :datacenter
           # Convert symbols to strings
           req_options = options.inject({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
           # Give our path to the request
@@ -131,6 +135,68 @@ module Fog
           memory_mb * 1024 * 1024
         end
 
+        def mac
+          interfaces.first.mac unless interfaces.empty?
+        end
+
+        def interfaces
+          attributes[:interfaces] ||= id.nil? ? [] : connection.interfaces( :vm => self )
+        end
+
+        def volumes
+          attributes[:volumes] ||= id.nil? ? [] : connection.volumes( :vm => self )
+        end
+
+        def folder
+          return nil unless datacenter and path
+          attributes[:folder] ||= connection.folders(:datacenter => datacenter, :type => :vm).get(path)
+        end
+
+        def save
+          requires :name, :cluster, :datacenter
+          if identity
+            raise "update is not supported yet"
+           # connection.update_vm(attributes)
+          else
+            self.id = connection.create_vm(attributes)
+          end
+          reload
+        end
+
+        def new?
+          id.nil?
+        end
+
+        def reload
+          # reload does not re-read assoiciated attributes, so we clear it manually
+          [:interfaces, :volumes].each do |attr|
+            self.attributes.delete(attr)
+          end
+          super
+        end
+
+        private
+
+        def defaults
+          {
+            :cpus      => 1,
+            :memory_mb => 512,
+            :guest_id  => 'otherGuest',
+            :path      => '/'
+          }
+        end
+
+        def initialize_interfaces
+          if attributes[:interfaces] and attributes[:interfaces].is_a?(Array)
+            self.attributes[:interfaces].map! { |nic| nic.is_a?(Hash) ? connection.interfaces.new(nic) : nic }
+          end
+        end
+
+        def initialize_volumes
+          if attributes[:volumes] and attributes[:volumes].is_a?(Array)
+            self.attributes[:volumes].map! { |vol| vol.is_a?(Hash) ? connection.volumes.new(vol) : vol }
+          end
+        end
       end
 
     end

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

@@ -8,30 +8,26 @@ module Fog
       class Servers < Fog::Collection
 
         model Fog::Compute::Vsphere::Server
+        attr_accessor :datacenter
+        attr_accessor :network
+        attr_accessor :cluster
+        attr_accessor :resource_pool
+        attr_accessor :folder
 
-        # 'path' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
+        # 'folder' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
         # than simply listing everything.
-        def all(filters = {})
-          # REVISIT: I'm not sure if this is the best way to implement search
-          # filters on a collection but it does work.  I need to study the AWS
-          # code more to make sure this matches up.
-          filters['folder'] ||= attributes['folder']
-          response = connection.list_virtual_machines(filters)
-          load(response['virtual_machines'])
+        def all(filters = { })
+          load connection.list_virtual_machines(filters.merge(
+                                                  :datacenter    => datacenter,
+                                                  :cluster       => cluster,
+                                                  :network       => network,
+                                                  :resource_pool => resource_pool,
+                                                  :folder        => folder
+                                                ))
         end
 
-        def get(id)
-          # Is the id a managed_object_reference?  This may be the case if we're reloading
-          # a model of a VM in the process of being cloned, since it
-          # will not have a instance_uuid yet.
-          if id =~ /^vm-/
-            response = connection.find_vm_by_ref('vm_ref' => id)
-            server_attributes = response['virtual_machine']
-          else
-            response = connection.list_virtual_machines('instance_uuid' => id)
-            server_attributes = response['virtual_machines'].first
-          end
-          new(server_attributes)
+        def get(id, datacenter = nil)
+          new connection.get_virtual_machine id, datacenter
         rescue Fog::Compute::Vsphere::NotFound
           nil
         end