fog-vsphere 2.1.1 → 2.2.0

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

@@ -2,9 +2,9 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_templates(options = { })
+        def list_templates(options = {})
           options[:folder] ||= options['folder']
-          if options[:folder] then
+          if options[:folder]
             list_all_templates_in_folder(options[:folder], options[:datacenter])
           else
             list_all_templates(options)
@@ -18,7 +18,7 @@ module Fog
 
           vms = folder.children.grep(RbVmomi::VIM::VirtualMachine)
           # remove all virtual machines that are not template
-          vms.delete_if { |v| v.config.nil? or not v.config.template }
+          vms.delete_if { |v| v.config.nil? || !v.config.template }
 
           vms.map(&method(:convert_vm_mob_ref_to_attr_hash))
         end
@@ -36,8 +36,7 @@ module Fog
         end
       end
       class Mock
-        def list_templates(filters = { })
-        end
+        def list_templates(filters = {}); end
       end
     end
   end

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

@@ -2,22 +2,21 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_virtual_machines(options = { })
+        def list_virtual_machines(options = {})
           # Listing all VM's can be quite slow and expensive.  Try and optimize
           # based on the available options we have.  These conditions are in
           # ascending order of time to complete for large deployments.
 
           options[:folder] ||= options['folder']
-          if options['instance_uuid'] then
+          if options['instance_uuid']
             [get_virtual_machine(options['instance_uuid'])]
-          elsif options[:folder] && options[:datacenter] then
+          elsif options[:folder] && options[:datacenter]
             list_all_virtual_machines_in_folder(options[:folder], options[:datacenter], options[:recursive])
           else
             list_all_virtual_machines(options)
           end
         end
 
-
         private
 
         def list_all_virtual_machines_in_folder(path, datacenter_name, recursive)
@@ -39,7 +38,7 @@ module Fog
             raw_folder.children.each do |child|
               case child
               when RbVmomi::VIM::Folder
-                folder_enumerator(child, true).each {|item| yielder.yield item} if recursive
+                folder_enumerator(child, true).each { |item| yielder.yield item } if recursive
               when RbVmomi::VIM::VirtualMachine
                 yielder.yield child
               end
@@ -47,7 +46,7 @@ module Fog
           end
         end
 
-        def list_all_virtual_machines(options = { })
+        def list_all_virtual_machines(options = {})
           raw_vms = raw_list_all_virtual_machines(options[:datacenter])
           vms = convert_vm_view_to_attr_hash(raw_vms)
 
@@ -65,29 +64,30 @@ module Fog
             list_container_view(dc, 'VirtualMachine', :vmFolder)
           end.flatten
         end
+
         def get_folder_path(folder, root = nil)
-          return if (!folder.methods.include?('parent')) || (folder == root)
+          return if !folder.methods.include?('parent') || (folder == root)
           "#{get_folder_path(folder.parent)}/#{folder.name}"
         end
       end
 
       class Mock
-        def get_folder_path(folder, root = nil)
+        def get_folder_path(_folder, _root = nil)
           nil
         end
 
-        def list_virtual_machines(options = { })
+        def list_virtual_machines(options = {})
           if options['instance_uuid']
-            server = self.data[:servers][options['instance_uuid']]
+            server = data[:servers][options['instance_uuid']]
             server.nil? ? [] : [server]
           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]}
+            data[:servers].values.select { |vm| vm['mo_ref'] == options['mo_ref'] }
+          elsif options[:folder] && options[:datacenter]
+            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 }}
+            options.reject! { |_k, v| v.nil? } # ignore options with nil value
+            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

@@ -5,24 +5,28 @@ module Fog
         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,
+              filename: (begin
+                              cdrom.backing.fileName
+                            rescue
+                              (nil)
+                            end),
+              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}) }
+          raise Fog::Compute::Vsphere::NotFound, 'VM not Found' unless data[:servers].key?(vm_id)
+          return [] unless data[:servers][vm_id].key?('cdroms')
+          data[:servers][vm_id]['cdroms'].map { |h| h.merge(instance_uuid: vm_id) }
         end
       end
     end

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

@@ -5,15 +5,14 @@ module Fog
         def list_vm_customvalues(vm_id)
           get_vm_ref(vm_id).summary.customValue.map do |customvalue|
             {
-              :key    => customvalue.key.to_i,
-              :value  => customvalue.value,
+              key: customvalue.key.to_i,
+              value: customvalue.value
             }
           end
         end
       end
       class Mock
-        def list_vm_customfields(vm_id)
-        end
+        def list_vm_customfields(vm_id); end
       end
     end
   end

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

@@ -2,83 +2,81 @@ module Fog
   module Compute
     class Vsphere
       class Real
-  # => VirtualE1000(
-  #addressType: "assigned",
-  #backing: VirtualEthernetCardNetworkBackingInfo(
-  #  deviceName: "VM Network",
-  #  dynamicProperty: [],
-  #  network: Network("network-163"),
-  #  useAutoDetect: false
-  #),
-  #connectable: VirtualDeviceConnectInfo(
-  #  allowGuestControl: true,
-  #  connected: true,
-  #  dynamicProperty: [],
-  #  startConnected: true,
-  #  status: "ok"
-  #),
-  #controllerKey: 100,
-  #deviceInfo: Description(
-  #  dynamicProperty: [],
-  #  label: "Network adapter 1",
-  #  summary: "VM Network"
-  #),
-  #dynamicProperty: [],
-  #key: 4000,
-  #macAddress: "00:50:56:a9:00:28",
-  #unitNumber: 7,
-  #
+        # => VirtualE1000(
+        # addressType: "assigned",
+        # backing: VirtualEthernetCardNetworkBackingInfo(
+        #  deviceName: "VM Network",
+        #  dynamicProperty: [],
+        #  network: Network("network-163"),
+        #  useAutoDetect: false
+        # ),
+        # connectable: VirtualDeviceConnectInfo(
+        #  allowGuestControl: true,
+        #  connected: true,
+        #  dynamicProperty: [],
+        #  startConnected: true,
+        #  status: "ok"
+        # ),
+        # controllerKey: 100,
+        # deviceInfo: Description(
+        #  dynamicProperty: [],
+        #  label: "Network adapter 1",
+        #  summary: "VM Network"
+        # ),
+        # dynamicProperty: [],
+        # key: 4000,
+        # macAddress: "00:50:56:a9:00:28",
+        # unitNumber: 7,
+        #
         def list_vm_interfaces(vm_id, datacenter = nil)
-          get_raw_interfaces(vm_id, datacenter).map {|nic| raw_to_hash nic}
+          get_raw_interfaces(vm_id, datacenter).map { |nic| raw_to_hash nic }
         end
 
-        def get_vm_interface(vm_id, options={})
+        def get_vm_interface(vm_id, options = {})
           raw = get_raw_interface(vm_id, options)
-          if raw
-            raw_to_hash(raw)
-          else
-            nil
-          end
+          raw_to_hash(raw) if raw
         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
+
+        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
-            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])
+            raise ArgumentError, "Either key or name is a required parameter. options: #{options}" unless options.key?(:key) || options.key?(:mac) || options.key?(:name)
+            raise ArgumentError, "'datacenter' is a required parameter in options: #{options}" unless options.key?(:datacenter)
+
+            get_raw_interfaces(vm_id, options[:datacenter]).find do |nic|
+              (options.key?(:key) && (nic.key == options[:key].to_i)) ||
+                (options.key?(:mac) && (nic.macAddress == options[:mac])) ||
+                (options.key?(:name) && (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,
-            :connected => nic.connectable.connected,
-            :summary => nic.deviceInfo.summary,
-            :type    => nic.class,
-            :key     => nic.key,
+            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,
+            connected: nic.connectable.connected,
+            summary: nic.deviceInfo.summary,
+            type: nic.class,
+            key: nic.key
           }
         end
-        
       end
-      
+
       class Mock
-        def list_vm_interfaces(vm_id)
-        end
+        def list_vm_interfaces(vm_id); end
       end
     end
   end

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

@@ -11,19 +11,19 @@ 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 self.data[:servers].key?(vm_id)
-          return [] unless self.data[:servers][vm_id].key?('scsi_controllers')
-          self.data[:servers][vm_id]['scsi_controllers'].map {|h| h.merge(:server_id => 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

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

@@ -20,48 +20,48 @@ module Fog
 
         protected
 
-          def snapshot_info(snap_tree, vm_id)
-            {
-              :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,
-              :ref_chain => "#{vm_id}/#{snap_tree.snapshot._ref}",
-              :snapshot_name_chain => "#{vm_id}/#{snap_tree.name}",
-              :server_id => vm_id
-            }
-          end
+        def snapshot_info(snap_tree, vm_id)
+          {
+            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,
+            ref_chain: "#{vm_id}/#{snap_tree.snapshot._ref}",
+            snapshot_name_chain: "#{vm_id}/#{snap_tree.name}",
+            server_id: vm_id
+          }
+        end
       end
       class Mock
-        def list_vm_snapshots(vm_id, opts = {})
+        def list_vm_snapshots(vm_id, _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 => "#{vm_id}/snapshot-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: "#{vm_id}/snapshot-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 => "#{vm_id}/snapshot-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: "#{vm_id}/snapshot-0102"
             }
           ]
         end

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

@@ -2,51 +2,58 @@ module Fog
   module Compute
     class Vsphere
       class Real
- # [VirtualDisk(
- #  backing: VirtualDiskFlatVer2BackingInfo(
- #    contentId: "a172d19487e878e17d6b16ff2505d7eb",
- #    datastore: Datastore("datastore-162"),
- #    diskMode: "persistent",
- #    dynamicProperty: [],
- #    fileName: "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
- #    split: false,
- #    thinProvisioned: true,
- #    uuid: "6000C29c-a47d-4cd9-5249-c371de775f06",
- #    writeThrough: false
- #  ),
- #  capacityInKB: 8388608,
- #  controllerKey: 1000,
- #  deviceInfo: Description(
- #    dynamicProperty: [],
- #    label: "Hard disk 1",
- #    summary: "8,388,608 KB"
- #  ),
- #  dynamicProperty: [],
- #  key: 2001,
- #  shares: SharesInfo( dynamicProperty: [], level: "normal", shares: 1000 ),
- #  unitNumber: 1
- #)]
+        # [VirtualDisk(
+        #  backing: VirtualDiskFlatVer2BackingInfo(
+        #    contentId: "a172d19487e878e17d6b16ff2505d7eb",
+        #    datastore: Datastore("datastore-162"),
+        #    diskMode: "persistent",
+        #    dynamicProperty: [],
+        #    fileName: "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
+        #    split: false,
+        #    thinProvisioned: true,
+        #    uuid: "6000C29c-a47d-4cd9-5249-c371de775f06",
+        #    writeThrough: false
+        #  ),
+        #  capacityInKB: 8388608,
+        #  controllerKey: 1000,
+        #  deviceInfo: Description(
+        #    dynamicProperty: [],
+        #    label: "Hard disk 1",
+        #    summary: "8,388,608 KB"
+        #  ),
+        #  dynamicProperty: [],
+        #  key: 2001,
+        #  shares: SharesInfo( dynamicProperty: [], level: "normal", shares: 1000 ),
+        #  unitNumber: 1
+        # )]
 
         def list_vm_volumes(vm_id)
           get_vm_ref(vm_id).disks.map do |vol|
             {
-              :id => vol.backing.uuid,
-              :thin => (vol.backing.thinProvisioned rescue(nil)),
-              :mode => vol.backing.diskMode,
-              :filename => vol.backing.fileName,
-              :datastore => (vol.backing.datastore.name rescue(nil)),
-              :size => vol.capacityInKB,
-              :name => vol.deviceInfo.label,
-              :key => vol.key,
-              :unit_number => vol.unitNumber,
-              :controller_key => vol.controllerKey
+              id: vol.backing.uuid,
+              thin: (begin
+                          vol.backing.thinProvisioned
+                        rescue
+                          (nil)
+                        end),
+              mode: vol.backing.diskMode,
+              filename: vol.backing.fileName,
+              datastore: (begin
+                               vol.backing.datastore.name
+                             rescue
+                               (nil)
+                             end),
+              size: vol.capacityInKB,
+              name: vol.deviceInfo.label,
+              key: vol.key,
+              unit_number: vol.unitNumber,
+              controller_key: vol.controllerKey
             }
           end
         end
       end
       class Mock
-        def list_vm_volumes(vm_id)
-        end
+        def list_vm_volumes(vm_id); end
       end
     end
   end