fog-vsphere 1.7.0.1 → 1.7.1

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

@@ -20,7 +20,7 @@ module Fog
           vm_cfg[:cpuHotAddEnabled] = attributes[:cpuHotAddEnabled] if attributes.key?(:cpuHotAddEnabled)
           vm_cfg[:memoryHotAddEnabled] = attributes[:memoryHotAddEnabled] if attributes.key?(:memoryHotAddEnabled)
           vm_cfg[:firmware] = attributes[:firmware] if attributes.key?(:firmware)
-          vm_cfg[:bootOptions] = boot_options(attributes) if attributes.key?(:boot_order) || attributes.key?(:boot_retry)
+          vm_cfg[:bootOptions] = boot_options(attributes, vm_cfg) if attributes.key?(:boot_order) || attributes.key?(:boot_retry)
           resource_pool = if attributes[:resource_pool] && attributes[:resource_pool] != 'Resources'
                             get_raw_resource_pool(attributes[:resource_pool], attributes[:cluster], attributes[:datacenter])
                           else
@@ -97,9 +97,12 @@ module Fog
             devices << nics.map { |nic| create_interface(nic, nics.index(nic), :add, attributes) }
           end
 
+          if (scsi_controllers = (attributes[:scsi_controllers] || attributes["scsi_controller"]))
+            devices << scsi_controllers.each_with_index.map { |controller, index| create_controller(controller, index) }
+          end
+
           if (disks = attributes[:volumes])
-            devices << create_controller(attributes[:scsi_controller]||attributes["scsi_controller"]||{})
-            devices << disks.map { |disk| create_disk(disk, disks.index(disk), :add, 1000, get_storage_pod(attributes)) }
+            devices << disks.map { |disk| create_disk(disk, :add, get_storage_pod(attributes)) }
           end
 
           if (cdroms = attributes[:cdroms])
@@ -108,12 +111,12 @@ module Fog
           devices.flatten
         end
 
-        def boot_options attributes
+        def boot_options(attributes, vm_cfg)
           # NOTE: you must be using vsphere_rev 5.0 or greater to set boot_order
           # e.g. Fog::Compute.new(provider: "vsphere", vsphere_rev: "5.5", etc)
           options = {}
           if @vsphere_rev.to_f >= 5 and attributes[:boot_order]
-            options[:bootOrder] = boot_order(attributes)
+            options[:bootOrder] = boot_order(attributes, vm_cfg)
           end
 
           # Set attributes[:boot_retry] to a delay in miliseconds to enable boot retries
@@ -121,11 +124,11 @@ module Fog
             options[:bootRetryEnabled] = true
             options[:bootRetryDelay]   = attributes[:boot_retry]
           end
-                   
+
           options.empty? ? nil : RbVmomi::VIM::VirtualMachineBootOptions.new(options)
         end
 
-        def boot_order attributes
+        def boot_order(attributes, vm_cfg)
           # attributes[:boot_order] may be an array like this ['network', 'disk']
           # stating, that we want to prefer network boots over disk boots
           boot_order = []
@@ -142,18 +145,17 @@ module Fog
                 end
               end
             when 'disk'
-              if disks = attributes[:volumes]
-                disks.each do |disk|
-                  # we allow booting from all harddisks, the first disk has the highest priority
-                  boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableDiskDevice.new(
-                    :deviceKey => disk.key || get_disk_device_key(disks.index(disk)),
-                  )
-                end
+              disks = vm_cfg[:deviceChange].map {|dev| dev[:device]}.select { |dev| dev.is_a? RbVmomi::VIM::VirtualDisk }
+              disks.each do |disk|
+                # we allow booting from all harddisks, the first disk has the highest priority
+                boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableDiskDevice.new(
+                  :deviceKey => disk.key
+                )
               end
             when 'cdrom'
-              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableCdromDevice.new()
+              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableCdromDevice.new
             when 'floppy'
-              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableFloppyDevice.new()
+              boot_order << RbVmomi::VIM::VirtualMachineBootOptionsBootableFloppyDevice.new
             else
               raise "failed to create boot device because \"#{boot_device}\" is unknown"
             end
@@ -161,19 +163,6 @@ module Fog
           boot_order
         end
 
-        def get_disk_device_key(index)
-          # disk key is based on 2000 + the SCSI ID + the controller bus * 16
-          # the scsi host adapter appears as SCSI ID 7, so we have to skip that
-          # host adapter key is based on 1000 + bus id
-          # fog assumes that there is only a single scsi controller, see device_change()
-          if (index > 6) then
-            _index = index + 1
-          else
-            _index = index
-          end
-          2000 + _index
-        end
-
         def create_nic_backing nic, attributes
           raw_network = get_raw_network(nic.network, attributes[:datacenter], if nic.virtualswitch then nic.virtualswitch end)
 
@@ -204,9 +193,9 @@ module Fog
           }
         end
 
-        def create_controller options=nil
-          options=if options
-                    controller_default_options.merge(Hash[options.map{|k,v| [k.to_sym,v] }])
+        def create_controller(controller=nil, index = 0)
+          options=if controller
+                    controller_default_options.merge(controller.attributes)
                   else
                     controller_default_options
                   end
@@ -218,15 +207,15 @@ module Fog
           {
             :operation => options[:operation],
             :device    => controller_class.new({
-              :key       => options[:key],
-              :busNumber => options[:bus_id],
+              :key       => options[:key] || (1000 + index),
+              :busNumber => options[:bus_id] || index,
               :sharedBus => controller_get_shared_from_options(options),
             })
           }
         end
 
         def controller_default_options
-          {:operation => "add", :type => RbVmomi::VIM.VirtualLsiLogicController.class, :key => 1000, :bus_id => 0, :shared => false }
+          {:operation => :add, :type => RbVmomi::VIM.VirtualLsiLogicController.class, :shared => false }
         end
 
         def controller_get_shared_from_options options
@@ -241,30 +230,29 @@ module Fog
           end
         end
 
-        def create_disk disk, index = 0, operation = :add, controller_key = 1000, storage_pod = nil
-          if (index > 6) then
-            _index = index + 1
-          else
-            _index = index
-          end
+        def create_disk(disk, operation = :add, storage_pod = nil)
           # If we deploy the vm on a storage pod, datastore has to be an empty string
           if storage_pod
             datastore = ''
           else
             datastore = "[#{disk.datastore}]"
           end
+
+          disk.set_unit_number
+          disk.set_key
+
           payload = {
             :operation     => operation,
             :fileOperation => operation == :add ? :create : :destroy,
             :device        => RbVmomi::VIM.VirtualDisk(
-              :key           => disk.key || _index,
+              :key           => disk.key,
               :backing       => RbVmomi::VIM.VirtualDiskFlatVer2BackingInfo(
                 :fileName        => datastore,
                 :diskMode        => disk.mode.to_sym,
                 :thinProvisioned => disk.thin
               ),
-              :controllerKey => controller_key,
-              :unitNumber    => _index,
+              :controllerKey => disk.controller_key,
+              :unitNumber    => disk.unit_number,
               :capacityInKB  => disk.size
             )
           }

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

@@ -11,21 +11,14 @@ module Fog
         def list_vm_scsi_controllers_raw(vm_id)
           get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).map do |ctrl|
             {
-              type: ctrl.class.to_s,
-              shared_bus: ctrl.sharedBus.to_s,
-              unit_number: ctrl.scsiCtlrUnitNumber,
-              key: ctrl.key
+              :type    => ctrl.class.to_s,
+              :shared_bus  => ctrl.sharedBus.to_s,
+              :unit_number => ctrl.scsiCtlrUnitNumber,
+              :key => ctrl.key,
             }
           end
         end
       end
-      class Mock
-        def list_vm_scsi_controllers(vm_id)
-          raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless data[:servers].key?(vm_id)
-          return [] unless data[:servers][vm_id].key?('scsi_controllers')
-          data[:servers][vm_id]['scsi_controllers'].map { |h| h.merge(server_id: vm_id) }
-        end
-      end
     end
   end
 end

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

@@ -38,7 +38,8 @@ module Fog
               :size => vol.capacityInKB,
               :name => vol.deviceInfo.label,
               :key => vol.key,
-              :unit_number => vol.unitNumber
+              :unit_number => vol.unitNumber,
+              :controller_key => vol.controllerKey
             }
           end
         end

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

@@ -3,25 +3,13 @@ module Fog
     class Vsphere
       class Real
         def add_vm_controller(controller)
-          options = {}
-          options[:operation] = 'add'
-          options[:type] = controller.type
-          options[:key] = controller.key
-          options[:shared] = controller.shared_bus
-
-          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(options)]})
+          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(controller)]})
         end
       end
 
       class Mock
         def add_vm_controller(controller)
-          options = {}
-          options[:operation] = 'add'
-          options[:type] = RbVmomi::VIM.VirtualLsiLogicController.class
-          options[:key] = 1000
-          options[:shared] = false
-
-          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(options)]})
+          vm_reconfig_hardware('instance_uuid' => controller.server_id, 'hardware_spec' => {'deviceChange'=>[create_controller(controller)]})
         end
       end
     end

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

@@ -3,17 +3,17 @@ module Fog
     class Vsphere
       class Real
         def add_vm_volume(volume)
-          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, volume.unit_number, :add)]})
+          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, :add)]})
         end
 
         def destroy_vm_volume(volume)
-          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, volume.unit_number, :remove)]})
+          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, :remove)]})
         end
       end
 
       class Mock
         def add_vm_volume(volume)
-          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_cdrom(volume, volume.unit_number, :add)]})
+          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_cdrom(volume, :add)]})
         end
 
         def destroy_vm_volume(volume)

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

@@ -133,7 +133,7 @@ module Fog
           # Options['host']<~String>
           # The target host for the virtual machine. Optional.
           if options.key?('host') && !options['host'].empty? && !cluster_name.nil?
-            host = get_raw_host(options['host'], attributes[:cluster], options['datacenter'])
+            host = get_raw_host(options['host'], cluster_name, options['datacenter'])
           else
             host = nil
           end
@@ -747,7 +747,7 @@ module Fog
                          :device  => template_volume }
             end
           end
-          specs.concat(new_volumes.map { |volume| create_disk(volume, volumes.index(volume)) })
+          specs.concat(new_volumes.map { |volume| create_disk(volume) })
           return specs
         end
       end

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

@@ -15,6 +15,7 @@ module Fog
             raise Fog::Vsphere::Errors::NotFound,
               "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
           end
+          options['host'] = get_raw_host(options['host'], options['cluster'], options['datacenter']) if options['host']
           task = vm_mob_ref.MigrateVM_Task(:pool => options['pool'], :host => options['host'], :priority => "#{priority}", :state => options['state'] )
           task.wait_for_completion
           { 'task_state' => task.info.state }

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

@@ -3,36 +3,47 @@ module Fog
     class Vsphere
       class Real
         def vm_reconfig_volumes(options = {})
-          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
-          raise ArgumentError, 'volumes is a required parameter' unless options.key? 'volumes'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, "volumes is a required parameter" unless options.key? 'volumes'
           hardware_spec = {
             deviceChange: []
           }
           options['volumes'].each do |volume|
-            hardware_spec[:deviceChange].push(create_disk(volume, :edit, filename: volume.filename))
+            hardware_spec[:deviceChange].push({
+              :operation=>:edit,
+              device: RbVmomi::VIM::VirtualDisk(
+                backing: RbVmomi::VIM::VirtualDiskFlatVer2BackingInfo( diskMode: volume.mode, fileName: volume.filename ),
+                unitNumber: volume.unit_number,
+                key: volume.key,
+                controllerKey: volume.controller_key,
+                capacityInKB: volume.size,
+              )
+            })
           end
-          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec)
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
         end
       end
 
       class Mock
         def vm_reconfig_volumes(options = {})
-          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
-          raise ArgumentError, 'volumes is a required parameter' unless options.key? 'volumes'
+          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, "volumes is a required parameter" unless options.key? 'volumes'
           hardware_spec = {
             deviceChange: []
           }
           options['volumes'].each do |volume|
-            hardware_spec[:deviceChange].push(operation: :edit,
-                                              device: {
-                                                backing: { diskMode: volume.mode, fileName: volume.filename },
-                                                unitNumber: volume.unit_number,
-                                                key: volume.key,
-                                                controllerKey: volume.controller_key,
-                                                capacityInKB: volume.size
-                                              })
+            hardware_spec[:deviceChange].push({
+              :operation=>:edit,
+              device: {
+                backing: { diskMode: volume.mode, fileName: volume.filename },
+                unitNumber: volume.unit_number,
+                key: volume.key,
+                controllerKey: volume.controller_key,
+                capacityInKB: volume.size,
+              }
+            })
           end
-          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec)
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
         end
       end
     end

data/lib/fog/vsphere/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Vsphere
-    VERSION = '1.7.0.1'
+    VERSION = '1.7.1'
   end
 end

data/tests/class_from_string_tests.rb

@@ -4,11 +4,11 @@ class A; class B; class C; end; end; end
 
 class TestClassFromString < Minitest::Test
   def test_empty_string
-    assert_nil(Fog::Vsphere.class_from_string(''))
+    assert_equal(nil, Fog::Vsphere.class_from_string(''))
   end
 
   def test_nil
-    assert_nil(Fog::Vsphere.class_from_string(nil))
+    assert_equal(nil, Fog::Vsphere.class_from_string(nil))
   end
 
   def test_name_as_class
@@ -20,7 +20,7 @@ class TestClassFromString < Minitest::Test
   end
 
   def test_unexpected_input
-    assert_nil(Fog::Vsphere.class_from_string(8))
+    assert_equal(nil, Fog::Vsphere.class_from_string(8))
   end
 
   def test_nested_class_without_default_path

data/tests/compute_tests.rb

@@ -1,7 +1,8 @@
 Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
+
   compute = Fog::Compute[:vsphere]
 
-  tests('| convert_vm_mob_ref_to_attr_hash') do
+  tests("| convert_vm_mob_ref_to_attr_hash") do
     # Mock the RbVmomi::VIM::ManagedObject class
     class MockManagedObject
       attr_reader :parent, :_ref
@@ -10,42 +11,42 @@ Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
         @parent = @_ref = 'vm-123'
       end
 
-      def collect!(*_pathSet)
+      def collect! *pathSet
         { '_ref' => 'vm-123', 'name' => 'fakevm' }
       end
     end
 
     fake_vm_mob_ref = MockManagedObject.new
 
-    tests('When converting an incomplete vm object') do
-      test('it should return a Hash') do
-        compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref).is_a? Hash
+    tests("When converting an incomplete vm object") do
+      test("it should return a Hash") do
+        compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref).kind_of? Hash
       end
-      tests('The converted Hash should') do
+      tests("The converted Hash should") do
         attr_hash = compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref)
-        test('have a name') { attr_hash['name'] == 'fakevm' }
-        test('have a mo_ref') { attr_hash['mo_ref'] == 'vm-123' }
-        test('have an id') { attr_hash['id'] == 'vm-123' }
-        test('not have a instance_uuid') { attr_hash['instance_uuid'].nil? }
+        test("have a name") { attr_hash['name'] == 'fakevm' }
+        test("have a mo_ref") {attr_hash['mo_ref'] == 'vm-123' }
+        test("have an id") { attr_hash['id'] == 'vm-123' }
+        test("not have a instance_uuid") { attr_hash['instance_uuid'].nil? }
       end
     end
 
-    tests('When passed a nil object') do
+    tests("When passed a nil object") do
       attr_hash = compute.send :convert_vm_mob_ref_to_attr_hash, nil
-      test('it should return a nil object') do
+      test("it should return a nil object") do
         attr_hash.nil?
       end
     end
   end
 
-  tests('Compute attributes') do
-    %w[vsphere_is_vcenter vsphere_rev vsphere_username vsphere_server].each do |attr|
+  tests("Compute attributes") do
+    %w{ vsphere_is_vcenter vsphere_rev vsphere_username vsphere_server }.each do |attr|
       test("it should respond to #{attr}") { compute.respond_to? attr }
     end
   end
 
-  tests('Compute collections') do
-    %w[servers].each do |collection|
+  tests("Compute collections") do
+    %w{ servers }.each do |collection|
       test("it should respond to #{collection}") { compute.respond_to? collection }
     end
   end

data/tests/helpers/mock_helper.rb

@@ -2,8 +2,8 @@ Fog.mock! if ENV['FOG_MOCK'] == 'true'
 
 if Fog.mock?
   Fog.credentials = {
-    vsphere_server: 'fake_vsphere_server',
-    vsphere_username: 'fake_vsphere_username',
-    vsphere_password: 'fake_vsphere_password'
+    :vsphere_server   => 'fake_vsphere_server',
+    :vsphere_username => 'fake_vsphere_username',
+    :vsphere_password => 'fake_vsphere_password'
   }.merge(Fog.credentials)
 end