fog-vsphere 2.1.1 → 2.2.0

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

@@ -5,8 +5,8 @@ module Fog
         def folder_destroy(path, datacenter_name)
           folder = get_raw_vmfolder(path, datacenter_name)
           raise Fog::Vsphere::Errors::NotFound, "No such folder #{path}" unless folder
-          raise Fog::Vsphere::Errors::ServiceError, "Folder #{path} is not empty" if folder.childEntity.size > 0
-          
+          raise Fog::Vsphere::Errors::ServiceError, "Folder #{path} is not empty" unless folder.childEntity.empty?
+
           task = folder.Destroy_Task
           task.wait_for_completion
           { 'task_state' => task.info.state }
@@ -15,7 +15,7 @@ module Fog
       class Mock
         def folder_destroy(path, datacenter_name)
           vms = list_virtual_machines(folder: path, datacenter: datacenter_name)
-          if vms.length > 0
+          unless vms.empty?
             raise Fog::Vsphere::Errors::ServiceError, "Folder #{path} is not empty"
           end
           { 'task_state' => 'success' }

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

@@ -18,8 +18,8 @@ module Fog
 
       class Mock
         def get_cluster(name, datacenter_name)
-          self.data[:clusters].find {|c| c[:name] == name && c[:datacenter] == datacenter_name} or
-            raise Fog::Compute::Vsphere::NotFound
+          data[:clusters].find { |c| c[:name] == name && c[:datacenter] == datacenter_name } ||
+            raise(Fog::Compute::Vsphere::NotFound)
         end
       end
     end

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

@@ -16,23 +16,23 @@ module Fog
       end
 
       class Mock
-        def get_compute_resource(name, datacenter_name)
+        def get_compute_resource(_name, _datacenter_name)
           {
-            :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
           }
         end
       end

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

@@ -2,26 +2,26 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def get_datacenter name
+        def get_datacenter(name)
           dc = find_raw_datacenter(name)
           raise(Fog::Compute::Vsphere::NotFound) unless dc
-          {:name => dc.name, :status => dc.overallStatus, :path => raw_getpathmo(dc) }
+          { name: dc.name, status: dc.overallStatus, path: raw_getpathmo(dc) }
         end
 
         protected
 
-        def find_raw_datacenter name
-          raw_datacenters.find {|d| d.name == name} || get_raw_datacenter(name)
+        def find_raw_datacenter(name)
+          raw_datacenters.find { |d| d.name == name } || get_raw_datacenter(name)
         end
 
-        def get_raw_datacenter name
+        def get_raw_datacenter(name)
           connection.serviceInstance.find_datacenter(name)
         end
       end
 
       class Mock
-        def get_datacenter name
-          dc = self.data[:datacenters][name]
+        def get_datacenter(name)
+          dc = data[:datacenters][name]
           raise(Fog::Compute::Vsphere::NotFound) unless dc
           dc
         end

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

@@ -20,8 +20,7 @@ module Fog
       end
 
       class Mock
-        def get_datastore(name, datacenter_name)
-        end
+        def get_datastore(name, datacenter_name); end
       end
     end
   end

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

@@ -7,17 +7,17 @@ module Fog
 
           # Cycle through all types of folders.
           case type
-            when 'vm', :vm
-              # if you're a vm then grab the VM.
-              folder = get_raw_vmfolder(path, datacenter_name)
-              raise(Fog::Compute::Vsphere::NotFound) unless folder
-              folder_attributes(folder, datacenter_name)
-            when 'network', :network
-              raise "not implemented"
-            when 'datastore', :datastore
-              raise "not implemented"
-            else
-              raise ArgumentError, "#{type} is unknown"
+          when 'vm', :vm
+            # if you're a vm then grab the VM.
+            folder = get_raw_vmfolder(path, datacenter_name)
+            raise(Fog::Compute::Vsphere::NotFound) unless folder
+            folder_attributes(folder, datacenter_name)
+          when 'network', :network
+            raise 'not implemented'
+          when 'datastore', :datastore
+            raise 'not implemented'
+          else
+            raise ArgumentError, "#{type} is unknown"
           end
         end
 
@@ -30,8 +30,8 @@ module Fog
           dc             = find_raw_datacenter(datacenter_name)
           dc_root_folder = dc.vmFolder
           # Filter the root path for this datacenter not to be used."
-          dc_root_folder_path=dc_root_folder.path.map { | id, name | name }.join("/")
-          paths          = path.sub(/^\/?#{Regexp.quote(dc_root_folder_path)}\/?/, '').split('/')
+          dc_root_folder_path = dc_root_folder.path.map { |_id, name| name }.join('/')
+          paths = path.sub(/^\/?#{Regexp.quote(dc_root_folder_path)}\/?/, '').split('/')
 
           return dc_root_folder if paths.empty?
           # Walk the tree resetting the folder pointer as we go
@@ -48,17 +48,17 @@ module Fog
 
         def folder_attributes(folder, datacenter_name)
           {
-            :id         => managed_obj_id(folder),
-            :name       => folder.name,
-            :parent     => folder.parent.name,
-            :datacenter => datacenter_name,
-            :type       => folder_type(folder),
-            :path       => folder_path(folder),
+            id: managed_obj_id(folder),
+            name: folder.name,
+            parent: folder.parent.name,
+            datacenter: datacenter_name,
+            type: folder_type(folder),
+            path: folder_path(folder)
           }
         end
-        
+
         def folder_path(folder)
-            "/"+folder.path.map(&:last).join('/')
+          '/' + folder.path.map(&:last).join('/')
         end
 
         def folder_type(folder)
@@ -70,9 +70,9 @@ module Fog
       end
 
       class Mock
-        def get_folder(path, datacenter_name, type = nil)
-          self.data[:folders].values.find {|f| f['datacenter'] == datacenter_name and f['path'].end_with? path} or
-            raise Fog::Compute::Vsphere::NotFound        
+        def get_folder(path, datacenter_name, _type = nil)
+          data[:folders].values.find { |f| (f['datacenter'] == datacenter_name) && f['path'].end_with?(path) } ||
+            raise(Fog::Compute::Vsphere::NotFound)
         end
       end
     end

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

@@ -2,7 +2,6 @@ module Fog
   module Compute
     class Vsphere
       class Real
-
         def get_host(name, cluster_name, datacenter_name)
           get_raw_host(name, cluster_name, datacenter_name)
         end
@@ -11,8 +10,8 @@ module Fog
 
         def get_raw_host(name, cluster_name, datacenter_name)
           cluster = get_raw_cluster(cluster_name, datacenter_name)
-          cluster.host.find { |host| host.name == name } or
-                        raise Fog::Compute::Vsphere::NotFound, "no such host #{name}"
+          cluster.host.find { |host| host.name == name } ||
+            raise(Fog::Compute::Vsphere::NotFound, "no such host #{name}")
         end
       end
     end

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

@@ -2,12 +2,12 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def get_interface_type(id, servertype, datacenter, filter={})
-           interfacetype=list_interface_types(filters={:id => id,
-             :datacenter => datacenter,
-             :servertype => servertype.id }).first
-           raise(Fog::Compute::Vsphere::NotFound) unless interfacetype
-           interfacetype
+        def get_interface_type(id, servertype, datacenter, _filter = {})
+          interfacetype = list_interface_types(filters = { id: id,
+                                                           datacenter: datacenter,
+                                                           servertype: servertype.id }).first
+          raise(Fog::Compute::Vsphere::NotFound) unless interfacetype
+          interfacetype
         end
       end
     end

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

@@ -10,14 +10,13 @@ module Fog
 
         protected
 
-        def get_raw_network(name, datacenter_name, distributedswitch=nil)
+        def get_raw_network(name, datacenter_name, distributedswitch = nil)
           finder = choose_finder(name, distributedswitch)
           get_all_raw_networks(datacenter_name).find { |n| finder.call(n) }
         end
       end
 
       module Shared
-
         protected
 
         def get_all_raw_networks(datacenter_name)
@@ -28,24 +27,22 @@ module Fog
           case distributedswitch
           when String
             # only the one will do
-            Proc.new { |n| (n.name == name) &&
-                (n.class.to_s == "DistributedVirtualPortgroup") &&
+            proc do |n|
+              n.is_a?(RbVmomi::VIM::DistributedVirtualPortgroup) && (n.name == name || n.key == name) &&
                 (n.config.distributedVirtualSwitch.name == distributedswitch)
-            }
+            end
           when :dvs
             # the first distributed virtual switch will do - selected by network - gives control to vsphere
-            Proc.new { |n| (n.name == name) && (n.class.to_s == "DistributedVirtualPortgroup") }
+            proc { |n| (n.name == name || n.key == name) && (n.class.to_s == 'DistributedVirtualPortgroup') }
           else
             # the first matching network will do, seems like the non-distributed networks come first
-            Proc.new { |n| (n.name == name) }
+            proc { |n| (n.name == name || (n.is_a?(RbVmomi::VIM::DistributedVirtualPortgroup) && n.key == name)) }
           end
         end
-
       end
 
       class Mock
-        def get_network(id)
-        end
+        def get_network(id); end
       end
     end
   end

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

@@ -18,8 +18,7 @@ module Fog
       end
 
       class Mock
-        def get_resource_pool(name, cluster_name, datacenter_name)
-        end
+        def get_resource_pool(name, cluster_name, datacenter_name); end
       end
     end
   end

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

@@ -2,29 +2,29 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def get_server_type(id, datacenter, filter={})
-          server_type=get_raw_server_type(id, datacenter)
+        def get_server_type(id, datacenter, _filter = {})
+          server_type = get_raw_server_type(id, datacenter)
           raise(Fog::Compute::Vsphere::NotFound) unless server_type
           server_type_attributes(server_type, datacenter)
         end
 
         protected
 
-        def get_raw_server_type(id, datacenter, filter={})
-           types=raw_server_types(datacenter)
-           raise(Fog::Compute::Vsphere::NotFound) unless types
-           types=types.select{ | servertype | servertype.id == id }.first
-           raise(Fog::Compute::Vsphere::NotFound) unless types
-           types
+        def get_raw_server_type(id, datacenter, _filter = {})
+          types = raw_server_types(datacenter)
+          raise(Fog::Compute::Vsphere::NotFound) unless types
+          types = types.select { |servertype| servertype.id == id }.first
+          raise(Fog::Compute::Vsphere::NotFound) unless types
+          types
         end
       end
       class Mock
-        def get_server_type(id)
-          {:id=>"rhel6Guest",
-            :name=>"rhel6Guest",
-            :family=>"linuxGuest",
-            :fullname=>"Red Hat Enterprise Linux 6 (32-Bit)",
-            :datacenter=>"Solutions"}
+        def get_server_type(_id)
+          { id: 'rhel6Guest',
+            name: 'rhel6Guest',
+            family: 'linuxGuest',
+            fullname: 'Red Hat Enterprise Linux 6 (32-Bit)',
+            datacenter: 'Solutions' }
         end
       end
     end

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

@@ -11,13 +11,13 @@ module Fog
         protected
 
         def get_raw_storage_pod(name, datacenter_name)
-          raw_storage_pods(datacenter_name).detect { |pod| pod.name == name}
+          raw_storage_pods(datacenter_name).detect { |pod| pod.name == name }
         end
       end
 
       class Mock
         def get_storage_pod(name, datacenter_name)
-          list_storage_pods({datacenter: datacenter_name}).detect { |h| h[:name] == name }
+          list_storage_pods(datacenter: datacenter_name).detect { |h| h[:name] == name }
         end
       end
     end

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

@@ -8,8 +8,7 @@ module Fog
       end
 
       class Mock
-        def get_template(id, datacenter_name = nil)
-        end
+        def get_template(id, datacenter_name = nil); end
       end
     end
   end

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

@@ -13,36 +13,36 @@ module Fog
           raw_datacenter = find_raw_datacenter(dc) if dc
           vm = case is_uuid?(id)
                  # UUID based
-                 when true
-                   params = {:uuid => id, :vmSearch => true, :instanceUuid => true}
-                   params[:datacenter] = raw_datacenter if dc
-                   connection.searchIndex.FindByUuid(params)
+               when true
+                 params = { uuid: id, vmSearch: true, instanceUuid: true }
+                 params[:datacenter] = raw_datacenter if dc
+                 connection.searchIndex.FindByUuid(params)
+               else
+                 # try to find based on VM name
+                 if dc
+                   get_vm_by_name(id, dc, folder, recursive)
                  else
-                   # try to find based on VM name
-                   if dc
-                     get_vm_by_name(id, dc, folder, recursive)
-                   else
-                     raw_datacenters.map { |d| get_vm_by_name(id, d["name"], folder, recursive)}.compact.first
-                   end
+                   raw_datacenters.map { |d| get_vm_by_name(id, d['name'], folder, recursive) }.compact.first
+                 end
                end
           vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
         end
 
         def get_vm_by_name(name, dc, folder, recursive)
-          if folder
-            # This returns an Enumerator, which when called with .find will
-            # search only until it finds the VM we're looking for
-            vms = raw_list_all_virtual_machines_in_folder(folder, dc, recursive)
-          else
-            vms = raw_list_all_virtual_machines(dc)
-          end
+          vms = if folder
+                  # This returns an Enumerator, which when called with .find will
+                  # search only until it finds the VM we're looking for
+                  raw_list_all_virtual_machines_in_folder(folder, dc, recursive)
+                else
+                  raw_list_all_virtual_machines(dc)
+                end
 
           if name.include?('/')
             folder = File.dirname(name)
             basename = File.basename(name)
             vms.find do |v|
               begin
-                v["name"] == basename && v.parent.pretty_path.include?(folder)
+                v['name'] == basename && v.parent.pretty_path.include?(folder)
               rescue RbVmomi::VIM::ManagedObjectNotFound
                 false
               end
@@ -50,7 +50,7 @@ module Fog
           else
             vms.find do |v|
               begin
-                v["name"] == name
+                v['name'] == name
               rescue RbVmomi::VIM::ManagedObjectNotFound
                 false
               end
@@ -60,13 +60,13 @@ module Fog
       end
 
       class Mock
-        def get_virtual_machine(id, datacenter_name = nil, folder = nil, recursive = false)
-          if is_uuid?(id)
-            vm = list_virtual_machines({ 'instance_uuid' => id, 'datacenter' => datacenter_name }).first
-          else
-            # try to find based on VM name. May need to handle the path of the VM
-            vm = list_virtual_machines({ 'name' => id, 'datacenter' => datacenter_name }).first
-          end
+        def get_virtual_machine(id, datacenter_name = nil, _folder = nil, _recursive = false)
+          vm = if is_uuid?(id)
+                 list_virtual_machines('instance_uuid' => id, 'datacenter' => datacenter_name).first
+               else
+                 # try to find based on VM name. May need to handle the path of the VM
+                 list_virtual_machines('name' => id, 'datacenter' => datacenter_name).first
+               end
           vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
         end
       end