fog-vsphere 2.1.1 → 2.2.0

data/lib/fog/vsphere/models/compute/networks.rb

@@ -8,7 +8,7 @@ module Fog
         attr_accessor :datacenter, :cluster
 
         def all(filters = {})
-          f = { :datacenter => datacenter, :cluster => cluster }.merge(filters)
+          f = { datacenter: datacenter, cluster: cluster }.merge(filters)
           load service.list_networks(f)
         end
 

data/lib/fog/vsphere/models/compute/resource_pools.rb

@@ -8,7 +8,7 @@ module Fog
         attr_accessor :datacenter, :cluster
 
         def all(filters = {})
-          load service.list_resource_pools(filters.merge(:datacenter => datacenter, :cluster => cluster))
+          load service.list_resource_pools(filters.merge(datacenter: datacenter, cluster: cluster))
         end
 
         def get(id)

data/lib/fog/vsphere/models/compute/rule.rb

@@ -4,7 +4,7 @@ module Fog
       # ClusterRuleInfo
       class Rule < Fog::Model
         identity :key
-        
+
         attribute :datacenter
         attribute :cluster
         attribute :name
@@ -15,32 +15,31 @@ module Fog
         #  - RbVmomi::VIM::ClusterVmHostRuleInfo
         attribute :type
         attribute :vm_ids
-        
+
         def vms
-          vm_ids.map {|id| service.servers.get(id, datacenter) }
+          vm_ids.map { |id| service.servers.get(id, datacenter) }
         end
-        
+
         def vms=(vms)
           self.vm_ids = vms.map(&:instance_uuid)
         end
-        
+
         def save
           requires :datacenter, :cluster, :name, :enabled, :type, :vm_ids
           if vm_ids.length < 2
-            raise ArgumentError, "A rule must have at least 2 VMs"
+            raise ArgumentError, 'A rule must have at least 2 VMs'
           end
           if persisted?
-            raise "Update is not supported yet"
+            raise 'Update is not supported yet'
           else
             self.key = service.create_rule(attributes)
           end
           reload
         end
-        
+
         def destroy
           service.destroy_rule(attributes)
         end
-        
       end
     end
   end

data/lib/fog/vsphere/models/compute/rules.rb

@@ -3,27 +3,26 @@ module Fog
     class Vsphere
       class Rules < Fog::Collection
         autoload :Rule, File.expand_path('../rule', __FILE__)
-        
+
         model Fog::Compute::Vsphere::Rule
         attribute :datacenter
         attribute :cluster
-        
-        def all(filters = {})
+
+        def all(_filters = {})
           requires :datacenter, :cluster
-          load service.list_rules(:datacenter => datacenter, :cluster => cluster)
+          load service.list_rules(datacenter: datacenter, cluster: cluster)
         end
-        
+
         def get(key_or_name)
-          all.find {|rule| [rule.key, rule.name].include? key_or_name } or
-            raise Fog::Compute::Vsphere::NotFound, "no such rule #{key_or_name}"
+          all.find { |rule| [rule.key, rule.name].include? key_or_name } ||
+            raise(Fog::Compute::Vsphere::NotFound, "no such rule #{key_or_name}")
         end
-        
+
         # Pass datacenter/cluster to every new rule
-        def new(attributes={})
+        def new(attributes = {})
           requires :datacenter, :cluster
           super(attributes.merge(datacenter: datacenter, cluster: cluster))
         end
-
       end
     end
   end

data/lib/fog/vsphere/models/compute/scsicontroller.rb

@@ -5,7 +5,7 @@ module Fog
         attribute :shared_bus
         attribute :type
         attribute :unit_number
-        attribute :key, :type => :integer
+        attribute :key, type: :integer
         attribute :server_id
 
         def initialize(attributes = {})

data/lib/fog/vsphere/models/compute/server.rb

@@ -24,12 +24,12 @@ module Fog
         attribute :uuid
         attribute :hostname
         attribute :operatingsystem
-        attribute :public_ip_address, :aliases => 'ipaddress'
-        attribute :power_state,   :aliases => 'power'
-        attribute :tools_state,   :aliases => 'tools'
+        attribute :public_ip_address, aliases: 'ipaddress'
+        attribute :power_state,   aliases: 'power'
+        attribute :tools_state,   aliases: 'tools'
         attribute :tools_version
-        attribute :mac_addresses, :aliases => 'macs'
-        attribute :hypervisor,    :aliases => 'host'
+        attribute :mac_addresses, aliases: 'macs'
+        attribute :hypervisor,    aliases: 'host'
         attribute :connection_state
         attribute :mo_ref
         attribute :path
@@ -39,20 +39,20 @@ module Fog
         attribute :interfaces
         attribute :volumes
         attribute :customvalues
-        attribute :overall_status, :aliases => 'status'
+        attribute :overall_status, aliases: 'status'
         attribute :cluster
         attribute :datacenter
         attribute :resource_pool
         attribute :instance_uuid # move this --> id
         attribute :guest_id
         attribute :hardware_version
-        attribute :scsi_controllers, :type => :array
+        attribute :scsi_controllers, type: :array
         attribute :cpuHotAddEnabled
         attribute :memoryHotAddEnabled
         attribute :firmware
         attribute :annotation
 
-        def initialize(attributes={} )
+        def initialize(attributes = {})
           super defaults.merge(attributes)
           self.instance_uuid ||= id # TODO: remvoe instance_uuid as it can be replaced with simple id
           initialize_interfaces
@@ -62,7 +62,7 @@ module Fog
         end
 
         # Lazy Loaded Attributes
-        [:datacenter, :cluster, :hypervisor, :resource_pool, :mac_addresses].each do |attr|
+        %i[datacenter cluster hypervisor resource_pool mac_addresses].each do |attr|
           define_method attr do
             attributes[attr] = attributes[attr].call if attributes[attr].is_a?(Proc)
             attributes[attr]
@@ -75,45 +75,45 @@ module Fog
           service.vm_rename('instance_uuid' => instance_uuid, 'name' => name)
         end
 
-        def vm_reconfig_memory(options = {})
+        def vm_reconfig_memory(_options = {})
           requires :instance_uuid, :memory
           service.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory_mb)
         end
 
-        def vm_reconfig_cpus(options = {})
+        def vm_reconfig_cpus(_options = {})
           requires :instance_uuid, :cpus, :corespersocket
           service.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus, 'corespersocket' => corespersocket)
         end
 
-        def vm_reconfig_volumes(options = {})
+        def vm_reconfig_volumes(_options = {})
           requires :instance_uuid, :volumes
           service.vm_reconfig_volumes('instance_uuid' => instance_uuid, 'volumes' => volumes)
         end
 
-        def vm_reconfig_hardware(hardware_spec, options = {})
+        def vm_reconfig_hardware(hardware_spec, _options = {})
           requires :instance_uuid
           service.vm_reconfig_hardware('instance_uuid' => instance_uuid, 'hardware_spec' => hardware_spec)
         end
 
-        def start(options = {})
+        def start(_options = {})
           requires :instance_uuid
           service.vm_power_on('instance_uuid' => instance_uuid) unless ready?
         end
 
         def stop(options = {})
-          options = { :force => !tools_installed? || !tools_running? }.merge(options)
+          options = { force: !tools_installed? || !tools_running? }.merge(options)
           requires :instance_uuid
           service.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force]) unless power_state == 'poweredOff'
         end
 
         def suspend(options = {})
-          options = { :force => !tools_installed? || !tools_running? }.merge(options)
+          options = { force: !tools_installed? || !tools_running? }.merge(options)
           requires :instance_uuid
           service.vm_suspend('instance_uuid' => instance_uuid, 'force' => options[:force])
         end
 
         def reboot(options = {})
-          options = { :force => false }.merge(options)
+          options = { force: false }.merge(options)
           requires :instance_uuid
           service.vm_reboot('instance_uuid' => instance_uuid, 'force' => options[:force])
         end
@@ -129,15 +129,15 @@ module Fog
         end
 
         def migrate(options = {})
-          options = { :priority => 'defaultPriority' }.merge(options)
+          options = { priority: 'defaultPriority' }.merge(options)
           requires :instance_uuid
 
           # Convert symbols to strings
-          req_options = options.reduce({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
+          req_options = options.each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v; }
           req_options['cluster'] ||= cluster
-          req_options['datacenter'] = "#{datacenter}"
+          req_options['datacenter'] = datacenter.to_s
           req_options['instance_uuid'] = instance_uuid
-          
+
           service.vm_migrate(req_options)
         end
 
@@ -152,22 +152,22 @@ module Fog
           requires :name, :datacenter, :path
 
           # Convert symbols to strings
-          req_options = options.reduce({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
+          req_options = options.each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v; }
 
           # Give our path to the request
-          req_options['template_path'] ="#{relative_path}/#{name}"
-          req_options['datacenter'] = "#{datacenter}"
+          req_options['template_path'] = "#{relative_path}/#{name}"
+          req_options['datacenter'] = datacenter.to_s
 
           # Perform the actual clone
           clone_results = service.vm_clone(req_options)
 
           # We need to assign the service, otherwise we can't reload the model
           # Create the new VM model. TODO This only works when "wait=true"
-          new_vm = self.class.new(clone_results['new_vm'].merge(:service => self.service))
+          new_vm = self.class.new(clone_results['new_vm'].merge(service: service))
 
           # We need to assign the collection otherwise we
           # cannot reload the model.
-          new_vm.collection = self.collection
+          new_vm.collection = collection
 
           # Return the new VM model.
           new_vm
@@ -179,7 +179,7 @@ module Fog
         end
 
         def ready?
-          power_state == "poweredOn"
+          power_state == 'poweredOn'
         end
 
         def tools_installed?
@@ -187,7 +187,7 @@ module Fog
         end
 
         def tools_running?
-          ["toolsOk","toolsOld"].include? tools_state
+          %w[toolsOk toolsOld].include? tools_state
         end
 
         # defines VNC attributes on the hypervisor
@@ -215,36 +215,36 @@ module Fog
         end
 
         def interfaces
-          attributes[:interfaces] ||= id.nil? ? [] : service.interfaces( :server_id => self.id )
+          attributes[:interfaces] ||= id.nil? ? [] : service.interfaces(server_id: id)
         end
 
-        def interface_ready? attrs
-          (attrs.is_a? Hash and attrs[:blocking]) or attrs.is_a? Fog::Compute::Vsphere::Interface
+        def interface_ready?(attrs)
+          (attrs.is_a?(Hash) && attrs[:blocking]) || attrs.is_a?(Fog::Compute::Vsphere::Interface)
         end
 
-        def add_interface attrs
-          Fog::Logger.deprecation("<server>.add_interface is deprecated. Call <server>.interfaces.create instead.")
+        def add_interface(attrs)
+          Fog::Logger.deprecation('<server>.add_interface is deprecated. Call <server>.interfaces.create instead.')
 
           interfaces.create(attrs)
         end
 
-        def update_interface attrs
-          wait_for { not ready? } if interface_ready? attrs
+        def update_interface(attrs)
+          wait_for { !ready? } if interface_ready? attrs
           service.update_vm_interface(id, attrs)
         end
 
-        def destroy_interface attrs
-          Fog::Logger.deprecation("<server>.destroy_vm_interface is deprecated. Call <server>.interfaces.get(:key => <nic_key>).destroy instead.")
+        def destroy_interface(attrs)
+          Fog::Logger.deprecation('<server>.destroy_vm_interface is deprecated. Call <server>.interfaces.get(:key => <nic_key>).destroy instead.')
 
           interfaces.get(attrs[:key] || attrs['key']).destroy
         end
 
         def volumes
-          attributes[:volumes] ||= id.nil? ? [] : service.volumes(:server_id => self.id)
+          attributes[:volumes] ||= id.nil? ? [] : service.volumes(server_id: id)
         end
 
         def snapshots(opts = {})
-          service.snapshots(:server_id => self.id).all(opts)
+          service.snapshots(server_id: id).all(opts)
         end
 
         def find_snapshot(snapshot_ref)
@@ -258,12 +258,12 @@ module Fog
           when String
             service.revert_to_snapshot(find_snapshot(snapshot))
           else
-            fail ArgumentError, "snapshot has to be kind of Snapshot or String class"
+            raise ArgumentError, 'snapshot has to be kind of Snapshot or String class'
           end
         end
 
         def cdroms(opts = {})
-          service.cdroms(:instance_uuid => self.id).all(opts)
+          service.cdroms(instance_uuid: id).all(opts)
         end
 
         def cdrom(key)
@@ -271,16 +271,16 @@ module Fog
         end
 
         def guest_processes(opts = {})
-          fail 'VM tools must be running' unless tools_running?
-          service.list_processes(self.id, opts)
+          raise 'VM tools must be running' unless tools_running?
+          service.list_processes(id, opts)
         end
 
         def customvalues
-          attributes[:customvalues] ||= id.nil? ? [] : service.customvalues( :vm => self )
+          attributes[:customvalues] ||= id.nil? ? [] : service.customvalues(vm: self)
         end
 
         def scsi_controllers
-          self.attributes[:scsi_controllers] ||= service.list_vm_scsi_controllers(id)
+          attributes[:scsi_controllers] ||= service.list_vm_scsi_controllers(id)
         end
 
         def scsi_controller
@@ -288,21 +288,17 @@ module Fog
         end
 
         def folder
-          return nil unless datacenter and path
-          attributes[:folder] ||= service.folders(:datacenter => datacenter, :type => :vm).get(path)
+          return nil unless datacenter && path
+          attributes[:folder] ||= service.folders(datacenter: datacenter, type: :vm).get(path)
         end
 
         def save
           requires :name, :cluster, :datacenter
           if persisted?
-            vm_rename if attribute_changed?(:name)
-            vm_reconfig_cpus if attribute_changed?(:cpus) || attribute_changed?(:corespersocket)
-            vm_reconfig_memory if attribute_changed?(:memory_mb)
-            vm_reconfig_volumes if attribute_changed?(:volumes)
+            service.update_vm(self)
           else
             self.id = service.create_vm(attributes)
           end
-          @old = nil
           reload
         end
 
@@ -312,8 +308,8 @@ module Fog
 
         def reload
           # reload does not re-read assoiciated attributes, so we clear it manually
-          [:interfaces, :volumes].each do |attr|
-            self.attributes.delete(attr)
+          %i[interfaces volumes].each do |attr|
+            attributes.delete(attr)
           end
           super
         end
@@ -321,67 +317,59 @@ module Fog
         def relative_path
           requires :path, :datacenter
 
-          (path.split('/').reject {|e| e.empty?} - ["Datacenters", datacenter, "vm"]).join("/")
+          (path.split('/').reject(&:empty?) - ['Datacenters', datacenter, 'vm']).join('/')
         end
 
-        def acquire_ticket(type = nil)
-          service.tickets(:server => self).create
+        def acquire_ticket(_type = nil)
+          service.tickets(server: self).create
         end
 
         private
 
         def defaults
           {
-            :cpus      => 1,
-#            :corespersocket => 1,
-            :memory_mb => 512,
-            :guest_id  => 'otherGuest',
-            :path      => '/'
+            cpus: 1,
+            #            :corespersocket => 1,
+            memory_mb: 512,
+            guest_id: 'otherGuest',
+            path: '/'
           }
         end
 
         def initialize_interfaces
-          if attributes[:interfaces] and attributes[:interfaces].is_a?(Array)
-            self.attributes[:interfaces].map! { |nic| nic.is_a?(Hash) ? service.interfaces.new(nic) : nic }
+          if attributes[:interfaces] && attributes[:interfaces].is_a?(Array)
+            attributes[:interfaces].map! { |nic| nic.is_a?(Hash) ? service.interfaces.new(nic) : nic }
           end
         end
 
         def initialize_volumes
-          if attributes[:volumes] and attributes[:volumes].is_a?(Array)
-            self.attributes[:volumes].map! { |vol| vol.is_a?(Hash) ? service.volumes.new({:server => self}.merge(vol)) : vol }
+          if attributes[:volumes] && attributes[:volumes].is_a?(Array)
+            attributes[:volumes].map! { |vol| vol.is_a?(Hash) ? service.volumes.new({ server: self }.merge(vol)) : vol }
           end
         end
 
         def initialize_customvalues
-          if attributes[:customvalues] and attributes[:customvalues].is_a?(Array)
-            self.attributes[:customvalues].map { |cfield| cfield.is_a?(Hash) ? service.customvalue.new(cfield) : cfield}
+          if attributes[:customvalues] && attributes[:customvalues].is_a?(Array)
+            attributes[:customvalues].map { |cfield| cfield.is_a?(Hash) ? service.customvalue.new(cfield) : cfield }
           end
         end
 
         def initialize_scsi_controllers
           if attributes[:scsi_controllers] && attributes[:scsi_controllers].is_a?(Array)
-            self.attributes[:scsi_controllers].map! do |controller|
+            attributes[:scsi_controllers].map! do |controller|
               controller.is_a?(Hash) ? Fog::Compute::Vsphere::SCSIController.new(controller) : controller
             end
           elsif attributes[:scsi_controller] && attributes[:scsi_controller].is_a?(Hash)
-            self.attributes[:scsi_controllers] = [
-              Fog::Compute::Vsphere::SCSIController.new(self.attributes[:scsi_controller])
+            attributes[:scsi_controllers] = [
+              Fog::Compute::Vsphere::SCSIController.new(attributes[:scsi_controller])
             ]
           elsif attributes[:volumes] && attributes[:volumes].is_a?(Array) && !attributes[:volumes].empty?
             # Create a default scsi controller if there are any disks but no controller defined
-            self.attributes[:scsi_controllers] = [
+            attributes[:scsi_controllers] = [
               Fog::Compute::Vsphere::SCSIController.new
             ]
           end
         end
-
-        def attribute_changed?(attr)
-          self.attributes.select { |k, v| old.attributes[k] != v }.key?(attr)
-        end
-
-        def old
-          @old ||= self.dup.reload
-        end
       end
     end
   end