fog-vsphere 2.1.1 → 2.2.0

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

@@ -8,18 +8,17 @@ module Fog
         end
 
         def get_vm_first_scsi_controller_raw(vm_id)
-          ctrl=get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).select{ | ctrl | ctrl.key == 1000 }.first
+          ctrl = get_vm_ref(vm_id).config.hardware.device.grep(RbVmomi::VIM::VirtualSCSIController).select { |ctrl| ctrl.key == 1000 }.first
           {
-            :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
       class Mock
-        def get_vm_first_scsi_controller(vm_id)
-        end
+        def get_vm_first_scsi_controller(vm_id); end
       end
     end
   end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         def host_finish_maintenance(name, cluster_name, datacenter_name, timeout = 0)
           host_ref = get_host(name, cluster_name, datacenter_name)
-          task = host_ref.ExitMaintenanceMode_Task(:timeout => timeout)
+          task = host_ref.ExitMaintenanceMode_Task(timeout: timeout)
           task.wait_for_completion
           { 'task_state' => task.info.state }
         end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         def host_shutdown(name, cluster_name, datacenter_name, force = false)
           host_ref = get_host(name, cluster_name, datacenter_name)
-          task = host_ref.ShutdownHost_Task(:force => force)
+          task = host_ref.ShutdownHost_Task(force: force)
           task.wait_for_completion
           { 'task_state' => task.info.state }
         end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         def host_start_maintenance(name, cluster_name, datacenter_name, timeout = 0, evacuate_powered_off_vms = false)
           host_ref = get_host(name, cluster_name, datacenter_name)
-          task = host_ref.EnterMaintenanceMode_Task(:timeout => timeout, :evacuatePoweredOffVms => evacuate_powered_off_vms)
+          task = host_ref.EnterMaintenanceMode_Task(timeout: timeout, evacuatePoweredOffVms: evacuate_powered_off_vms)
           task.wait_for_completion
           { 'task_state' => task.info.state }
         end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         def list_child_snapshots(snapshot, opts = {})
           normalized_snapshot = Hash === snapshot ?
-            Snapshot.new(snapshot.update(:service => self)) : snapshot
+            Snapshot.new(snapshot.update(service: self)) : snapshot
 
           child_snapshots = normalized_snapshot.tree_node.childSnapshotList.map do |snap|
             item = child_snapshot_info(snap, normalized_snapshot)
@@ -19,50 +19,48 @@ module Fog
 
         protected
 
-          def child_snapshot_info(snap_tree, parent_snap)
-            {
-              :name => snap_tree.name,
-              :quiesced => snap_tree.quiesced,
-              :description => snap_tree.description,
-              :create_time => snap_tree.createTime,
-              :power_state => snap_tree.state,
-              :ref => snap_tree.snapshot._ref,
-              :mo_ref => snap_tree.snapshot,
-              :tree_node => snap_tree,
-              :snapshot_name_chain =>
-                "#{parent_snap.snapshot_name_chain}/#{snap_tree.name}",
-              :ref_chain =>
-                "#{parent_snap.ref_chain}/#{snap_tree.snapshot._ref}",
-              :server_id => parent_snap.server_id
-            }
-          end
+        def child_snapshot_info(snap_tree, parent_snap)
+          {
+            name: snap_tree.name,
+            quiesced: snap_tree.quiesced,
+            description: snap_tree.description,
+            create_time: snap_tree.createTime,
+            power_state: snap_tree.state,
+            ref: snap_tree.snapshot._ref,
+            mo_ref: snap_tree.snapshot,
+            tree_node: snap_tree,
+            snapshot_name_chain:               "#{parent_snap.snapshot_name_chain}/#{snap_tree.name}",
+            ref_chain:               "#{parent_snap.ref_chain}/#{snap_tree.snapshot._ref}",
+            server_id: parent_snap.server_id
+          }
+        end
       end
       class Mock
-        def list_child_snapshots(snapshot, opts = {})
+        def list_child_snapshots(_snapshot, _opts = {})
           [
             {
-              :name => 'clean',
-              :quiesced => false,
-              :description => '',
-              :create_time => Time.now.utc,
-              :power_state => 'poweredOn',
-              :ref => 'snapshot-0101',
-              :mo_ref => nil,
-              :tree_node => nil,
-              :snapshot_name_chain => '123/clean',
-              :ref_chain => '123/snap-0101'
+              name: 'clean',
+              quiesced: false,
+              description: '',
+              create_time: Time.now.utc,
+              power_state: 'poweredOn',
+              ref: 'snapshot-0101',
+              mo_ref: nil,
+              tree_node: nil,
+              snapshot_name_chain: '123/clean',
+              ref_chain: '123/snap-0101'
             },
             {
-              :name => 'dirty',
-              :quiesced => false,
-              :description => '',
-              :create_time => Time.now.utc,
-              :power_state => 'poweredOn',
-              :ref => 'snapshot-0102',
-              :mo_ref => nil,
-              :tree_node => nil,
-              :snapshot_name_chain => '123/dirty',
-              :ref_chain => '123/snap-0102'
+              name: 'dirty',
+              quiesced: false,
+              description: '',
+              create_time: Time.now.utc,
+              power_state: 'poweredOn',
+              ref: 'snapshot-0102',
+              mo_ref: nil,
+              tree_node: nil,
+              snapshot_name_chain: '123/dirty',
+              ref_chain: '123/snap-0102'
             }
           ]
         end

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

@@ -2,11 +2,10 @@ module Fog
   module Compute
     class Vsphere
       class Real
-
         def list_clusters(filters = {})
           datacenter_name = filters[:datacenter] if filters.key? :datacenter
           if datacenter_name.nil?
-            list_datacenters.map { |dc| list_clusters(:datacenter => dc[:name]) }.flatten
+            list_datacenters.map { |dc| list_clusters(datacenter: dc[:name]) }.flatten
           else
             raw_clusters(datacenter_name).map do |cluster|
               if cluster.instance_of? RbVmomi::VIM::ClusterComputeResource
@@ -35,13 +34,13 @@ module Fog
 
         def cluster_attributes(cluster, datacenter_name)
           {
-            :id => managed_obj_id(cluster),
-            :name => cluster.name,
-            :full_path => cluster_path(cluster, datacenter_name),
-            :num_host => cluster.summary.numHosts,
-            :num_cpu_cores => cluster.summary.numCpuCores,
-            :overall_status => cluster.summary.overallStatus,
-            :datacenter => datacenter_name || parent_attribute(cluster.path, :datacenter)[1]
+            id: managed_obj_id(cluster),
+            name: cluster.name,
+            full_path: cluster_path(cluster, datacenter_name),
+            num_host: cluster.summary.numHosts,
+            num_cpu_cores: cluster.summary.numCpuCores,
+            overall_status: cluster.summary.overallStatus,
+            datacenter: datacenter_name || parent_attribute(cluster.path, :datacenter)[1]
           }
         end
 

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

@@ -2,89 +2,87 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_compute_resources(filters = { })
+        def list_compute_resources(filters = {})
           datacenter_name = filters[:datacenter]
           # default to show all compute_resources
           only_active = filters[:effective] || false
           compute_resources = raw_compute_resources datacenter_name
-          
+
           compute_resources.map do |compute_resource|
-            unless compute_resource.instance_of? RbVmomi::VIM::Folder
-              summary = compute_resource.summary
-              next if only_active and summary.numEffectiveHosts == 0
-              compute_resource_attributes(compute_resource, datacenter_name)
-            end
+            next if compute_resource.instance_of? RbVmomi::VIM::Folder
+            summary = compute_resource.summary
+            next if only_active && (summary.numEffectiveHosts == 0)
+            compute_resource_attributes(compute_resource, datacenter_name)
           end.compact
         end
-        
+
         def raw_compute_resources(datacenter_name)
           find_raw_datacenter(datacenter_name).find_compute_resource('').children
         end
 
         protected
 
-        def compute_resource_attributes compute_resource, datacenter
-          overall_usage = compute_resource.host.inject({:overallCpuUsage=>0, :overallMemoryUsage=>0}) do |sum, host|
+        def compute_resource_attributes(compute_resource, _datacenter)
+          overall_usage = compute_resource.host.inject(overallCpuUsage: 0, overallMemoryUsage: 0) do |sum, host|
             {
-              :overallCpuUsage => sum[:overallCpuUsage]+(host.summary.quickStats.overallCpuUsage || 0), 
-              :overallMemoryUsage=> sum[:overallMemoryUsage]+(host.summary.quickStats.overallMemoryUsage || 0)
+              overallCpuUsage: sum[:overallCpuUsage] + (host.summary.quickStats.overallCpuUsage || 0),
+              overallMemoryUsage: sum[:overallMemoryUsage] + (host.summary.quickStats.overallMemoryUsage || 0)
             }
           end
           {
-            :id                 =>   managed_obj_id(compute_resource),
-            :name               =>   compute_resource.name,
-            :totalCpu           =>   compute_resource.summary.totalCpu, 
-            :totalMemory        =>   compute_resource.summary.totalMemory,
-            :numCpuCores        =>   compute_resource.summary.numCpuCores, 
-            :numCpuThreads      =>   compute_resource.summary.numCpuThreads,
-            :effectiveCpu       =>   compute_resource.summary.effectiveCpu,
-            :effectiveMemory    =>   compute_resource.summary.effectiveMemory,
-            :numHosts           =>   compute_resource.summary.numHosts,
-            :numEffectiveHosts  =>   compute_resource.summary.numEffectiveHosts,
-            :overallStatus      =>   compute_resource.summary.overallStatus,
-            :overallCpuUsage    =>   overall_usage[:overallCpuUsage],
-            :overallMemoryUsage =>   overall_usage[:overallMemoryUsage],
-            :effective          =>   compute_resource.summary.numEffectiveHosts > 0,
-            :isSingleHost       =>   compute_resource.summary.numHosts == 1
+            id: managed_obj_id(compute_resource),
+            name: compute_resource.name,
+            totalCpu: compute_resource.summary.totalCpu,
+            totalMemory: compute_resource.summary.totalMemory,
+            numCpuCores: compute_resource.summary.numCpuCores,
+            numCpuThreads: compute_resource.summary.numCpuThreads,
+            effectiveCpu: compute_resource.summary.effectiveCpu,
+            effectiveMemory: compute_resource.summary.effectiveMemory,
+            numHosts: compute_resource.summary.numHosts,
+            numEffectiveHosts: compute_resource.summary.numEffectiveHosts,
+            overallStatus: compute_resource.summary.overallStatus,
+            overallCpuUsage: overall_usage[:overallCpuUsage],
+            overallMemoryUsage: overall_usage[:overallMemoryUsage],
+            effective: compute_resource.summary.numEffectiveHosts > 0,
+            isSingleHost: compute_resource.summary.numHosts == 1
           }
         end
-
       end
       class Mock
-        def list_compute_resources(filters = { })
+        def list_compute_resources(_filters = {})
           [
             {
-              :id=>"domain-s7", 
-              :name=>"fake-host", 
-              :totalCpu=>33504, 
-              :totalMemory=>154604142592, 
-              :numCpuCores=>12, 
-              :numCpuThreads=>24, 
-              :effectiveCpu=>32247, 
-              :effectiveMemory=>135733, 
-              :numHosts=>1, 
-              :numEffectiveHosts=>1, 
-              :overallStatus=>"gray", 
-              :overallCpuUsage=>15682, 
-              :overallMemoryUsage=>132755, 
-              :effective=>true, 
-              :isSingleHost=>true
+              id: 'domain-s7',
+              name: 'fake-host',
+              totalCpu: 33_504,
+              totalMemory: 154_604_142_592,
+              numCpuCores: 12,
+              numCpuThreads: 24,
+              effectiveCpu: 32_247,
+              effectiveMemory: 135_733,
+              numHosts: 1,
+              numEffectiveHosts: 1,
+              overallStatus: 'gray',
+              overallCpuUsage: 15_682,
+              overallMemoryUsage: 132_755,
+              effective: true,
+              isSingleHost: true
             }, {
-              :id=>"domain-s74", 
-              :name=>"fake-cluster", 
-              :totalCpu=>41484, 
-              :totalMemory=>51525996544, 
-              :numCpuCores=>12, 
-              :numCpuThreads=>24, 
-              :effectiveCpu=>37796, 
-              :effectiveMemory=>45115, 
-              :numHosts=>2, 
-              :numEffectiveHosts=>2, 
-              :overallStatus=>"gray", 
-              :overallCpuUsage=>584, 
-              :overallMemoryUsage=>26422, 
-              :effective=>true, 
-              :isSingleHost=>false
+              id: 'domain-s74',
+              name: 'fake-cluster',
+              totalCpu: 41_484,
+              totalMemory: 51_525_996_544,
+              numCpuCores: 12,
+              numCpuThreads: 24,
+              effectiveCpu: 37_796,
+              effectiveMemory: 45_115,
+              numHosts: 2,
+              numEffectiveHosts: 2,
+              overallStatus: 'gray',
+              overallCpuUsage: 584,
+              overallMemoryUsage: 26_422,
+              effective: true,
+              isSingleHost: false
             }
           ]
         end

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

@@ -2,19 +2,18 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_customfields()
+        def list_customfields
           connection.serviceContent.customFieldsManager.field.map do |customfield|
             {
-              :key   => customfield.key.to_i,
-              :name  => customfield.name,
-              :type  => customfield.type
+              key: customfield.key.to_i,
+              name: customfield.name,
+              type: customfield.type
             }
           end
         end
       end
       class Mock
-        def list_vm_customfields()
-        end
+        def list_vm_customfields; end
       end
     end
   end

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

@@ -2,50 +2,50 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_datacenters filters = {}
+        def list_datacenters(_filters = {})
           raw_datacenters.map do |dc|
             {
-              :id => managed_obj_id(dc),
-              :name => dc.name,
-              :path => raw_getpathmo(dc),
-              :status => dc.overallStatus
+              id: managed_obj_id(dc),
+              name: dc.name,
+              path: raw_getpathmo(dc),
+              status: dc.overallStatus
             }
           end
         end
 
         protected
 
-        def raw_getpathmo mo
-          if mo.parent == nil or mo.parent.name == connection.rootFolder.name then
-            [ mo.name ]
+        def raw_getpathmo(mo)
+          if mo.parent.nil? || (mo.parent.name == connection.rootFolder.name)
+            [mo.name]
           else
-            [ raw_getpathmo(mo.parent), mo.name ].flatten
+            [raw_getpathmo(mo.parent), mo.name].flatten
           end
         end
 
-        def raw_datacenters folder=nil
+        def raw_datacenters(folder = nil)
           folder ||= connection.rootFolder
           @raw_datacenters ||= get_raw_datacenters_from_folder folder
         end
 
-        def get_raw_datacenters_from_folder folder=nil
-          folder.childEntity.map do | childE |
+        def get_raw_datacenters_from_folder(folder = nil)
+          folder.childEntity.map do |childE|
             if childE.is_a? RbVmomi::VIM::Datacenter
-               childE
+              childE
             elsif childE.is_a? RbVmomi::VIM::Folder
-               get_raw_datacenters_from_folder childE
+              get_raw_datacenters_from_folder childE
             end
           end.flatten
         end
 
-        def find_datacenters name=nil
+        def find_datacenters(name = nil)
           name ? [find_raw_datacenter(name)] : raw_datacenters
         end
       end
 
       class Mock
-        def list_datacenters filters = {}
-          self.data[:datacenters].values
+        def list_datacenters(_filters = {})
+          data[:datacenters].values
         end
       end
     end

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

@@ -2,13 +2,13 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_datastores(filters = { })
+        def list_datastores(filters = {})
           datacenter_name = filters[:datacenter]
           cluster_name = filters.fetch(:cluster, nil)
           # default to show all datastores
           only_active = filters[:accessible] || false
           raw_datastores(datacenter_name, cluster_name).map do |datastore|
-            next if only_active and !datastore.summary.accessible
+            next if only_active && !datastore.summary.accessible
             datastore_attributes(datastore, datacenter_name)
           end.compact
         end
@@ -20,18 +20,19 @@ module Fog
             get_raw_cluster(cluster, datacenter_name).datastore
           end
         end
+
         protected
 
-        def datastore_attributes datastore, datacenter
+        def datastore_attributes(datastore, datacenter)
           {
-            :id          => managed_obj_id(datastore),
-            :name        => datastore.name,
-            :accessible  => datastore.summary.accessible,
-            :type        => datastore.summary.type,
-            :freespace   => datastore.summary.freeSpace,
-            :capacity    => datastore.summary.capacity,
-            :uncommitted => datastore.summary.uncommitted,
-            :datacenter  => datacenter,
+            id: managed_obj_id(datastore),
+            name: datastore.name,
+            accessible: datastore.summary.accessible,
+            type: datastore.summary.type,
+            freespace: datastore.summary.freeSpace,
+            capacity: datastore.summary.capacity,
+            uncommitted: datastore.summary.uncommitted,
+            datacenter: datacenter
           }
         end
       end
@@ -40,11 +41,11 @@ module Fog
           datacenter_name = filters[:datacenter]
           cluster_name = filters.fetch(:cluster, nil)
           if cluster_name.nil?
-            self.data[:datastores].values.select { |d| d['datacenter'] == datacenter_name } or
-              raise Fog::Compute::Vsphere::NotFound
+            data[:datastores].values.select { |d| d['datacenter'] == datacenter_name } ||
+              raise(Fog::Compute::Vsphere::NotFound)
           else
-            self.data[:datastores].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } or
-              raise Fog::Compute::Vsphere::NotFound
+            data[:datastores].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } ||
+              raise(Fog::Compute::Vsphere::NotFound)
           end
         end
       end