fog-vsphere 0.2.0 → 0.3.0

data/lib/fog/vsphere/requests/compute/folder_destroy.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def folder_destroy(path, datacenter_name)
+          folder = get_raw_vmfolder(path, datacenter_name)
+          raise Fog::Vsphere::Errors::NotFound, "No such folder #{path}" unless folder
+          raise Fog::Vsphere::Errors::ServiceError, "Folder #{path} is not empty" if folder.childEntity.size > 0
+          
+          task = folder.Destroy_Task
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+      class Mock
+        def folder_destroy(path, datacenter_name)
+          vms = list_virtual_machines(folder: path, datacenter: datacenter_name)
+          if vms.length > 0
+            raise Fog::Vsphere::Errors::ServiceError, "Folder #{path} is not empty"
+          end
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/get_folder.rb

@@ -41,7 +41,7 @@ module Fog
             # VIM::Folder#inventory since that returns _all_ managed objects of
             # a certain type _and_ their properties.
             sub = last_returned_folder.find(sub_folder, RbVmomi::VIM::Folder)
-            raise ArgumentError, "Could not descend into #{sub_folder}.  Please check your path. #{path}" unless sub
+            raise Fog::Compute::Vsphere::NotFound, "Could not descend into #{sub_folder}.  Please check your path. #{path}" unless sub
             sub
           end
         end
@@ -66,7 +66,9 @@ module Fog
       end
 
       class Mock
-        def get_folder(path, filters = { })
+        def get_folder(path, datacenter_name, type = nil)
+          self.data[:folders].values.find {|f| f['datacenter'] == datacenter_name and f['path'].end_with? path} or
+            raise Fog::Compute::Vsphere::NotFound        
         end
       end
     end

data/lib/fog/vsphere/requests/compute/get_storage_pod.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_storage_pod(name, datacenter_name)
+          storage_pod = get_raw_storage_pod(name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless storage_pod
+          storage_pod_attributes(storage_pod, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_storage_pod(name, datacenter_name)
+          dc = find_raw_datacenter(datacenter_name)
+
+          @connection.serviceContent.viewManager.CreateContainerView({
+            :container  => dc,
+            :type       => ["StoragePod"],
+            :recursive  => true
+          }).view.select{|pod| pod.name == name}.first
+        end
+      end
+
+      class Mock
+        def get_storage_pod(name, datacenter_name)
+          list_storage_pods({datacenter: datacenter_name}).select{|h| h[:name] == name }.first
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_datacenters.rb

@@ -45,7 +45,7 @@ module Fog
 
       class Mock
         def list_datacenters filters = {}
-          [ {:name => "Solutions", :status => "grey"}, {:name => "Solutions2", :status => "green" }]
+          self.data[:datacenters].values
         end
       end
     end

data/lib/fog/vsphere/requests/compute/list_datastores.rb

@@ -32,7 +32,8 @@ module Fog
       end
       class Mock
         def list_datastores(datacenter_name)
-          []
+          self.data[:datastores].values.select {|d| d['datacenter'] == datacenter_name[:datacenter]} or
+            raise Fog::Compute::Vsphere::NotFound
         end
       end
     end

data/lib/fog/vsphere/requests/compute/list_networks.rb

@@ -30,7 +30,8 @@ module Fog
       end
       class Mock
         def list_networks(datacenter_name)
-          []
+          self.data[:networks].values.select {|n| n['datacenter'] == datacenter_name[:datacenter]} or
+            raise Fog::Compute::Vsphere::NotFound
         end
       end
     end

data/lib/fog/vsphere/requests/compute/list_storage_pods.rb

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_storage_pods(filters = { })
+          datacenter_name = filters[:datacenter]
+          raw_storage_pods(datacenter_name).map do |storage_pod|
+            storage_pod_attributes(storage_pod, datacenter_name)
+          end.compact
+        end
+
+        private
+        def raw_storage_pods(datacenter_name)
+          dc = find_raw_datacenter(datacenter_name)
+
+          @connection.serviceContent.viewManager.CreateContainerView({
+            :container  => dc,
+            :type       => ["StoragePod"],
+            :recursive  => true
+          }).view
+        end
+        protected
+
+        def storage_pod_attributes storage_pod, datacenter
+          {
+            :id          => managed_obj_id(storage_pod),
+            :name        => storage_pod.name,
+            :freespace   => storage_pod.summary.freeSpace,
+            :capacity    => storage_pod.summary.capacity,
+            :datacenter  => datacenter,
+          }
+        end
+      end
+      class Mock
+        def list_storage_pods(filters = {})
+          if filters.key?(:datacenter)
+            self.data[:storage_pods].select{|h| h[:datacenter] == filters[:datacenter] }
+          else
+            self.data[:storage_pods]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -65,13 +65,17 @@ module Fog
         end
 
         def list_virtual_machines(options = { })
-          if options['instance_uuid'].nil? and options['mo_ref'].nil?
-            self.data[:servers].values
-          elsif !options['instance_uuid'].nil?
+          if options['instance_uuid']
             server = self.data[:servers][options['instance_uuid']]
             server.nil? ? [] : [server]
-          else
+          elsif options['mo_ref']
             self.data[:servers].values.select{|vm| vm['mo_ref'] == options['mo_ref']}
+          elsif options[:folder] and options[:datacenter]
+            self.data[:servers].values.select {|vm| vm['path'] == options[:folder] && vm['datacenter'] == options[:datacenter]}
+          else
+            options.delete('datacenter') # real code iterates if this is missing
+            options.reject! {|k,v| v.nil? } # ignore options with nil value
+            self.data[:servers].values.select {|vm| options.all? {|k,v| vm[k.to_s] == v.to_s }}
           end
         end
       end

data/lib/fog/vsphere/requests/compute/list_vm_cdroms.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_vm_cdroms(vm_id)
+          get_vm_ref(vm_id).config.hardware.device.select { |hw| hw.class == RbVmomi::VIM::VirtualCdrom }.map do |cdrom|
+            {
+              :filename => (cdrom.backing.fileName rescue(nil)),
+              :name => cdrom.deviceInfo.label,
+              :key => cdrom.key,
+              :controller_key => cdrom.controllerKey,
+              :unit_number => cdrom.unitNumber,
+              :start_connected => cdrom.connectable.startConnected,
+              :allow_guest_control => cdrom.connectable.allowGuestControl,
+              :connected => cdrom.connectable.connected,
+              :instance_uuid => vm_id,
+            }
+          end
+        end
+      end
+      class Mock
+        def list_vm_cdroms(vm_id)
+          raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless self.data[:servers].key?(vm_id)
+          return [] unless self.data[:servers][vm_id].key?('cdroms')
+          self.data[:servers][vm_id]['cdroms'].map {|h| h.merge({:instance_uuid => vm_id}) }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_vm_interfaces.rb

@@ -29,31 +29,52 @@ module Fog
   #unitNumber: 7,
   #
         def list_vm_interfaces(vm_id, datacenter = nil)
-          get_vm_ref(vm_id, datacenter).config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard).map do |nic|
-            {
-              :name    => nic.deviceInfo.label,
-              :mac     => nic.macAddress,
-              :network => nic.backing.respond_to?("network") ? nic.backing.network.name : nic.backing.port.portgroupKey,
-              :status  => nic.connectable.status,
-              :summary => nic.deviceInfo.summary,
-              :type    => nic.class,
-              :key     => nic.key,
-            }
-          end
+          get_raw_interfaces(vm_id, datacenter).map {|nic| raw_to_hash nic}
         end
 
         def get_vm_interface(vm_id, options={})
+          raw = get_raw_interface(vm_id, options)
+          if raw
+            raw_to_hash(raw)
+          else
+            nil
+          end
+        end
+        
+        def get_raw_interfaces(vm_id, datacenter = nil)
+          get_vm_ref(vm_id, datacenter).config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard)
+        end
+        
+        def get_raw_interface(vm_id, options={})
           raise ArgumentError, "instance id is a required parameter" unless vm_id
           if options.is_a? Fog::Compute::Vsphere::Interface
             options
           else
             raise ArgumentError, "Either key or name is a required parameter. options: #{options}" unless options.key? :key or options.key? :mac or options.key? :name
-            list_vm_interfaces(vm_id).find do | nic |
-              (options.key? :key and nic[:key]==options[:key].to_i) or (options.key? :mac and nic[:mac]==options[:mac]) or (options.key? :name and nic[:name]==options[:name])
+            get_raw_interfaces(vm_id).find do |nic|
+              (options.key? :key and nic.key==options[:key].to_i) or
+              (options.key? :mac and nic.macAddress==options[:mac]) or
+              (options.key? :name and nic.deviceInfo.label==options[:name])
             end
           end
         end
+        
+        private
+        
+        def raw_to_hash(nic)
+          {
+            :name    => nic.deviceInfo.label,
+            :mac     => nic.macAddress,
+            :network => nic.backing.respond_to?("network") ? nic.backing.network.name : nic.backing.port.portgroupKey,
+            :status  => nic.connectable.status,
+            :summary => nic.deviceInfo.summary,
+            :type    => nic.class,
+            :key     => nic.key,
+          }
+        end
+        
       end
+      
       class Mock
         def list_vm_interfaces(vm_id)
         end

data/lib/fog/vsphere/requests/compute/list_vm_snapshots.rb

@@ -3,7 +3,11 @@ module Fog
     class Vsphere
       class Real
         def list_vm_snapshots(vm_id, opts = {})
-          root_snapshots = get_vm_ref(vm_id).snapshot.rootSnapshotList.map do |snap|
+          vm_snapshot_info = get_vm_ref(vm_id).snapshot
+
+          return [] unless vm_snapshot_info
+
+          root_snapshots = vm_snapshot_info.rootSnapshotList.map do |snap|
             item = snapshot_info(snap, vm_id)
             [
               item,

data/lib/fog/vsphere/requests/compute/modify_vm_cdrom.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def add_vm_cdrom(cdrom)
+          vm_reconfig_hardware('instance_uuid' => cdrom.server.instance_uuid, 'hardware_spec' => {'deviceChange'=>[create_cdrom(cdrom, cdrom.unit_number, :add)]})
+        end
+
+        def destroy_vm_cdrom(cdrom)
+          vm_reconfig_hardware('instance_uuid' => cdrom.server.instance_uuid, 'hardware_spec' => {'deviceChange'=>[create_cdrom(cdrom, cdrom.unit_number, :remove)]})
+        end
+      end
+
+      class Mock
+        def add_vm_cdrom(cdrom)
+          vm_reconfig_hardware('instance_uuid' => cdrom.server.instance_uuid, 'hardware_spec' => {'deviceChange'=>[create_cdrom(cdrom, cdrom.unit_number, :add)]})
+        end
+
+        def destroy_vm_cdrom(cdrom)
+          vm_reconfig_hardware('instance_uuid' => cdrom.server.instance_uuid, 'hardware_spec' => {'deviceChange'=>[create_cdrom(cdrom, cdrom.unit_number, :remove)]})
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/modify_vm_interface.rb

@@ -19,11 +19,22 @@ module Fog
         def update_vm_interface(vmid, options = {})
           raise ArgumentError, "instance id is a required parameter" unless vmid
 
-          interface = get_interface_from_options(vmid, options.merge(:server_id => vmid))
-          vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[create_interface(interface, interface.key, :edit)]})
+          interface = get_interface_from_options(vmid, options)
+          raw_interface = get_raw_interface(vmid, key: interface.key)
+          if options[:network]
+            interface.network = options[:network]
+            backing = create_nic_backing(interface, {})
+            raw_interface.backing = backing
+          end
+          spec = {
+            operation: :edit,
+            device: raw_interface
+          }          
+          vm_reconfig_hardware('instance_uuid' => vmid, 'hardware_spec' => {'deviceChange'=>[spec]})
         end
 
         private
+        
         def get_interface_from_options(vmid, options)
           if options and options[:interface]
             options[:interface]
@@ -53,6 +64,12 @@ module Fog
           raise ArgumentError, "interface is a required parameter" unless options and options[:interface]
           true
         end
+        
+        def update_vm_interface(vmid, options = {})
+          return unless options[:interface]
+          options[:interface].network = options[:network]
+          options[:interface].type    = options[:type]
+        end
       end
     end
   end

data/lib/fog/vsphere/requests/compute/modify_vm_volume.rb

@@ -13,7 +13,7 @@ module Fog
 
       class Mock
         def add_vm_volume(volume)
-          true
+          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_cdrom(volume, volume.unit_number, :add)]})
         end
 
         def destroy_vm_volume(volume)

data/lib/fog/vsphere/requests/compute/upload_iso.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def upload_iso_check_options(options)
+          default_options = {
+            'upload_directory' => 'isos',
+          }
+          options = default_options.merge(options)
+          required_options = %w{ datacenter datastore local_path }
+          required_options.each do |param|
+            raise ArgumentError, "#{required_options.join(', ')} are required" unless options.key? param
+          end
+          raise Fog::Compute::Vsphere::NotFound, "Datacenter #{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
+          raise Fog::Compute::Vsphere::NotFound, "Datastore #{options["datastore"]} Doesn't Exist!" unless get_raw_datastore(options['datastore'], options['datacenter'])
+          options
+        end
+
+        def upload_iso(options = {})
+          options = upload_iso_check_options(options)
+          datastore = get_raw_datastore(options['datastore'], options['datacenter'])
+          datacenter = get_datacenter(options['datacenter'])
+          filename = options['filename'] || File.basename(options['local_path'])
+          unless datastore.exists? options['upload_directory']+'/'
+            @connection.serviceContent.fileManager.MakeDirectory :name => "[#{options['datastore']}] #{options['directory']}",
+                                                                 :datacenter => datacenter,
+                                                                 :createParentDirectories => false
+          end
+          datastore.upload options['upload_directory']+'/'+filename, options['local_path']
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/vm_clone.rb

@@ -10,6 +10,7 @@ module Fog
             'nic_type' => 'VirtualE1000',
           }
           options = default_options.merge(options)
+          options["storage_pod"] = nil if options["storage_pod"] == ''
           # Backwards compat for "path" option
           options["template_path"] ||= options["path"]
           options["path"] ||= options["template_path"]
@@ -19,6 +20,7 @@ module Fog
           end
           raise Fog::Compute::Vsphere::NotFound, "Datacenter #{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
           raise Fog::Compute::Vsphere::NotFound, "Template #{options["template_path"]} Doesn't Exist!" unless get_virtual_machine(options["template_path"], options["datacenter"])
+          raise Fog::Compute::Vsphere::NotFound, "Storage Pod #{options["storage_pod"]} Doesn't Exist!" if options.key?('storage_pod') and ! get_storage_pod(options['storage_pod'], options['datacenter'])
           options
         end
       end
@@ -54,6 +56,7 @@ module Fog
         #     Example: ['cluster_name_here','resource_pool_name_here']
         #   * 'datastore'<~String> - The datastore you'd like to use.
         #       (datacenterObj.datastoreFolder.find('name') in API)
+        #   * 'storage_pod'<~String> - The storage pod / datastore cluster you'd like to use.
         #   * 'transform'<~String> - Not documented - see http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.RelocateSpec.html
         #   * 'numCPUs'<~Integer> - the number of Virtual CPUs of the Destination VM
         #   * 'memoryMB'<~Integer> - the size of memory of the Destination VM in MB
@@ -537,6 +540,9 @@ module Fog
 
           relocation_spec=nil
           if ( options['linked_clone'] )
+            # Storage DRS does not support vSphere linked clones.
+            # http://www.vmware.com/files/pdf/techpaper/vsphere-storage-drs-interoperability.pdf
+            raise ArgumentError, "linked clones are not supported on storage pods" unless options.key?('storage_pod')
             # cribbed heavily from the rbvmomi clone_vm.rb
             # this chunk of code reconfigures the disk of the clone source to be read only,
             # and then creates a delta disk on top of that, this is required by the API in order to create
@@ -569,9 +575,11 @@ module Fog
                                                                       :pool => resource_pool,
                                                                       :diskMoveType => :moveChildMostDiskBacking)
           else
-            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:datastore => datastore_obj,
-                                                                      :pool => resource_pool,
+            relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
                                                                       :transform => options['transform'] || 'sparse')
+            unless options.key?('storage_pod') and datastore_obj.nil?
+              relocation_spec[:datastore] = datastore_obj
+            end
           end
           # And the clone specification
           clone_spec = RbVmomi::VIM.VirtualMachineCloneSpec(:location => relocation_spec,
@@ -581,31 +589,66 @@ module Fog
                                                             :template => false)
 
           # Perform the actual Clone Task
-          task = vm_mob_ref.CloneVM_Task(:folder => dest_folder,
+          # Clone VM on a storage pod
+          if options.key?('storage_pod')
+            raise ArgumentError, "need to use at least vsphere revision 5.0 or greater to use storage pods" unless @vsphere_rev.to_f >= 5
+            pod_spec     = RbVmomi::VIM::StorageDrsPodSelectionSpec.new(
+              :storagePod => get_raw_storage_pod(options['storage_pod'], options['datacenter']),
+            )
+            storage_spec = RbVmomi::VIM::StoragePlacementSpec.new(
+              :type => 'clone',
+              :folder => dest_folder,
+              :resourcePool => resource_pool,
+              :podSelectionSpec => pod_spec,
+              :cloneSpec => clone_spec,
+              :cloneName => options['name'],
+              :vm => vm_mob_ref,
+            )
+            srm = @connection.serviceContent.storageResourceManager
+            result = srm.RecommendDatastores(:storageSpec => storage_spec)
+
+            # if result array contains recommendation, we can apply it
+            if key = result.recommendations.first.key
+              task = srm.ApplyStorageDrsRecommendation_Task(:key => [key])
+              if options.fetch('wait', true) then
+                result = task.wait_for_completion
+                new_vm = result.vm
+              else
+                new_vm = nil
+                Fog.wait_for(150, 15) {
+                  begin
+                    new_vm = dest_folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+                  rescue Fog::Vsphere::Errors::NotFound
+                    new_vm = nil
+                  end
+                }
+                raise Fog::Vsphere::Errors::NotFound unless new_vm
+              end
+            end
+          else
+            task = vm_mob_ref.CloneVM_Task(:folder => dest_folder,
                                          :name => options['name'],
                                          :spec => clone_spec)
-          # Waiting for the VM to complete allows us to get the VirtulMachine
-          # object of the new machine when it's done.  It is HIGHLY recommended
-          # to set 'wait' => true if your app wants to wait.  Otherwise, you're
-          # going to have to reload the server model over and over which
-          # generates a lot of time consuming API calls to vmware.
-          if options.fetch('wait', true) then
-            # REVISIT: It would be awesome to call a block passed to this
-            # request to notify the application how far along in the process we
-            # are.  I'm thinking of updating a progress bar, etc...
-            new_vm = task.wait_for_completion
-          else
-            tries = 0
-            new_vm = begin
-              # Try and find the new VM (folder.find is quite efficient)
-              dest_folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
-            rescue Fog::Vsphere::Errors::NotFound
-              tries += 1
-              if tries <= 10 then
-                sleep 15
-                retry
-              end
-              nil
+            # Waiting for the VM to complete allows us to get the VirtulMachine
+            # object of the new machine when it's done.  It is HIGHLY recommended
+            # to set 'wait' => true if your app wants to wait.  Otherwise, you're
+            # going to have to reload the server model over and over which
+            # generates a lot of time consuming API calls to vmware.
+            if options.fetch('wait', true) then
+              # REVISIT: It would be awesome to call a block passed to this
+              # request to notify the application how far along in the process we
+              # are.  I'm thinking of updating a progress bar, etc...
+              new_vm = task.wait_for_completion
+            else
+              new_vm = nil
+              Fog.wait_for(150, 15) {
+                begin
+                  new_vm = dest_folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+                rescue Fog::Vsphere::Errors::NotFound
+                  new_vm = nil
+                end
+              }
+              raise Fog::Vsphere::Errors::NotFound unless new_vm
             end
           end