vmware_web_service 2.1.1 → 3.0.0

data/lib/VMwareWebService/MiqVimDump.rb

@@ -60,7 +60,7 @@ module MiqVimDump
 
   def indentedPrint(s, i)
     if @dumpToLog
-      $vim_log.debug @globalIndent + ("    " * i) + s.to_s
+      logger.debug @globalIndent + ("    " * i) + s.to_s
     else
       print @globalIndent + "    " * i
       puts s

data/lib/VMwareWebService/MiqVimEventHistoryCollector.rb

@@ -1,4 +1,8 @@
+require 'VMwareWebService/logging'
+
 class MiqVimEventHistoryCollector
+  include VMwareWebService::Logging
+
   attr_reader :invObj
 
   def initialize(invObj, eventFilterSpec = nil, pgSize = 20)
@@ -14,7 +18,7 @@ class MiqVimEventHistoryCollector
 
   def release
     return unless @eventHistoryCollector
-    $vim_log.info "MiqVimEventHistoryCollector.release: destroying #{@eventHistoryCollector}"
+    logger.info "MiqVimEventHistoryCollector.release: destroying #{@eventHistoryCollector}"
     @invObj.destroyCollector(@eventHistoryCollector)
     @eventHistoryCollector = nil
   end

data/lib/VMwareWebService/MiqVimEventMonitor.rb

@@ -1,15 +1,17 @@
-require 'enumerator'
+require 'VMwareWebService/logging'
 require 'VMwareWebService/MiqVimInventory'
 
 class MiqVimEventMonitor < MiqVimInventory
-  def initialize(server, username, password, eventFilterSpec = nil, pgSize = 100, maxWait = 60)
-    super(server, username, password, :cache_scope_event_monitor)
+  include VMwareWebService::Logging
 
-    @eventFilterSpec = eventFilterSpec || VimHash.new("EventFilterSpec")
-    @pgSize = pgSize
-    @maxWait = maxWait
-    @_monitorEvents = true
-    @emPropCol = nil
+  def initialize(server:, username:, password:, port: 443, ssl_options: {}, event_filter_spec: nil, page_size: 100, max_wait: 60)
+    super(:server => server, :port => port, :ssl_options => ssl_options, :username => username, :password => password, :cache_scope => :cache_scope_event_monitor)
+
+    @eventFilterSpec = event_filter_spec || VimHash.new("EventFilterSpec")
+    @pgSize          = page_size
+    @maxWait         = max_wait
+    @_monitorEvents  = true
+    @emPropCol       = nil
 
     hostSystemsByMor
     # datacentersByMor
@@ -73,25 +75,25 @@ class MiqVimEventMonitor < MiqVimInventory
             end
           rescue HTTPClient::ReceiveTimeoutError => terr
             retry if isAlive?
-            $vim_log.debug "MiqVimEventMonitor.monitorEvents: connection lost"
+            logger.debug "MiqVimEventMonitor.monitorEvents: connection lost"
             raise
           end
       rescue SignalException => err
       ensure
-        $vim_log.info "MiqVimEventMonitor: calling destroyPropertyFilter"
+        logger.info "MiqVimEventMonitor: calling destroyPropertyFilter"
         destroyPropertyFilter(filterSpecRef) if filterSpecRef
-        $vim_log.info "MiqVimEventMonitor: returned from destroyPropertyFilter"
+        logger.info "MiqVimEventMonitor: returned from destroyPropertyFilter"
         disconnect
       end
   end # def monitorEvents
 
   def stop
-    $vim_log.info "MiqVimEventMonitor stopping..."
+    logger.info "MiqVimEventMonitor stopping..."
     @_monitorEvents = false
     if @emPropCol
-      $vim_log.info "MiqVimEventMonitor: calling cancelWaitForUpdates"
+      logger.info "MiqVimEventMonitor: calling cancelWaitForUpdates"
       cancelWaitForUpdates(@emPropCol)
-      $vim_log.info "MiqVimEventMonitor: returned from cancelWaitForUpdates"
+      logger.info "MiqVimEventMonitor: returned from cancelWaitForUpdates"
     end
   end
 
@@ -100,14 +102,14 @@ class MiqVimEventMonitor < MiqVimInventory
 
   def fixupEvent(event)
     unless event.kind_of?(Hash)
-      $vim_log.error "MiqVimEventMonitor.fixupEvent: Expecting Hash, got #{event.class}"
+      logger.error "MiqVimEventMonitor.fixupEvent: Expecting Hash, got #{event.class}"
       if event.kind_of?(Array)
         event.each_index do |i|
-          $vim_log.error "MiqVimEventMonitor.fixupEvent: event[#{i}] is a #{event[i].class}"
-          $vim_log.error "\tMiqVimEventMonitor.fixupEvent: event[#{i}] = #{event[i].inspect}"
+          logger.error "MiqVimEventMonitor.fixupEvent: event[#{i}] is a #{event[i].class}"
+          logger.error "\tMiqVimEventMonitor.fixupEvent: event[#{i}] = #{event[i].inspect}"
         end
       else
-        $vim_log.error "\tMiqVimEventMonitor.fixupEvent: event = #{event.inspect}"
+        logger.error "\tMiqVimEventMonitor.fixupEvent: event = #{event.inspect}"
       end
       raise "MiqVimEventMonitor.fixupEvent: Expecting Hash, got #{event.class}"
     end
@@ -164,8 +166,8 @@ class MiqVimEventMonitor < MiqVimInventory
     begin
       cancelTask(String.new(e['info']['task'].to_str))
     rescue => err
-      $vim_log.error err.to_s
-      $vim_log.error err.backtrace.join("\n")
+      logger.error err.to_s
+      logger.error err.backtrace.join("\n")
     end
   end
 end # module MiqVimEventMonitor

data/lib/VMwareWebService/MiqVimFolder.rb

@@ -1,4 +1,8 @@
+require 'VMwareWebService/logging'
+
 class MiqVimFolder
+  include VMwareWebService::Logging
+
   attr_reader :name, :invObj
 
   def initialize(invObj, fh)
@@ -36,10 +40,10 @@ class MiqVimFolder
     hmor = (host.kind_of?(Hash) ? host['MOR'] : host) if host
     pmor = (pool.kind_of?(Hash) ? pool['MOR'] : pool) if pool
 
-    $vim_log.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).registerVM: calling registerVM_Task" if $vim_log
+    logger.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).registerVM: calling registerVM_Task"
     taskMor = @invObj.registerVM_Task(@fMor, path, name, asTemplate.to_s, pmor, hmor)
-    $vim_log.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).registerVM: returned from registerVM_Task" if $vim_log
-    $vim_log.debug "MiqVimFolder::registerVM: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).registerVM: returned from registerVM_Task"
+    logger.debug "MiqVimFolder::registerVM: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 
@@ -65,9 +69,9 @@ class MiqVimFolder
       cs.vmFolder       = ah[:vmFolder]       unless ah[:vmFolder].nil?
     end
 
-    $vim_log.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addStandaloneHost: calling addStandaloneHost_Task" if $vim_log
+    logger.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addStandaloneHost: calling addStandaloneHost_Task"
     taskMor = @invObj.addStandaloneHost_Task(@fMor, cspec, ah[:asConnected].to_s, ah[:license])
-    $vim_log.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addStandaloneHost: returned from addStandaloneHost_Task" if $vim_log
+    logger.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addStandaloneHost: returned from addStandaloneHost_Task"
     return taskMor unless ah[:wait]
     waitForTask(taskMor)
   end # def addStandaloneHost
@@ -77,10 +81,10 @@ class MiqVimFolder
     oMor = nil
     oMor = (vCenterObject.kind_of?(Hash) ? vCenterObject['MOR'] : vCenterObject) if vCenterObject
 
-    $vim_log.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).moveIntoFolder: calling moveIntoFolder_Task" if $vim_log
+    logger.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).moveIntoFolder: calling moveIntoFolder_Task"
     taskMor = @invObj.moveIntoFolder_Task(@fMor, oMor)
-    $vim_log.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).moveIntoFolder: returned from moveIntoFolder_Task" if $vim_log
-    $vim_log.debug "MiqVimFolder::moveIntoFolder: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).moveIntoFolder: returned from moveIntoFolder_Task"
+    logger.debug "MiqVimFolder::moveIntoFolder: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 
@@ -96,10 +100,10 @@ class MiqVimFolder
     hMor = (host.kind_of?(Hash) ? host['MOR'] : host) if host
     pMor = (pool.kind_of?(Hash) ? pool['MOR'] : pool) if pool
 
-    $vim_log.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).createVM calling createVM_Task" if $vim_log
+    logger.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).createVM calling createVM_Task"
     taskMor = @invObj.createVM_Task(@fMor, configSpec, pMor, hMor)
-    $vim_log.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).createVM returned from createVM_Task" if $vim_log
-    $vim_log.debug "MiqVimFolder::createVM: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimFolder(#{@invObj.server}, #{@invObj.username}).createVM returned from createVM_Task"
+    logger.debug "MiqVimFolder::createVM: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 

data/lib/VMwareWebService/MiqVimHost.rb

@@ -1,9 +1,9 @@
 require 'sync'
 
-require 'enumerator'
 require "ostruct"
 
 require 'more_core_extensions/core_ext/hash'
+require 'VMwareWebService/logging'
 require 'VMwareWebService/MiqHostDatastoreSystem'
 require 'VMwareWebService/MiqHostStorageSystem'
 require 'VMwareWebService/MiqHostFirewallSystem'
@@ -14,6 +14,8 @@ require 'VMwareWebService/MiqHostAdvancedOptionManager'
 require 'VMwareWebService/MiqHostSnmpSystem'
 
 class MiqVimHost
+  include VMwareWebService::Logging
+
   attr_reader :name, :invObj
 
   def initialize(invObj, hh)
@@ -108,49 +110,49 @@ class MiqVimHost
   end
 
   def enterMaintenanceMode(timeout = 0, evacuatePoweredOffVms = false, wait = true)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).enterMaintenanceMode: calling enterMaintenanceMode_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).enterMaintenanceMode: calling enterMaintenanceMode_Task"
     taskMor = @invObj.enterMaintenanceMode_Task(@hMor, timeout, evacuatePoweredOffVms)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).enterMaintenanceMode: returned from enterMaintenanceMode_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).enterMaintenanceMode: returned from enterMaintenanceMode_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def exitMaintenanceMode(timeout = 0, wait = true)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).exitMaintenanceMode: calling exitMaintenanceMode_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).exitMaintenanceMode: calling exitMaintenanceMode_Task"
     taskMor = @invObj.exitMaintenanceMode_Task(@hMor, timeout)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).exitMaintenanceMode: returned from exitMaintenanceMode_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).exitMaintenanceMode: returned from exitMaintenanceMode_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def powerDownHostToStandBy(timeout = 0, evacuatePoweredOffVms = false, wait = true)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerDownHostToStandBy: calling powerDownHostToStandBy_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerDownHostToStandBy: calling powerDownHostToStandBy_Task"
     taskMor = @invObj.powerDownHostToStandBy_Task(@hMor, timeout, evacuatePoweredOffVms)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerDownHostToStandBy: returned from powerDownHostToStandBy_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerDownHostToStandBy: returned from powerDownHostToStandBy_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def powerUpHostFromStandBy(timeout = 0, wait = true)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerUpHostFromStandBy: calling powerUpHostFromStandBy_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerUpHostFromStandBy: calling powerUpHostFromStandBy_Task"
     taskMor = @invObj.powerUpHostFromStandBy_Task(@hMor, timeout)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerUpHostFromStandBy: returned from powerUpHostFromStandBy_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).powerUpHostFromStandBy: returned from powerUpHostFromStandBy_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def rebootHost(force = false, wait = true)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).rebootHost: calling rebootHost_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).rebootHost: calling rebootHost_Task"
     taskMor = @invObj.rebootHost_Task(@hMor, force)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).rebootHost: returned from rebootHost_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).rebootHost: returned from rebootHost_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def shutdownHost(force = false, wait = true)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).shutdownHost: calling shutdownHost_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).shutdownHost: calling shutdownHost_Task"
     taskMor = @invObj.shutdownHost_Task(@hMor, force)
-    $vim_log.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).shutdownHost: returned from shutdownHost_Task" if $vim_log
+    logger.info "MiqVimHost(#{@invObj.server}, #{@invObj.username}).shutdownHost: returned from shutdownHost_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end

data/lib/VMwareWebService/MiqVimInventory.rb

@@ -1,5 +1,4 @@
 require 'sync'
-require 'enumerator'
 require 'VMwareWebService/MiqVimClientBase'
 require 'VMwareWebService/MiqVimDump'
 require 'VMwareWebService/VimPropMaps'
@@ -18,31 +17,31 @@ class MiqVimInventory < MiqVimClientBase
   @@selectorHash = {}
   @@cacheScope   = :cache_scope_full
 
-  def initialize(server, username, password, cacheScope = nil)
-    super(server, username, password)
+  def initialize(server:, username:, password:, port: 443, ssl_options: {}, cache_scope: nil)
+    super(:server => server, :port => port, :ssl_options => ssl_options, :username => username, :password => password)
 
-    cacheScope ||= @@cacheScope
+    cache_scope ||= @@cacheScope
 
-    case cacheScope
+    case cache_scope
     when :cache_scope_full
       @propMap = FullPropMap
-      $vim_log.info "MiqVimInventory: using property map FullPropMap"
+      logger.info "MiqVimInventory: using property map FullPropMap"
     when :cache_scope_ems_refresh
       @propMap = EmsRefreshPropMap
-      $vim_log.info "MiqVimInventory: using property map EmsRefreshPropMap"
+      logger.info "MiqVimInventory: using property map EmsRefreshPropMap"
     when :cache_scope_core
       @propMap = CorePropMap
-      $vim_log.info "MiqVimInventory: using property map CorePropMap"
+      logger.info "MiqVimInventory: using property map CorePropMap"
     when :cache_scope_event_monitor
       @propMap = EventMonitorPropMap
-      $vim_log.info "MiqVimInventory: using property map EventMonitorPropMap"
+      logger.info "MiqVimInventory: using property map EventMonitorPropMap"
     else
       @propMap = FullPropMap
-      $vim_log.info "MiqVimInventory: unrecognized cache scope #{cacheScope}, using FullPropMap"
+      logger.info "MiqVimInventory: unrecognized cache scope #{cacheScope}, using FullPropMap"
     end
 
     # If we are connected to a virtual center then we can access additional properties
-    @propMap.merge!(PropMapVCenter) if isVirtualCenter && cacheScope != :cache_scope_event_monitor
+    @propMap.merge!(PropMapVCenter) if isVirtualCenter && cache_scope != :cache_scope_event_monitor
 
     @propCol    = @sic.propertyCollector
     @rootFolder = @sic.rootFolder
@@ -88,11 +87,11 @@ class MiqVimInventory < MiqVimClientBase
 
         unless instance_variable_get(hnm).nil?
           hnmc = instance_variable_get(hnm).keys.length
-          $vim_log.info "#{pref}#{hnm}: #{hnmc}"
+          logger.info "#{pref}#{hnm}: #{hnmc}"
         end
         unless instance_variable_get(hn).nil?
           hnc = instance_variable_get(hn).keys.length
-          $vim_log.info "#{pref}#{hn}: #{hnc}"
+          logger.info "#{pref}#{hn}: #{hnc}"
         end
       end
     end
@@ -108,37 +107,37 @@ class MiqVimInventory < MiqVimClientBase
         hashByKey = pm[:keyPath] ? instance_variable_get(hn) : nil
 
         if hashByMor.nil?
-          $vim_log.info "#{pref}#{hnm}: is nil"
+          logger.info "#{pref}#{hnm}: is nil"
           next
         end
 
         keya = hashByMor.keys
         obja = hashByMor.values
-        $vim_log.info "#{pref}#{hnm}: #keys = #{keya.length}"
-        $vim_log.info "#{pref}#{hnm}: #objects = #{obja.length}"
+        logger.info "#{pref}#{hnm}: #keys = #{keya.length}"
+        logger.info "#{pref}#{hnm}: #objects = #{obja.length}"
         obja.compact!
         obja.uniq!
-        $vim_log.info "#{pref}#{hnm}: #unique non-nill objects = #{obja.length}"
+        logger.info "#{pref}#{hnm}: #unique non-nill objects = #{obja.length}"
 
         unless hashByKey.nil?
           keyb = hashByKey.keys
           objb = hashByKey.values
-          $vim_log.info "#{pref}#{hn}: #keys = #{keyb.length}"
-          $vim_log.info "#{pref}#{hn}: #objects = #{objb.length}"
+          logger.info "#{pref}#{hn}: #keys = #{keyb.length}"
+          logger.info "#{pref}#{hn}: #objects = #{objb.length}"
           objb.compact!
           objb.uniq!
-          $vim_log.info "#{pref}#{hn}: #unique non-nill objects = #{objb.length}"
+          logger.info "#{pref}#{hn}: #unique non-nill objects = #{objb.length}"
           obja.concat(objb).uniq!
         end
-        $vim_log.info "#{pref}TOTAL: #unique non-nill objects = #{obja.length}"
+        logger.info "#{pref}TOTAL: #unique non-nill objects = #{obja.length}"
         cacheSz = Marshal.dump(obja).length
-        $vim_log.info "#{pref}TOTAL: size of objects = #{cacheSz}"
-        $vim_log.info "#{pref}****"
+        logger.info "#{pref}TOTAL: size of objects = #{cacheSz}"
+        logger.info "#{pref}****"
         totalCacheSz += cacheSz
       end
-      $vim_log.info "#{pref}****************"
-      $vim_log.info "#{pref}TOTAL: cache size = #{totalCacheSz}"
-      $vim_log.info "#{pref}****************"
+      logger.info "#{pref}****************"
+      logger.info "#{pref}TOTAL: cache size = #{totalCacheSz}"
+      logger.info "#{pref}****************"
     end
     totalCacheSz
   end
@@ -219,7 +218,7 @@ class MiqVimInventory < MiqVimClientBase
   end
 
   def resetCache
-    $vim_log.info "MiqVimInventory.resetCache: clearing cache for #{@connId}"
+    logger.info "MiqVimInventory.resetCache: clearing cache for #{@connId}"
     @cacheLock.synchronize(:EX) do
       @inventoryHash = nil
 
@@ -228,7 +227,7 @@ class MiqVimInventory < MiqVimClientBase
         instance_variable_set(pm[:baseName], nil)
       end
     end
-    $vim_log.info "MiqVimInventory.resetCache: cleared cache for #{@connId}"
+    logger.info "MiqVimInventory.resetCache: cleared cache for #{@connId}"
   end # def resetCache
 
   def currentSession
@@ -239,11 +238,11 @@ class MiqVimInventory < MiqVimClientBase
     return false unless @alive
     begin
         unless currentSession
-          $vim_log.info "MiqVimInventory.isAlive?: Current session no longer exists."
+          logger.info "MiqVimInventory.isAlive?: Current session no longer exists."
           @alive = false
         end
       rescue Exception => err
-        $vim_log.info "MiqVimInventory.isAlive?: Could not access connection - #{err}"
+        logger.info "MiqVimInventory.isAlive?: Could not access connection - #{err}"
         @alive = false
       end
     @alive
@@ -278,9 +277,9 @@ class MiqVimInventory < MiqVimClientBase
     if keyPath
       key = props.fetch_path(keyPath)
       if !key
-        $vim_log.debug "hashObj: key is nil for #{mor}: #{keyPath}"
+        logger.debug "hashObj: key is nil for #{mor}: #{keyPath}"
       elsif key.empty?
-        $vim_log.debug "hashObj: key is empty for #{mor}: #{keyPath}"
+        logger.debug "hashObj: key is empty for #{mor}: #{keyPath}"
         key = nil
         props.store_path(keyPath, nil)
       end
@@ -491,7 +490,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "virtualMachines_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@virtualMachines) if @virtualMachines
 
-    $vim_log.info "MiqVimInventory.virtualMachines_locked: loading VirtualMachine cache for #{@connId}"
+    logger.info "MiqVimInventory.virtualMachines_locked: loading VirtualMachine cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -505,7 +504,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.virtualMachines_locked: loaded VirtualMachine cache for #{@connId}"
+    logger.info "MiqVimInventory.virtualMachines_locked: loaded VirtualMachine cache for #{@connId}"
 
     @virtualMachines
   end # def virtualMachines_locked
@@ -617,7 +616,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "computeResources_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@computeResources) if @computeResources
 
-    $vim_log.info "MiqVimInventory.computeResources_locked: loading ComputeResource cache for #{@connId}"
+    logger.info "MiqVimInventory.computeResources_locked: loading ComputeResource cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -631,7 +630,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.computeResources_locked: loaded ComputeResource cache for #{@connId}"
+    logger.info "MiqVimInventory.computeResources_locked: loaded ComputeResource cache for #{@connId}"
 
     @computeResources
   end # def computeResources_locked
@@ -720,7 +719,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "clusterComputeResources_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@clusterComputeResources) if @clusterComputeResources
 
-    $vim_log.info "MiqVimInventory.clusterComputeResources_locked: loading ClusterComputeResource cache for #{@connId}"
+    logger.info "MiqVimInventory.clusterComputeResources_locked: loading ClusterComputeResource cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -734,7 +733,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.clusterComputeResources_locked: loaded ClusterComputeResource cache for #{@connId}"
+    logger.info "MiqVimInventory.clusterComputeResources_locked: loaded ClusterComputeResource cache for #{@connId}"
 
     @clusterComputeResources
   end # def clusterComputeResources_locked
@@ -823,7 +822,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "resourcePools_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@resourcePools) if @resourcePools
 
-    $vim_log.info "MiqVimInventory.resourcePools_locked: loading ResourcePool cache for #{@connId}"
+    logger.info "MiqVimInventory.resourcePools_locked: loading ResourcePool cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -837,7 +836,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.resourcePools_locked: loaded ResourcePool cache for #{@connId}"
+    logger.info "MiqVimInventory.resourcePools_locked: loaded ResourcePool cache for #{@connId}"
 
     @resourcePools
   end # def resourcePools_locked
@@ -935,7 +934,7 @@ class MiqVimInventory < MiqVimClientBase
 
     return(@virtualApps) if @virtualApps
 
-    $vim_log.info "MiqVimInventory.virtualApps_locked: loading VirtualApp cache for #{@connId}"
+    logger.info "MiqVimInventory.virtualApps_locked: loading VirtualApp cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -949,7 +948,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.virtualApps_locked: loaded VirtualApp cache for #{@connId}"
+    logger.info "MiqVimInventory.virtualApps_locked: loaded VirtualApp cache for #{@connId}"
 
     @virtualApps
   end # def virtualApps_locked
@@ -1038,7 +1037,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "folders_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@folders) if @folders
 
-    $vim_log.info "MiqVimInventory.folders_locked: loading Folder cache for #{@connId}"
+    logger.info "MiqVimInventory.folders_locked: loading Folder cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1052,7 +1051,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.folders_locked: loaded Folder cache for #{@connId}"
+    logger.info "MiqVimInventory.folders_locked: loaded Folder cache for #{@connId}"
 
     @folders
   end # def folders_locked
@@ -1141,7 +1140,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "datacenters_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@datacenters) if @datacenters
 
-    $vim_log.info "MiqVimInventory.datacenters_locked: loading Datacenter cache for #{@connId}"
+    logger.info "MiqVimInventory.datacenters_locked: loading Datacenter cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1155,7 +1154,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.datacenters_locked: loaded Datacenter cache for #{@connId}"
+    logger.info "MiqVimInventory.datacenters_locked: loaded Datacenter cache for #{@connId}"
 
     @datacenters
   end # def datacenters_locked
@@ -1244,7 +1243,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "hostSystems_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@hostSystems) if @hostSystems
 
-    $vim_log.info "MiqVimInventory.hostSystems_locked: loading HostSystem cache for #{@connId}"
+    logger.info "MiqVimInventory.hostSystems_locked: loading HostSystem cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1258,7 +1257,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.hostSystems_locked: loaded HostSystem cache for #{@connId}"
+    logger.info "MiqVimInventory.hostSystems_locked: loaded HostSystem cache for #{@connId}"
 
     @hostSystems
   end # def hostSystems_locked
@@ -1369,7 +1368,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "dataStores_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@dataStores) if @dataStores
 
-    $vim_log.info "MiqVimInventory.dataStores_locked: loading Datastore cache for #{@connId}"
+    logger.info "MiqVimInventory.dataStores_locked: loading Datastore cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1383,7 +1382,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.dataStores_locked: loaded Datastore cache for #{@connId}"
+    logger.info "MiqVimInventory.dataStores_locked: loaded Datastore cache for #{@connId}"
 
     @dataStores
   end # def dataStores_locked
@@ -1488,7 +1487,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "dvPortgroups_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@dvPortgroups) if @dvPortgroups
 
-    $vim_log.info "MiqVimInventory.dvPortgroups_locked: loading DV Portgroup cache for #{@connId}"
+    logger.info "MiqVimInventory.dvPortgroups_locked: loading DV Portgroup cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1502,7 +1501,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.dvPortgroups_locked: loaded DV Portgroup cache for #{@connId}"
+    logger.info "MiqVimInventory.dvPortgroups_locked: loaded DV Portgroup cache for #{@connId}"
 
     @dvPortgroups
   end # def dvPortgroups_locked
@@ -1576,7 +1575,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "dvSwitches_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@dvSwithces) if @dvSwitches
 
-    $vim_log.info "MiqVimInventory.dvSwitches_locked: loading DV Switch cache for #{@connId}"
+    logger.info "MiqVimInventory.dvSwitches_locked: loading DV Switch cache for #{@connId}"
 
     base_class    = 'DistributedVirtualSwitch'.freeze
     child_classes = VimClass.child_classes(base_class)
@@ -1596,7 +1595,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.dvSwitches_locked: loaded DV Switch cache for #{@connId}"
+    logger.info "MiqVimInventory.dvSwitches_locked: loaded DV Switch cache for #{@connId}"
 
     @dvSwitches
   end # def dvSwitches_locked
@@ -1669,7 +1668,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "storagePods_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@storagePods) if @storagePods
 
-    $vim_log.info "MiqVimInventory.storagePods_locked: loading Datastore Cluster cache for #{@connId}"
+    logger.info "MiqVimInventory.storagePods_locked: loading Datastore Cluster cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1683,7 +1682,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.storagePods_locked: loaded Datastore Cluster cache for #{@connId}"
+    logger.info "MiqVimInventory.storagePods_locked: loaded Datastore Cluster cache for #{@connId}"
 
     @storagePods
   end # def storagePods_locked
@@ -1761,7 +1760,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "licenseManagers_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@licenseManagers) if @licenseManagers
 
-    $vim_log.info "MiqVimInventory.licenseManagers_locked: loading LicenseManager cache for #{@connId}"
+    logger.info "MiqVimInventory.licenseManagers_locked: loading LicenseManager cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1775,7 +1774,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.licenseManagers_locked: loaded LicenseManager cache for #{@connId}"
+    logger.info "MiqVimInventory.licenseManagers_locked: loaded LicenseManager cache for #{@connId}"
 
     @licenseManagers
   end # def licenseManagers_locked
@@ -1871,7 +1870,7 @@ class MiqVimInventory < MiqVimClientBase
     raise "extensionManagers_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@extensionManagers) if @extensionManagers
 
-    $vim_log.info "MiqVimInventory.extensionManagers_locked: loading ExtensionManager cache for #{@connId}"
+    logger.info "MiqVimInventory.extensionManagers_locked: loading ExtensionManager cache for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
@@ -1885,7 +1884,7 @@ class MiqVimInventory < MiqVimClientBase
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.extensionManagers_locked: loaded ExtensionManager cache for #{@connId}"
+    logger.info "MiqVimInventory.extensionManagers_locked: loaded ExtensionManager cache for #{@connId}"
 
     @extensionManagers
   end # def extensionManagers_locked
@@ -1977,22 +1976,22 @@ class MiqVimInventory < MiqVimClientBase
     raise "inventoryHash_locked: cache lock not held" unless @cacheLock.sync_locked?
     return(@inventoryHash) if @inventoryHash
 
-    $vim_log.info "MiqVimInventory.inventoryHash_locked: loading inventoryHash for #{@connId}"
+    logger.info "MiqVimInventory.inventoryHash_locked: loading inventoryHash for #{@connId}"
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
-      $vim_log.info "MiqVimInventory(#{@server}, #{@username}).inventoryHash_locked: calling retrieveProperties" if $vim_log
+      logger.info "MiqVimInventory(#{@server}, #{@username}).inventoryHash_locked: calling retrieveProperties"
 
       @inventoryHash = {}
       retrievePropertiesIter(@propCol, @spec) do |oc|
         (@inventoryHash[oc.obj.vimType] ||= []) << oc.obj
       end
 
-      $vim_log.info "MiqVimInventory(#{@server}, #{@username}).inventoryHash_locked: returned from retrieveProperties" if $vim_log
+      logger.info "MiqVimInventory(#{@server}, #{@username}).inventoryHash_locked: returned from retrieveProperties"
     ensure
       @cacheLock.sync_unlock if unlock
     end
-    $vim_log.info "MiqVimInventory.inventoryHash_locked: loaded inventoryHash for #{@connId}"
+    logger.info "MiqVimInventory.inventoryHash_locked: loaded inventoryHash for #{@connId}"
 
     @inventoryHash
   end
@@ -2009,9 +2008,9 @@ class MiqVimInventory < MiqVimClientBase
   # Generate a user event associated with the given managed object.
   #
   def logUserEvent(entity, msg)
-    $vim_log.info "MiqVimInventory(#{@server}, #{@username}).logUserEvent: calling logUserEvent" if $vim_log
+    logger.info "MiqVimInventory(#{@server}, #{@username}).logUserEvent: calling logUserEvent"
     super(@sic.eventManager, entity, msg)
-    $vim_log.info "MiqVimInventory(#{@server}, #{@username}).logUserEvent: returned from logUserEvent" if $vim_log
+    logger.info "MiqVimInventory(#{@server}, #{@username}).logUserEvent: returned from logUserEvent"
   end
 
   ##################################
@@ -2184,13 +2183,13 @@ class MiqVimInventory < MiqVimClientBase
 
   def getTaskMor(tmor)
     if tmor.respond_to?(:vimType)
-      $vim_log.debug "getTaskMor: returning #{tmor}, no search"
+      logger.debug "getTaskMor: returning #{tmor}, no search"
       return tmor
     else
-      $vim_log.debug "getTaskMor: searching for task #{tmor}"
+      logger.debug "getTaskMor: searching for task #{tmor}"
       getTasks.each do |tmo|
         if tmo.to_str == tmor
-          $vim_log.debug "getTaskMor: returning #{tmo} (#{tmo.vimType})"
+          logger.debug "getTaskMor: returning #{tmo} (#{tmo.vimType})"
           return tmo
         end
       end
@@ -2205,7 +2204,7 @@ class MiqVimInventory < MiqVimClientBase
   def waitForTask(tmor, className = nil)
     className ||= self.class.to_s
 
-    $vim_log.info "#{className}(#{@server}, #{@username})::waitForTask(#{tmor})" if $vim_log
+    logger.info "#{className}(#{@server}, #{@username})::waitForTask(#{tmor})"
     args = VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
       pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
         pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
@@ -2241,14 +2240,14 @@ class MiqVimInventory < MiqVimClientBase
     end
 
     raise VimFault.new(error) if state == TaskInfoState::Error
-    $vim_log.info "#{className}(#{@server}, #{@username})::waitForTask: result = #{result}" if $vim_log
+    logger.info "#{className}(#{@server}, #{@username})::waitForTask: result = #{result}"
     result
   end # def waitForTask
 
   def pollTask(tmor, className = nil)
     className ||= self.class.to_s
 
-    $vim_log.info "#{className}(#{@server}, #{@username})::pollTask(#{tmor})" if $vim_log
+    logger.info "#{className}(#{@server}, #{@username})::pollTask(#{tmor})"
     args = VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
       pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
         pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
@@ -2324,9 +2323,9 @@ class MiqVimInventory < MiqVimClientBase
       end
     end
 
-    $vim_log.info "MiqVimInventory(#{@server}, #{@username}).getMoProp_local: calling retrieveProperties(#{mo.vimType})" if $vim_log
+    logger.info "MiqVimInventory(#{@server}, #{@username}).getMoProp_local: calling retrieveProperties(#{mo.vimType})"
     oca = retrievePropertiesCompat(@propCol, pfSpec)
-    $vim_log.info "MiqVimInventory(#{@server}, #{@username}).getMoProp_local: return from retrieveProperties(#{mo.vimType})" if $vim_log
+    logger.info "MiqVimInventory(#{@server}, #{@username}).getMoProp_local: return from retrieveProperties(#{mo.vimType})"
 
     return nil if !oca || !oca[0] || !oca[0].propSet
 
@@ -2442,9 +2441,9 @@ class MiqVimInventory < MiqVimClientBase
   end
 
   def self.setSelector(selSpec)
-    raise "MiqVimBroker.setSelector: selSpec must be a hash, received #{selSpec.class}" unless selSpec.kind_of?(Hash)
+    raise "MiqVimInventory.setSelector: selSpec must be a hash, received #{selSpec.class}" unless selSpec.kind_of?(Hash)
     selSpec.each_key do |k|
-      raise "MiqVimBroker.setSelector: selSpec keys must be symbols, received #{k.class}" unless k.kind_of?(Symbol)
+      raise "MiqVimInventory.setSelector: selSpec keys must be symbols, received #{k.class}" unless k.kind_of?(Symbol)
     end
     ov = nil
     selSpec.each_value do |v|
@@ -2458,7 +2457,7 @@ class MiqVimInventory < MiqVimClientBase
       else
         ov = v unless v.kind_of?(String)
       end
-      raise "MiqVimBroker.setSelector: selSpec values must be strings or arrays of strings, received #{ov.class}" unless ov.nil?
+      raise "MiqVimInventory.setSelector: selSpec values must be strings or arrays of strings, received #{ov.class}" unless ov.nil?
     end
     @@selectorHash.merge!(selSpec)
   end
@@ -2472,10 +2471,10 @@ class MiqVimInventory < MiqVimClientBase
     elsif selName.kind_of?(Array)
       remKeys = selName
     else
-      raise "MiqVimBroker.removeSelector: selName must be a symbol, hash or array, received #{selName.class}"
+      raise "MiqVimInventory.removeSelector: selName must be a symbol, hash or array, received #{selName.class}"
     end
     remKeys.each do |rk|
-      raise "MiqVimBroker.removeSelector: keys must be symbols, received #{rk.class}" unless rk.kind_of?(Symbol)
+      raise "MiqVimInventory.removeSelector: keys must be symbols, received #{rk.class}" unless rk.kind_of?(Symbol)
     end
 
     remKeys.each do |rk|