fog-vsphere 2.1.1 → 2.2.0

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

@@ -20,7 +20,7 @@ module Fog
         #  mydc = vspconn.datacenters.first
         #  folders = mydc.vm_folders
         #
-        def list_folders(filters = { })
+        def list_folders(filters = {})
           path            = filters[:path] || filters['path'] || ''
           datacenter_name = filters[:datacenter]
           get_raw_vmfolders(path, datacenter_name).map do |folder|
@@ -35,14 +35,14 @@ module Fog
           child_folders(folder).flatten.compact
         end
 
-        def child_folders folder
+        def child_folders(folder)
           [folder, folder.childEntity.grep(RbVmomi::VIM::Folder).map(&method(:child_folders)).flatten]
         end
       end
       class Mock
         def list_folders(options = {})
-          options.reject! {|k,v| v.nil? } # ignore options with nil value
-          self.data[:folders].values.select {|folder| options.all? {|k,v| folder[k.to_s] == v.to_s }}
+          options.reject! { |_k, v| v.nil? } # ignore options with nil value
+          data[:folders].values.select { |folder| options.all? { |k, v| folder[k.to_s] == v.to_s } }
         end
       end
     end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         def list_groups(filters = {})
           cluster = get_raw_cluster(filters[:cluster], filters[:datacenter])
-          cluster.configurationEx.group.map {|g| group_attributes g, filters}
+          cluster.configurationEx.group.map { |g| group_attributes g, filters }
         end
 
         protected
@@ -15,14 +15,14 @@ module Fog
           attributes[:cluster] = filters[:cluster]
           attributes[:name] = group[:name]
           attributes[:type] = group.class
-          if group.class.to_s == 'ClusterVmGroup' then attributes[:vm_ids] = group[:vm].map {|vm| vm.config.instanceUuid} end
-          if group.class.to_s == 'ClusterHostGroup' then attributes[:hosts] = group[:host].map {|host| host.name} end
-          return attributes
+          if group.class.to_s == 'ClusterVmGroup' then attributes[:vm_ids] = group[:vm].map { |vm| vm.config.instanceUuid } end
+          if group.class.to_s == 'ClusterHostGroup' then attributes[:hosts] = group[:host].map(&:name) end
+          attributes
         end
       end
       class Mock
         def list_groups(filters = {})
-          self.data[:groups].values.select {|g| g[:datacenter] == filters[:datacenter] && g[:cluster] == filters[:cluster]}
+          data[:groups].values.select { |g| g[:datacenter] == filters[:datacenter] && g[:cluster] == filters[:cluster] }
         end
       end
     end

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

@@ -12,9 +12,25 @@ module Fog
             hsh.merge(
               datacenter: filters[:datacenter],
               cluster: filters[:cluster],
-              ipaddress: (host['config.network.vnic'].first.spec.ip.ipAddress rescue nil),
-              ipaddress6: (host['config.network.vnic'].first.spec.ip.ipV6Config.ipV6Address.first.ipAddress rescue nil),
-              vm_ids: Proc.new { host['vm'].map {|vm| vm.config.instanceUuid rescue nil} }
+              ipaddress: (begin
+                            host['config.network.vnic'].first.spec.ip.ipAddress
+                          rescue
+                            nil
+                          end),
+              ipaddress6: (begin
+                             host['config.network.vnic'].first.spec.ip.ipV6Config.ipV6Address.first.ipAddress
+                           rescue
+                             nil
+                           end),
+              vm_ids: proc {
+                host['vm'].map do |vm|
+                  begin
+                                           vm.config.instanceUuid
+                                         rescue
+                                           nil
+                                         end
+                end
+              }
             )
           end
         end
@@ -29,28 +45,28 @@ module Fog
 
         def property_collector_results(filter_spec)
           property_collector = connection.serviceContent.propertyCollector
-          property_collector.RetrieveProperties(:specSet => [filter_spec])
+          property_collector.RetrieveProperties(specSet: [filter_spec])
         end
 
         def compute_resource_host_traversal_spec
           RbVmomi::VIM.TraversalSpec(
-            :name => 'computeResourceHostTraversalSpec',
-            :type => 'ComputeResource',
-            :path => 'host',
-            :skip => false
+            name: 'computeResourceHostTraversalSpec',
+            type: 'ComputeResource',
+            path: 'host',
+            skip: false
           )
         end
 
         def host_system_filter_spec(obj)
           RbVmomi::VIM.PropertyFilterSpec(
-            :objectSet => [
-              :obj => obj,
-              :selectSet => [
+            objectSet: [
+              obj: obj,
+              selectSet: [
                 compute_resource_host_traversal_spec
               ]
             ],
-            :propSet => [
-              { :type => 'HostSystem', :pathSet => host_system_attribute_mapping.values + ['config.network.vnic', 'vm'] }
+            propSet: [
+              { type: 'HostSystem', pathSet: host_system_attribute_mapping.values + ['config.network.vnic', 'vm'] }
             ]
           )
         end
@@ -75,7 +91,7 @@ module Fog
 
       class Mock
         def list_hosts(filters = {})
-          self.data[:hosts].values.select {|r| r[:datacenter] == filters[:datacenter] && r[:cluster] == filters[:cluster]}
+          data[:hosts].values.select { |r| r[:datacenter] == filters[:datacenter] && r[:cluster] == filters[:cluster] }
         end
       end
     end

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

@@ -2,21 +2,21 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_interface_types(filters={})
+        def list_interface_types(filters = {})
           datacenter_name = filters[:datacenter]
           servertype_name = filters[:servertype]
-          get_raw_server_type(servertype_name, datacenter_name)[:supportedEthernetCard].map do | nictype |
-            next if filters.key?(:id) and filters[:id] != nictype
+          get_raw_server_type(servertype_name, datacenter_name)[:supportedEthernetCard].map do |nictype|
+            next if filters.key?(:id) && (filters[:id] != nictype)
             interface_type_attributes(nictype, servertype_name, datacenter_name)
           end.compact
         end
 
         def interface_type_attributes(nic, servertype, datacenter)
           {
-            :id => nic,
-            :name => nic,
-            :datacenter => datacenter,
-            :servertype => servertype
+            id: nic,
+            name: nic,
+            datacenter: datacenter,
+            servertype: servertype
           }
         end
       end

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

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_networks(filters = { })
+        def list_networks(filters = {})
           datacenter_name = filters[:datacenter]
           cluster_name = filters.fetch(:cluster, nil)
           # default to show all networks
@@ -24,7 +24,7 @@ module Fog
         protected
 
         def network_attributes(network, datacenter)
-          if network.kind_of?(RbVmomi::VIM::DistributedVirtualPortgroup)
+          if network.is_a?(RbVmomi::VIM::DistributedVirtualPortgroup)
             id = network.key
             virtualswitch = network.config.distributedVirtualSwitch.name
             vlanid = raw_network_vlan(network.config.defaultPortConfig)
@@ -34,12 +34,12 @@ module Fog
             vlanid = nil
           end
           {
-            :id            => id,
-            :name          => network.name,
-            :accessible    => network.summary.accessible,
-            :datacenter    => datacenter,
-            :virtualswitch => virtualswitch,
-            :vlanid        => vlanid
+            id: id,
+            name: network.name,
+            accessible: network.summary.accessible,
+            datacenter: datacenter,
+            virtualswitch: virtualswitch,
+            vlanid: vlanid
           }
         end
 
@@ -49,8 +49,6 @@ module Fog
           case network
           when RbVmomi::VIM::VMwareDVSPortSetting
             raw_network_vlan_id(network.vlan)
-          else
-            nil
           end
         end
 
@@ -58,8 +56,6 @@ module Fog
           case vlan
           when RbVmomi::VIM::VmwareDistributedVirtualSwitchVlanIdSpec
             vlan.vlanId
-          else
-            nil
           end
         end
       end
@@ -68,11 +64,11 @@ module Fog
           datacenter_name = filters[:datacenter]
           cluster_name = filters.fetch(:cluster, nil)
           if cluster_name.nil?
-            self.data[:networks].values.select { |d| d['datacenter'] == datacenter_name } or
-              raise Fog::Compute::Vsphere::NotFound
+            data[:networks].values.select { |d| d['datacenter'] == datacenter_name } ||
+              raise(Fog::Compute::Vsphere::NotFound)
           else
-            self.data[:networks].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } or
-              raise Fog::Compute::Vsphere::NotFound
+            data[:networks].values.select { |d| d['datacenter'] == datacenter_name && d['cluster'].include?(cluster_name) } ||
+              raise(Fog::Compute::Vsphere::NotFound)
           end
         end
       end

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

@@ -6,32 +6,32 @@ module Fog
           vm = get_vm_ref(vm_id)
 
           auth = RbVmomi::VIM::NamePasswordAuthentication(
-            :username => opts[:user],
-            :password => opts[:password],
-            :interactiveSession => false
+            username: opts[:user],
+            password: opts[:password],
+            interactiveSession: false
           )
 
           p_manager = connection.serviceContent.guestOperationsManager.processManager
-          processes = p_manager.ListProcessesInGuest(:vm => vm, :auth => auth)
+          processes = p_manager.ListProcessesInGuest(vm: vm, auth: auth)
           processes.map do |pi|
             Process.new(
-              :cmd_line => pi.cmdLine,
-              :end_time => pi.endTime,
-              :exit_code => pi.exitCode,
-              :name => pi.name,
-              :owner => pi.owner,
-              :pid => pi.pid,
-              :start_time => pi.startTime
+              cmd_line: pi.cmdLine,
+              end_time: pi.endTime,
+              exit_code: pi.exitCode,
+              name: pi.name,
+              owner: pi.owner,
+              pid: pi.pid,
+              start_time: pi.startTime
             )
           end
         end
       end
 
       class Mock
-        def list_processes(vm_id, opts = {})
+        def list_processes(_vm_id, _opts = {})
           [
-            Process.new(:name => 'winlogon'),
-            Process.new(:name => 'init')
+            Process.new(name: 'winlogon'),
+            Process.new(name: 'init')
           ]
         end
       end

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

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_resource_pools(filters = { })
+        def list_resource_pools(filters = {})
           datacenter_name = filters[:datacenter]
           cluster_name    = filters[:cluster]
           cluster         = get_raw_cluster(cluster_name, datacenter_name)
@@ -21,14 +21,14 @@ module Fog
         end
 
         def traverse_raw_resource_pools(pools, rp)
-          if rp 
+          if rp
             if rp.respond_to? :resourcePool
               traverse_raw_resource_pools(pools, rp.resourcePool)
             end
             if rp.respond_to? :each
-               rp.each do |resourcePool|
-                 traverse_raw_resource_pools(pools, resourcePool)
-               end
+              rp.each do |resourcePool|
+                traverse_raw_resource_pools(pools, resourcePool)
+              end
             else
               pools << rp
             end
@@ -36,22 +36,21 @@ module Fog
         end
 
         def resource_pool_attributes(resource_pool, cluster, datacenter)
-          name = folder_path(resource_pool).gsub(/^.*Resources(\/|)/,'')
+          name = folder_path(resource_pool).gsub(/^.*Resources(\/|)/, '')
           name = 'Resources' if name.empty?
           {
-            :id                   => managed_obj_id(resource_pool),
-            :name                 => name,
-            :configured_memory_mb => resource_pool.summary.configuredMemoryMB,
-            :overall_status       => resource_pool.overallStatus,
-            :cluster              => cluster,
-            :datacenter           => datacenter
+            id: managed_obj_id(resource_pool),
+            name: name,
+            configured_memory_mb: resource_pool.summary.configuredMemoryMB,
+            overall_status: resource_pool.overallStatus,
+            cluster: cluster,
+            datacenter: datacenter
           }
         end
       end
 
       class Mock
-        def list_resource_pools(filters = { })
-        end
+        def list_resource_pools(filters = {}); end
       end
     end
   end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         def list_rules(filters = {})
           cluster = get_raw_cluster(filters[:cluster], filters[:datacenter])
-          cluster.configurationEx.rule.map {|r| rule_attributes r, filters}
+          cluster.configurationEx.rule.map { |r| rule_attributes r, filters }
         end
 
         protected
@@ -18,18 +18,18 @@ module Fog
           attributes[:enabled] = rule[:enabled]
           attributes[:type] = rule.class
           if rule.class.to_s == 'ClusterAntiAffinityRuleSpec' || rule.class.to_s == 'ClusterAffinityRuleSpec'
-            attributes[:vm_ids] = rule[:vm].map {|vm| vm.config.instanceUuid}
+            attributes[:vm_ids] = rule[:vm].map { |vm| vm.config.instanceUuid }
           elsif rule.class.to_s == 'ClusterVmHostRuleInfo'
             attributes[:mandatory] = rule[:mandatory]
             attributes[:vmGroupName] = rule[:vmGroupName]
             attributes[:affineHostGroupName] = rule[:affineHostGroupName]
           end
-          return attributes
+          attributes
         end
       end
       class Mock
         def list_rules(filters = {})
-          self.data[:rules].values.select {|r| r[:datacenter] == filters[:datacenter] && r[:cluster] == filters[:cluster]}
+          data[:rules].values.select { |r| r[:datacenter] == filters[:datacenter] && r[:cluster] == filters[:cluster] }
         end
       end
     end

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

@@ -2,22 +2,20 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_server_types(filters={})
+        def list_server_types(filters = {})
           datacenter_name = filters[:datacenter]
-          servertypes=raw_server_types(datacenter_name)
+          servertypes = raw_server_types(datacenter_name)
           if servertypes
-            servertypes.map do | servertype |
-               server_type_attributes(servertype, datacenter_name)
+            servertypes.map do |servertype|
+              server_type_attributes(servertype, datacenter_name)
             end.compact
-          else
-            nil
           end
-          #select{ | guestdesc | guestdesc.select{ | k, v | filter.has_key?(k) and filter[k] == v }==filter }
+          # select{ | guestdesc | guestdesc.select{ | k, v | filter.has_key?(k) and filter[k] == v }==filter }
         end
 
-        def raw_server_types(datacenter_name, filter={})
-          datacenter=find_raw_datacenter(datacenter_name)
-          environmentBrowser=datacenter.hostFolder.childEntity.grep(RbVmomi::VIM::ComputeResource).first.environmentBrowser
+        def raw_server_types(datacenter_name, _filter = {})
+          datacenter = find_raw_datacenter(datacenter_name)
+          environmentBrowser = datacenter.hostFolder.childEntity.grep(RbVmomi::VIM::ComputeResource).first.environmentBrowser
           if environmentBrowser
             environmentBrowser.QueryConfigOption[:guestOSDescriptor]
           end
@@ -27,26 +25,26 @@ module Fog
 
         def server_type_attributes(servertype, datacenter)
           {
-            :id         => servertype.id,
-            :name       => servertype.id,
-            :family     => servertype.family,
-            :fullname   => servertype.fullName,
-            :datacenter => datacenter,
+            id: servertype.id,
+            name: servertype.id,
+            family: servertype.family,
+            fullname: servertype.fullName,
+            datacenter: datacenter
           }
         end
       end
       class Mock
-        def list_server_types(datacenter_name)
-          [{:id=>"rhel6Guest",
-            :name=>"rhel6Guest",
-            :family=>"linuxGuest",
-            :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)",
-            :datacenter=>"Solutions"},
-           {:id=>"rhel5_64Guest",
-            :name=>"rhel5_64Guest",
-            :family=>"linuxGuest",
-            :fullname=>"Red Hat Enterprise Linux 5 (64-Bit)",
-            :datacenter=>"Solutions"}]
+        def list_server_types(_datacenter_name)
+          [{ id: 'rhel6Guest',
+             name: 'rhel6Guest',
+             family: 'linuxGuest',
+             fullname: 'Red Hat Enterprise Linux 6 (32-Bit)',
+             datacenter: 'Solutions' },
+           { id: 'rhel5_64Guest',
+             name: 'rhel5_64Guest',
+             family: 'linuxGuest',
+             fullname: 'Red Hat Enterprise Linux 5 (64-Bit)',
+             datacenter: 'Solutions' }]
         end
       end
     end

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

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_storage_pods(filters = { })
+        def list_storage_pods(filters = {})
           datacenter_name = filters[:datacenter]
           raw_storage_pods(datacenter_name).map do |storage_pod|
             storage_pod_attributes(storage_pod, datacenter_name)
@@ -19,20 +19,20 @@ module Fog
 
         def storage_pod_attributes(storage_pod, datacenter)
           {
-            :id          => managed_obj_id(storage_pod),
-            :name        => storage_pod.name,
-            :freespace   => storage_pod.summary.freeSpace,
-            :capacity    => storage_pod.summary.capacity,
-            :datacenter  => datacenter,
+            id: managed_obj_id(storage_pod),
+            name: storage_pod.name,
+            freespace: storage_pod.summary.freeSpace,
+            capacity: storage_pod.summary.capacity,
+            datacenter: datacenter
           }
         end
       end
       class Mock
         def list_storage_pods(filters = {})
           if filters.key?(:datacenter)
-            self.data[:storage_pods].select{|h| h[:datacenter] == filters[:datacenter] }
+            data[:storage_pods].select { |h| h[:datacenter] == filters[:datacenter] }
           else
-            self.data[:storage_pods]
+            data[:storage_pods]
           end
         end
       end