fog-vsphere 1.7.0 → 1.7.0.1

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, :add)]})
+          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, volume.unit_number, :add)]})
         end
 
         def destroy_vm_volume(volume)
-          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, :remove)]})
+          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_disk(volume, volume.unit_number, :remove)]})
         end
       end
 
       class Mock
         def add_vm_volume(volume)
-          vm_reconfig_hardware('instance_uuid' => volume.server_id, 'hardware_spec' => {'deviceChange'=>[create_cdrom(volume, :add)]})
+          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/vm_acquire_ticket.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_acquire_ticket(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key?('instance_uuid')
+          ticket_type = options['ticket_type'] || 'webmks'
+
+          vm_mob_ref = get_vm_ref(options['instance_uuid'])
+
+          ticket = vm_mob_ref.AcquireTicket(ticketType: ticket_type)
+          {
+            'ticket' => ticket.ticket,
+            'host' => ticket.host,
+            'port' => ticket.port,
+            'ssl_thumbprint' => ticket.sslThumbprint
+          }
+        end
+      end
+
+      class Mock
+        def vm_acquire_ticket(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key?('instance_uuid')
+          {
+            'ticket' => 'fdsfdsf',
+            'host' => 'esxi.example.com',
+            'port' => 443,
+            'ssl_thumbprint' => '1C:63:E1:BD:56:03:EB:44:85:12:12:FC:DA:40:11:65:0E:30:A1:B8'
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -3,47 +3,36 @@ 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({
-              :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,
-              )
-            })
+            hardware_spec[:deviceChange].push(create_disk(volume, :edit, filename: volume.filename))
           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/requests/compute/vm_relocate.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        # Clones a VM from a template or existing machine on your vSphere
+        # Server.
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'instance_uuid'<~String> - *REQUIRED* VM to relocate
+        #   * 'host'<~String> - name of host which will run the VM.
+        #   * 'pool'<~String> - name of pool which the VM should be
+        #       attached.
+        #   * 'disks'<~Array> - disks to relocate. Each disk is a
+        #       hash with diskId wich is key attribute of volume,
+        #       and datastore to relocate to.
+        def vm_relocate(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+
+          # Find the VM Object
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm_mob_ref = connection.searchIndex.FindAllByUuid(search_filter).first
+
+          unless vm_mob_ref.is_a? RbVmomi::VIM::VirtualMachine
+            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']
+          if options['disks']
+            options['disks'] = options['disks'].map do |disk|
+              disk['datastore'] = get_raw_datastore(disk['datastore'], nil)
+              RbVmomi::VIM::VirtualMachineRelocateSpecDiskLocator(disk)
+            end
+          end
+          spec = RbVmomi::VIM::VirtualMachineRelocateSpec(
+            pool: options['pool'],
+            host: options['host'],
+            disk: options['disks']
+          )
+          task = vm_mob_ref.RelocateVM_Task(spec: spec, priority: options['priority'])
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_relocate(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_remove_snapshot(vm_id, snapshot_id, remove_children = false)
+          vm = servers.get(vm_id)
+          snapshot = vm.snapshots.get(snapshot_id).mo_ref
+          task = snapshot.RemoveSnapshot_Task(removeChildren: remove_children)
+
+          task.wait_for_completion
+
+          {
+            'task_state' => task.info.state,
+            'was_cancelled' => task.info.cancelled
+          }
+        end
+      end
+
+      class Mock
+        def vm_remove_snapshot(_vm_id, _snapshot_id)
+          {
+            'task_state' => 'success',
+            'was_cancelled' => false
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_rename(options = {})
+          raise ArgumentError, 'name is a required parameter' unless options.key? 'name'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          vm_mob_ref = get_vm_ref(options['instance_uuid'])
+          task = vm_mob_ref.Rename_Task(newName: options['name'])
+          task.wait_for_completion
+          { 'task_state' => task.info.state }
+        end
+      end
+
+      class Mock
+        def vm_rename(options = {})
+          raise ArgumentError, 'name is a required parameter' unless options.key? 'name'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          { 'task_state' => 'success' }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_revert_snapshot(vm_id, snapshot_id)
+          vm = servers.get(vm_id)
+          snapshot = vm.snapshots.get(snapshot_id).mo_ref
+          task = snapshot.RevertToSnapshot_Task
+
+          task.wait_for_completion
+
+          {
+            'task_state' => task.info.state,
+            'was_cancelled' => task.info.cancelled
+          }
+        end
+      end
+
+      class Mock
+        def vm_revert_snapshot(_vm_id, _snapshot_id)
+          {
+            'task_state' => 'success',
+            'was_cancelled' => false
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def vm_suspend(options = {})
+          raise(ArgumentError, 'instance_uuid is a required parameter') unless options.key?('instance_uuid')
+          options = { 'force' => false }.merge(options)
+
+          search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
+          vm = connection.searchIndex.FindAllByUuid(search_filter).first
+
+          if options['force']
+            suspend_forcefully(vm)
+          else
+            suspend_gracefully(vm)
+          end
+        end
+
+        private
+
+        def suspend_forcefully(vm)
+          task = vm.SuspendVM_Task
+          task.wait_for_completion
+          {
+            'task_state'   => task.info.result,
+            'suspend_type' => 'suspend'
+          }
+        end
+
+        def suspend_gracefully(vm)
+          vm.StandbyGuest
+          {
+            'task_state'   => 'running',
+            'suspend_type' => 'standby_guest'
+          }
+        end
+      end
+
+      class Mock
+        def vm_suspend(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+
+          vm = get_virtual_machine(options['instance_uuid'])
+          vm['power_state'] = 'suspended'
+
+          {
+            'task_state'   => 'running',
+            'suspend_type' => options['force'] ? 'suspend' : 'standby_guest'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Vsphere
-    VERSION = '1.7.0'
+    VERSION = '1.7.0.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_equal(nil, Fog::Vsphere.class_from_string(''))
+    assert_nil(Fog::Vsphere.class_from_string(''))
   end
 
   def test_nil
-    assert_equal(nil, Fog::Vsphere.class_from_string(nil))
+    assert_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_equal(nil, Fog::Vsphere.class_from_string(8))
+    assert_nil(Fog::Vsphere.class_from_string(8))
   end
 
   def test_nested_class_without_default_path

data/tests/compute_tests.rb

@@ -1,8 +1,7 @@
 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
@@ -11,42 +10,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).kind_of? 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).is_a? 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

data/tests/models/compute/cluster_tests.rb

@@ -1,19 +1,18 @@
 Shindo.tests('Fog::Compute[:vsphere] | cluster collection', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
   tests('Cluster collection') do
     clusters = compute.datacenters.first.clusters
 
-    test('should not be empty') { not clusters.empty? }
-    test('should be a kind of Fog::Compute::Vsphere::Clusters') { clusters.kind_of? Fog::Compute::Vsphere::Clusters }
+    test('should not be empty') { !clusters.empty? }
+    test('should be a kind of Fog::Compute::Vsphere::Clusters') { clusters.is_a? Fog::Compute::Vsphere::Clusters }
     test('should get a cluster') { clusters.get('Solutionscluster').id == '1d4d9a3f-e4e8-4c40-b7fc-263850068fa4' }
   end
 
   tests('A cluster should') do
     cluster = compute.datacenters.first.clusters.get('Solutionscluster')
 
-    test('have datastores') { cluster.datastores.first.kind_of? Fog::Compute::Vsphere::Datastore }
-    test('have networks') { cluster.networks.first.kind_of? Fog::Compute::Vsphere::Network }
+    test('have datastores') { cluster.datastores.first.is_a? Fog::Compute::Vsphere::Datastore }
+    test('have networks') { cluster.networks.first.is_a? Fog::Compute::Vsphere::Network }
   end
 end