fog-vsphere 2.1.1 → 2.2.0

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

@@ -2,42 +2,42 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def vm_config_vnc(options = { })
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+        def vm_config_vnc(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
 
           search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
           vm_mob_ref    = connection.searchIndex.FindAllByUuid(search_filter).first
-          task          = vm_mob_ref.ReconfigVM_Task(:spec => {
-            :extraConfig => [
-              { :key => 'RemoteDisplay.vnc.enabled',  :value => options[:enabled] ? 'true' : 'false' },
-              { :key => 'RemoteDisplay.vnc.password', :value => options[:password].to_s },
-              { :key => 'RemoteDisplay.vnc.port',     :value => options[:port].to_s || '5910' }
-            ]
-          })
+          task          = vm_mob_ref.ReconfigVM_Task(spec: {
+                                                       extraConfig: [
+                                                         { key: 'RemoteDisplay.vnc.enabled',  value: options[:enabled] ? 'true' : 'false' },
+                                                         { key: 'RemoteDisplay.vnc.password', value: options[:password].to_s },
+                                                         { key: 'RemoteDisplay.vnc.port',     value: options[:port].to_s || '5910' }
+                                                       ]
+                                                     })
           task.wait_for_completion
           { 'task_state' => task.info.state }
         end
 
         # return a hash of VNC attributes required to view the console
-        def vm_get_vnc uuid
+        def vm_get_vnc(uuid)
           search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
           vm = connection.searchIndex.FindAllByUuid(search_filter).first
           Hash[vm.config.extraConfig.map do |config|
             if config.key =~ /^RemoteDisplay\.vnc\.(\w+)$/
-              [$1.to_sym, config.value]
+              [Regexp.last_match(1).to_sym, config.value]
             end
           end.compact]
         end
       end
 
       class Mock
-        def vm_config_vnc(options = { })
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+        def vm_config_vnc(options = {})
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
 
-        def vm_get_vnc uuid
-          {:password => 'secret', :port => '5900', :enabled => 'true'}
+        def vm_get_vnc(_uuid)
+          { password: 'secret', port: '5900', enabled: 'true' }
         end
       end
     end

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

@@ -3,7 +3,7 @@ module Fog
     class Vsphere
       class Real
         def vm_destroy(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          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.Destroy_Task
@@ -14,7 +14,7 @@ module Fog
 
       class Mock
         def vm_destroy(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
       end

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

@@ -12,34 +12,34 @@ module Fog
         #   * 'user'<~String> *REQUIRED* the ssh username you would like to login as
         #   * 'password'<~String> *REQUIRED* the ssh password for the user you would like to log in as
         def vm_execute(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          raise ArgumentError, "command is a required parameter" unless options.key? 'command'
-          raise ArgumentError, "user is a required parameter" unless options.key? 'user'
-          raise ArgumentError, "password is a required parameter" unless options.key? 'password'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          raise ArgumentError, 'command is a required parameter' unless options.key? 'command'
+          raise ArgumentError, 'user is a required parameter' unless options.key? 'user'
+          raise ArgumentError, 'password is a required parameter' unless options.key? 'password'
 
           search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
           vm_mob_ref = connection.searchIndex.FindAllByUuid(search_filter).first
 
-          auth = RbVmomi::VIM::NamePasswordAuthentication(:interactiveSession => false,
-                                                          :username => options['user'],
-                                                          :password => options['password'])
+          auth = RbVmomi::VIM::NamePasswordAuthentication(interactiveSession: false,
+                                                          username: options['user'],
+                                                          password: options['password'])
 
-          spec = RbVmomi::VIM::GuestProgramSpec(:programPath => options['command'],
-                                                :arguments => options['args'],
-                                                :workingDirectory => options['working_dir'])
+          spec = RbVmomi::VIM::GuestProgramSpec(programPath: options['command'],
+                                                arguments: options['args'],
+                                                workingDirectory: options['working_dir'])
 
           gom = connection.serviceContent.guestOperationsManager
-          gom.processManager.StartProgramInGuest(:vm => vm_mob_ref, :auth => auth, :spec => spec)
+          gom.processManager.StartProgramInGuest(vm: vm_mob_ref, auth: auth, spec: spec)
         end
       end
 
       class Mock
         def vm_execute(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          raise ArgumentError, "command is a required parameter" unless options.key? 'command'
-          raise ArgumentError, "user is a required parameter" unless options.key? 'user'
-          raise ArgumentError, "password is a required parameter" unless options.key? 'password'
-          return 12345
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          raise ArgumentError, 'command is a required parameter' unless options.key? 'command'
+          raise ArgumentError, 'user is a required parameter' unless options.key? 'user'
+          raise ArgumentError, 'password is a required parameter' unless options.key? 'password'
+          12_345
         end
       end
     end

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

@@ -3,27 +3,27 @@ module Fog
     class Vsphere
       class Real
         def vm_migrate(options = {})
-          #priority is the only required option, and it has a sane default option.
-          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          # priority is the only required option, and it has a sane default option.
+          priority = options['priority'].nil? ? 'defaultPriority' : options['priority']
+          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.kind_of? RbVmomi::VIM::VirtualMachine
+          unless vm_mob_ref.is_a? RbVmomi::VIM::VirtualMachine
             raise Fog::Vsphere::Errors::NotFound,
-              "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
+                  "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_options = {:pool => options['pool'], :host => options['host'], :state => options['state']}
+          task_options = { pool: options['pool'], host: options['host'], state: options['state'] }
           if options['check']
             checker = connection.serviceContent.vmProvisioningChecker
-            task = checker.CheckMigrate_Task(task_options.merge(:vm => vm_mob_ref))
+            task = checker.CheckMigrate_Task(task_options.merge(vm: vm_mob_ref))
             task.wait_for_completion
-            {'error' => task.info.result[0].error, 'warning' => task.info.result[0].warning}
+            { 'error' => task.info.result[0].error, 'warning' => task.info.result[0].warning }
           else
-            task = vm_mob_ref.MigrateVM_Task(task_options.merge(:priority => "#{priority}"))
+            task = vm_mob_ref.MigrateVM_Task(task_options.merge(priority: priority.to_s))
             task.wait_for_completion
             { 'task_state' => task.info.state }
           end
@@ -32,8 +32,8 @@ module Fog
 
       class Mock
         def vm_migrate(options = {})
-          priority = options['priority'].nil? ? 'defaultPriority' : options["priority"]
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          priority = options['priority'].nil? ? 'defaultPriority' : options['priority']
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
       end

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

@@ -4,20 +4,20 @@ module Fog
       class Real
         def vm_power_off(options = {})
           options = { 'force' => false }.merge(options)
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
 
           search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
           vm_mob_ref = connection.searchIndex.FindAllByUuid(search_filter).first
 
-          if options['force'] then
+          if options['force']
             task = vm_mob_ref.PowerOffVM_Task
             task.wait_for_completion
             { 'task_state' => task.info.result, 'power_off_type' => 'cut_power' }
           else
             vm_mob_ref.ShutdownGuest
             {
-              'task_state'     => "running",
-              'power_off_type' => 'shutdown_guest',
+              'task_state'     => 'running',
+              'power_off_type' => 'shutdown_guest'
             }
           end
         end
@@ -25,12 +25,12 @@ module Fog
 
       class Mock
         def vm_power_off(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           vm = get_virtual_machine(options['instance_uuid'])
-          vm["power_state"] = "poweredOff"
+          vm['power_state'] = 'poweredOff'
           {
-            'task_state'     => "running",
-            'power_off_type' => options['force'] ? 'cut_power' : 'shutdown_guest',
+            'task_state'     => 'running',
+            'power_off_type' => options['force'] ? 'cut_power' : 'shutdown_guest'
           }
         end
       end

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

@@ -3,7 +3,7 @@ module Fog
     class Vsphere
       class Real
         def vm_power_on(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
 
           search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
           vm_mob_ref = connection.searchIndex.FindAllByUuid(search_filter).first
@@ -17,7 +17,7 @@ module Fog
 
       class Mock
         def vm_power_on(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
       end

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

@@ -4,26 +4,26 @@ module Fog
       class Real
         def vm_reboot(options = {})
           options = { 'force' => false }.merge(options)
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
 
           search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
           vm_mob_ref = connection.searchIndex.FindAllByUuid(search_filter).first
 
-          if options['force'] then
+          if options['force']
             task = vm_mob_ref.ResetVM_Task
             task.wait_for_completion
             { 'task_state' => task.info.result, 'reboot_type' => 'reset_power' }
           else
             vm_mob_ref.RebootGuest
-            { 'task_state' => "running", 'reboot_type' => 'reboot_guest' }
+            { 'task_state' => 'running', 'reboot_type' => 'reboot_guest' }
           end
         end
       end
 
       class Mock
         def vm_reboot(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          { 'task_state'     => "running", 'reboot_type' => options['force'] ? 'reset_power' : 'reboot_guest' }
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          { 'task_state' => 'running', 'reboot_type' => options['force'] ? 'reset_power' : 'reboot_guest' }
         end
       end
     end

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

@@ -3,10 +3,10 @@ module Fog
     class Vsphere
       class Real
         def vm_reconfig_cdrom(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           # Attach iso / disattach
-          if options.has_key?('iso')
-            raise ArgumentError, "datastore is a required parameter" unless options.key? 'datastore'
+          if options.key?('iso')
+            raise ArgumentError, 'datastore is a required parameter' unless options.key? 'datastore'
             backing = RbVmomi::VIM::VirtualCdromIsoBackingInfo(
               fileName: "[#{options['datastore']}] #{options['iso']}"
             )
@@ -24,25 +24,25 @@ module Fog
                 connectable: RbVmomi::VIM::VirtualDeviceConnectInfo(
                   startConnected: options['start_connected'] || false,
                   connected: options['connected'] || false,
-                  allowGuestControl: options['allow_guest_control'] || true,
+                  allowGuestControl: options['allow_guest_control'] || true
                 )
               )
             }]
           }
-          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_cdrom(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          if options.has_key?('iso')
-            raise ArgumentError, "datastore is a required parameter" unless options.key? 'datastore'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          if options.key?('iso')
+            raise ArgumentError, 'datastore is a required parameter' unless options.key? 'datastore'
             backing = {
               fileName: "[#{options['datastore']}] #{options['iso']}"
             }
           else
-            backing = {deviceName: ''}
+            backing = { deviceName: '' }
           end
           cdrom_obj = list_vm_cdroms(options['instance_uuid']).first
           hardware_spec = {
@@ -55,12 +55,12 @@ module Fog
                 connectable: {
                   startConnected: options['start_connected'] || false,
                   connected: options['connected'] || false,
-                  allowGuestControl: options['allow_guest_control'] || true,
+                  allowGuestControl: options['allow_guest_control'] || true
                 }
               }
             }]
           }
-          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_reconfig_cpus.rb

@@ -3,19 +3,19 @@ module Fog
     class Vsphere
       class Real
         def vm_reconfig_cpus(options = {})
-          raise ArgumentError, "cpus is a required parameter" unless options.key? 'cpus'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          hardware_spec={'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket']}
-          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+          raise ArgumentError, 'cpus is a required parameter' unless options.key? 'cpus'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          hardware_spec = { 'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket'] }
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec)
         end
       end
 
       class Mock
         def vm_reconfig_cpus(options = {})
-          raise ArgumentError, "cpus is a required parameter" unless options.key? 'cpus'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          hardware_spec={'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket']}
-          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+          raise ArgumentError, 'cpus is a required parameter' unless options.key? 'cpus'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          hardware_spec = { 'numCPUs' => options['cpus'], 'numCoresPerSocket' => options['corespersocket'] }
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec)
         end
       end
     end

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

@@ -3,19 +3,19 @@ module Fog
     class Vsphere
       class Real
         def vm_reconfig_hardware(options = {})
-          raise ArgumentError, "hardware_spec is a required parameter" unless options.key? 'hardware_spec'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'hardware_spec is a required parameter' unless options.key? 'hardware_spec'
+          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.ReconfigVM_Task(:spec => RbVmomi::VIM.VirtualMachineConfigSpec(options['hardware_spec']))
+          task = vm_mob_ref.ReconfigVM_Task(spec: RbVmomi::VIM.VirtualMachineConfigSpec(options['hardware_spec']))
           task.wait_for_completion
-           { 'task_state' => task.info.state }
+          { 'task_state' => task.info.state }
         end
       end
 
       class Mock
         def vm_reconfig_hardware(options = {})
-          raise ArgumentError, "hardware_spec is a required parameter" unless options.key? 'hardware_spec'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'hardware_spec is a required parameter' unless options.key? 'hardware_spec'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
       end

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

@@ -3,19 +3,19 @@ module Fog
     class Vsphere
       class Real
         def vm_reconfig_memory(options = {})
-          raise ArgumentError, "memory is a required parameter" unless options.key? 'memory'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          hardware_spec={'memoryMB' => options['memory']}
-          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+          raise ArgumentError, 'memory is a required parameter' unless options.key? 'memory'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          hardware_spec = { 'memoryMB' => options['memory'] }
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec)
         end
       end
 
       class Mock
         def vm_reconfig_memory(options = {})
-          raise ArgumentError, "memory is a required parameter" unless options.key? 'memory'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          hardware_spec={'memoryMB' => options['memory']}
-          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec )
+          raise ArgumentError, 'memory is a required parameter' unless options.key? 'memory'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          hardware_spec = { 'memoryMB' => options['memory'] }
+          vm_reconfig_hardware('instance_uuid' => options['instance_uuid'], 'hardware_spec' => hardware_spec)
         end
       end
     end

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

@@ -3,38 +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(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