vmware_web_service 2.0.3 → 3.1.0

data/lib/VMwareWebService/MiqVimVm.rb

@@ -1,17 +1,18 @@
 require 'sync'
 
-require 'enumerator'
 require "ostruct"
 
 require 'more_core_extensions/core_ext/hash'
 require 'active_support/core_ext/object/try'
 
 require 'VMwareWebService/exception'
+require 'VMwareWebService/logging'
 require 'VMwareWebService/MiqVimVdlMod'
 require 'VMwareWebService/esx_thumb_print'
 require 'VMwareWebService/vcenter_thumb_print'
 
 class MiqVimVm
+  include VMwareWebService::Logging
   include MiqVimVdlVcConnectionMod
 
   EVM_SNAPSHOT_NAME         = "EvmSnapshot".freeze # TODO: externalize - not VIM specific
@@ -92,53 +93,53 @@ class MiqVimVm
   #######################
 
   def start(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: calling powerOnVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: calling powerOnVM_Task"
     taskMor = @invObj.powerOnVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: returned from powerOnVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).start: returned from powerOnVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def start
 
   def stop(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: calling powerOffVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: calling powerOffVM_Task"
     taskMor = @invObj.powerOffVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: returned from powerOffVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).stop: returned from powerOffVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def stop
 
   def suspend(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: calling suspendVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: calling suspendVM_Task"
     taskMor = @invObj.suspendVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: returned from suspendVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).suspend: returned from suspendVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def suspend
 
   def reset(wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: calling resetVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: calling resetVM_Task"
     taskMor = @invObj.resetVM_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: returned from resetVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reset: returned from resetVM_Task"
     return taskMor unless wait
     waitForTask(taskMor)
   end
 
   def rebootGuest
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: calling rebootGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: calling rebootGuest"
     @invObj.rebootGuest(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: returned from rebootGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).rebootGuest: returned from rebootGuest"
   end
 
   def shutdownGuest
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: calling shutdownGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: calling shutdownGuest"
     @invObj.shutdownGuest(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: returned from shutdownGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).shutdownGuest: returned from shutdownGuest"
   end
 
   def standbyGuest
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: calling standbyGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: calling standbyGuest"
     @invObj.standbyGuest(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: returned from standbyGuest" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).standbyGuest: returned from standbyGuest"
   end
 
   def powerState
@@ -168,18 +169,18 @@ class MiqVimVm
   ############################
 
   def markAsTemplate
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: calling markAsTemplate" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: calling markAsTemplate"
     @invObj.markAsTemplate(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: returned from markAsTemplate" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsTemplate: returned from markAsTemplate"
   end
 
   def markAsVm(pool, host = nil)
     hmor = nil
     hmor = (host.kind_of?(Hash) ? host['MOR'] : host) if host
     pmor = (pool.kind_of?(Hash) ? pool['MOR'] : pool)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: calling markAsVirtualMachine" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: calling markAsVirtualMachine"
     @invObj.markAsVirtualMachine(@vmMor, pmor, hmor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: returned from markAsVirtualMachine" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).markAsVm: returned from markAsVirtualMachine"
   end
 
   def template?
@@ -194,18 +195,18 @@ class MiqVimVm
     hmor = (host.kind_of?(Hash) ? host['MOR'] : host)
     pool = (pool.kind_of?(Hash) ? pool['MOR'] : pool) if pool
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: calling migrateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, priority=<#{priority.inspect}>, state=<#{state.inspect}>" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: calling migrateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, priority=<#{priority.inspect}>, state=<#{state.inspect}>"
     taskMor = @invObj.migrateVM_Task(@vmMor, pool, hmor, priority, state)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: returned from migrateVM_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::migrate: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).migrate: returned from migrateVM_Task"
+    logger.debug "MiqVimVm::migrate: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 
   def renameVM(newName)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: calling rename_Task, vm=<#{@vmMor.inspect}>, newName=<#{newName}>" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: calling rename_Task, vm=<#{@vmMor.inspect}>, newName=<#{newName}>"
     task_mor = @invObj.rename_Task(@vmMor, newName)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: returned from rename_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::renameVM: taskMor = #{task_mor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameVM: returned from rename_Task"
+    logger.debug "MiqVimVm::renameVM: taskMor = #{task_mor}"
     waitForTask(task_mor)
   end
 
@@ -223,26 +224,26 @@ class MiqVimVm
       rsl.transform    = transform      if transform
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: calling relocateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, datastore=<#{dsmor.inspect}>, priority=<#{priority.inspect}>" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: calling relocateVM_Task, vm=<#{@vmMor.inspect}>, host=<#{hmor.inspect}>, pool=<#{pool.inspect}>, datastore=<#{dsmor.inspect}>, priority=<#{priority.inspect}>"
     taskMor = @invObj.relocateVM_Task(@vmMor, rspec, priority)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: returned from relocateVM_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::relocate: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).relocate: returned from relocateVM_Task"
+    logger.debug "MiqVimVm::relocate: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end
 
   def cloneVM_raw(folder, name, spec, wait = true)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: calling cloneVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: calling cloneVM_Task"
     taskMor = @invObj.cloneVM_Task(@vmMor, folder, name, spec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: returned from cloneVM_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::cloneVM_raw: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).cloneVM_raw: returned from cloneVM_Task"
+    logger.debug "MiqVimVm::cloneVM_raw: taskMor = #{taskMor}"
 
     if wait
       rv = waitForTask(taskMor)
-      $vim_log.debug "MiqVimVm::cloneVM_raw: rv = #{rv}" if $vim_log
+      logger.debug "MiqVimVm::cloneVM_raw: rv = #{rv}"
       return rv
     end
 
-    $vim_log.debug "MiqVimVm::cloneVM_raw - no wait: taskMor = #{taskMor}" if $vim_log
+    logger.debug "MiqVimVm::cloneVM_raw - no wait: taskMor = #{taskMor}"
     taskMor
   end
 
@@ -288,15 +289,15 @@ class MiqVimVm
   # end
 
   def unregister
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: calling unregisterVM" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: calling unregisterVM"
     @invObj.unregisterVM(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: returned from unregisterVM" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).unregister: returned from unregisterVM"
   end
 
   def destroy
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: calling destroy_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: calling destroy_Task"
     taskMor = @invObj.destroy_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: returned from destroy_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).destroy: returned from destroy_Task"
     waitForTask(taskMor)
   end
 
@@ -378,33 +379,33 @@ class MiqVimVm
   end
 
   def createSnapshot(name, desc, memory, quiesce, wait = true, free_space_percent = 100)
-    $vim_log.debug "MiqVimVm::createSnapshot(#{name}, #{desc}, #{memory}, #{quiesce})" if $vim_log
+    logger.debug "MiqVimVm::createSnapshot(#{name}, #{desc}, #{memory}, #{quiesce})"
     cs = connectionState
     raise "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: VM is not connected, connectionState = #{cs}" if cs != "connected"
     snapshot_free_space_check('create', free_space_percent)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: calling createSnapshot_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: calling createSnapshot_Task"
     taskMor = @invObj.createSnapshot_Task(@vmMor, name, desc, memory, quiesce)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: returned from createSnapshot_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::createSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).createSnapshot: returned from createSnapshot_Task"
+    logger.debug "MiqVimVm::createSnapshot: taskMor = #{taskMor}"
 
     if wait
       snMor = waitForTask(taskMor)
-      $vim_log.warn "MiqVimVm::createSnapshot: snMor = #{snMor}" if $vim_log
+      logger.warn "MiqVimVm::createSnapshot: snMor = #{snMor}"
       return snMor
     end
 
-    $vim_log.debug "MiqVimVm::createSnapshot - no wait: taskMor = #{taskMor}" if $vim_log
+    logger.debug "MiqVimVm::createSnapshot - no wait: taskMor = #{taskMor}"
     taskMor
   end # def createSnapshot
 
   def removeSnapshot(snMor, subTree = "false", wait = true, free_space_percent = 100)
-    $vim_log.warn "MiqVimVm::removeSnapshot(#{snMor}, #{subTree})" if $vim_log
+    logger.warn "MiqVimVm::removeSnapshot(#{snMor}, #{subTree})"
     snMor = getSnapMor(snMor)
     snapshot_free_space_check('remove', free_space_percent)
-    $vim_log.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: calling removeSnapshot_Task: snMor [#{snMor}] subtree [#{subTree}]" if $vim_log
+    logger.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: calling removeSnapshot_Task: snMor [#{snMor}] subtree [#{subTree}]"
     taskMor = @invObj.removeSnapshot_Task(snMor, subTree)
-    $vim_log.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: returned from removeSnapshot_Task: snMor [#{snMor}]" if $vim_log
-    $vim_log.debug "MiqVimVm::removeSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.warn "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeSnapshot: returned from removeSnapshot_Task: snMor [#{snMor}]"
+    logger.debug "MiqVimVm::removeSnapshot: taskMor = #{taskMor}"
     return taskMor unless wait
     waitForTask(taskMor)
   end # def removeSnapshot
@@ -422,40 +423,40 @@ class MiqVimVm
   end # def removeSnapshotByDescription
 
   def removeAllSnapshots(free_space_percent = 100)
-    $vim_log.debug "MiqVimVm::removeAllSnapshots" if $vim_log
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: calling removeAllSnapshots_Task" if $vim_log
+    logger.debug "MiqVimVm::removeAllSnapshots"
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: calling removeAllSnapshots_Task"
     snapshot_free_space_check('remove_all', free_space_percent)
     taskMor = @invObj.removeAllSnapshots_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: returned from removeAllSnapshots_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::removeAllSnapshots: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeAllSnapshots: returned from removeAllSnapshots_Task"
+    logger.debug "MiqVimVm::removeAllSnapshots: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end # def removeAllSnapshots
 
   def revertToSnapshot(snMor)
-    $vim_log.debug "MiqVimVm::revertToSnapshot(#{snMor})" if $vim_log
+    logger.debug "MiqVimVm::revertToSnapshot(#{snMor})"
     snMor = getSnapMor(snMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: calling revertToSnapshot_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: calling revertToSnapshot_Task"
     taskMor = @invObj.revertToSnapshot_Task(snMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: returned from revertToSnapshot_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::revertToSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToSnapshot: returned from revertToSnapshot_Task"
+    logger.debug "MiqVimVm::revertToSnapshot: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end # def revertToSnapshot
 
   def revertToCurrentSnapshot
-    $vim_log.debug "MiqVimVm::revertToCurrentSnapshot" if $vim_log
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: calling revertToCurrentSnapshot_Task" if $vim_log
+    logger.debug "MiqVimVm::revertToCurrentSnapshot"
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: calling revertToCurrentSnapshot_Task"
     taskMor = @invObj.revertToCurrentSnapshot_Task(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: returned from revertToCurrentSnapshot_Task" if $vim_log
-    $vim_log.debug "MiqVimVm::revertToCurrentSnapshot: taskMor = #{taskMor}" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).revertToCurrentSnapshot: returned from revertToCurrentSnapshot_Task"
+    logger.debug "MiqVimVm::revertToCurrentSnapshot: taskMor = #{taskMor}"
     waitForTask(taskMor)
   end # def revertToCurrentSnapshot
 
   def renameSnapshot(snMor, name, desc)
-    $vim_log.debug "MiqVimVm::renameSnapshot(#{snMor}, #{name}, #{desc})" if $vim_log
+    logger.debug "MiqVimVm::renameSnapshot(#{snMor}, #{name}, #{desc})"
     snMor = getSnapMor(snMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: calling renameSnapshot" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: calling renameSnapshot"
     @invObj.renameSnapshot(snMor, name, desc)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: returned from renameSnapshot" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).renameSnapshot: returned from renameSnapshot"
   end # def renameSnapshot
 
   def snapshot_free_space_check(action, free_space_percent = 100)
@@ -509,13 +510,13 @@ class MiqVimVm
 
   def getSnapMor(snMor)
     unless snMor.respond_to?(:vimType)
-      $vim_log.debug "MiqVimVm::getSnapMor converting #{snMor} to MOR" if $vim_log
+      logger.debug "MiqVimVm::getSnapMor converting #{snMor} to MOR"
       @cacheLock.synchronize(:SH) do
         raise "getSnapMor: VM #{@dsPath} has no snapshots" unless (sni = snapshotInfo_locked(true))
         raise "getSnapMor: snapshot #{snMor} not found" unless (snObj = sni['ssMorHash'][snMor])
         snMor = snObj['snapshot']
       end
-      $vim_log.debug "MiqVimVm::getSnapMor new MOR: #{snMor}" if $vim_log
+      logger.debug "MiqVimVm::getSnapMor new MOR: #{snMor}"
     end
     (snMor)
   end # def getSnapMor
@@ -610,9 +611,9 @@ class MiqVimVm
   end # def getCfg
 
   def reconfig(vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).reconfig: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -631,9 +632,9 @@ class MiqVimVm
 
   def setMemory(memMB)
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") { |cs| cs.memoryMB = memMB }
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setMemory: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -643,9 +644,9 @@ class MiqVimVm
 
   def setNumCPUs(numCPUs)
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") { |cs| cs.numCPUs = numCPUs }
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setNumCPUs: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -667,9 +668,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).connectDevice: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end # def connectDevice
 
@@ -705,9 +706,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).attachIsoToCd: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -723,9 +724,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resetCd: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -803,9 +804,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addDisk: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end # def addDisk
 
@@ -820,8 +821,8 @@ class MiqVimVm
     raise "removeDiskByFile: false setting for deleteBacking not yet supported" if deleteBacking == false
     controllerKey, key = getDeviceKeysByBacking(backingFile)
     raise "removeDiskByFile: no virtual device associated with: #{backingFile}" unless key
-    $vim_log.debug "MiqVimVm::MiqVimVm: backingFile = #{backingFile}" if $vim_log
-    $vim_log.debug "MiqVimVm::MiqVimVm: controllerKey = #{controllerKey}, key = #{key}" if $vim_log
+    logger.debug "MiqVimVm::MiqVimVm: backingFile = #{backingFile}"
+    logger.debug "MiqVimVm::MiqVimVm: controllerKey = #{controllerKey}, key = #{key}"
 
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") do |vmcs|
       vmcs.deviceChange = VimArray.new("ArrayOfVirtualDeviceConfigSpec") do |vmcs_vca|
@@ -859,9 +860,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeDiskByFile: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end # def removeDiskByFile
 
@@ -869,7 +870,7 @@ class MiqVimVm
     disk = getDeviceByBacking(backingFile)
     raise "resizeDisk: no virtual device associated with: #{backingFile}" unless disk
     raise "resizeDisk: cannot reduce the size of a disk" unless newSizeInKb >= Integer(disk.capacityInKB)
-    $vim_log.debug "MiqVimVm::resizeDisk: backingFile = #{backingFile} current size = #{device.capacityInKB} newSize = #{newSizeInKb} KB" if $vim_log
+    logger.debug "MiqVimVm::resizeDisk: backingFile = #{backingFile} current size = #{device.capacityInKB} newSize = #{newSizeInKb} KB"
 
     vmConfigSpec = VimHash.new("VirtualMachineConfigSpec") do |vmcs|
       vmcs.deviceChange = VimArray.new("ArrayOfVirtualDeviceConfigSpec") do |vmcs_vca|
@@ -887,9 +888,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).resizeDisk: returned from reconfigVM_Task"
     waitForTask(taskMor)
   end
 
@@ -1041,9 +1042,9 @@ class MiqVimVm
       else
         aSpec = @miqAlarmSpecDisabled
       end
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: calling createAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: calling createAlarm"
       alarmMor = @invObj.createAlarm(alarmManager, @vmMor, aSpec)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: returned from createAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).addMiqAlarm_locked: returned from createAlarm"
       @miqAlarmMor = alarmMor
     ensure
       @cacheLock.sync_unlock if unlock
@@ -1074,9 +1075,9 @@ class MiqVimVm
     begin
       @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
 
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: calling getAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: calling getAlarm"
       alarms = @invObj.getAlarm(@sic.alarmManager, @vmMor)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: returned from getAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).getMiqAlarm_locked: returned from getAlarm"
       alarms.each do |aMor|
         ap = @invObj.getMoProp(aMor, "info.name")
         next unless ap['info']['name'][MIQ_ALARM_PFX]
@@ -1105,27 +1106,27 @@ class MiqVimVm
   def disableMiqAlarm
     @cacheLock.synchronize(:SH) do
       raise "disableMiqAlarm: MiqAlarm not configured for VM #{@dsPath}" unless (aMor = getMiqAlarm_locked)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: calling reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: calling reconfigureAlarm"
       @invObj.reconfigureAlarm(aMor, @miqAlarmSpecDisabled)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: returned from reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).disableMiqAlarm: returned from reconfigureAlarm"
     end
   end
 
   def enableMiqAlarm
     @cacheLock.synchronize(:SH) do
       raise "enableMiqAlarm: MiqAlarm not configured for VM #{@dsPath}" unless (aMor = getMiqAlarm_locked)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: calling reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: calling reconfigureAlarm"
       @invObj.reconfigureAlarm(aMor, @miqAlarmSpecEnabled)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: returned from reconfigureAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).enableMiqAlarm: returned from reconfigureAlarm"
     end
   end
 
   def removeMiqAlarm
     @cacheLock.synchronize(:SH) do
       return unless (aMor = getMiqAlarm_locked)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: calling removeAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: calling removeAlarm"
       @invObj.removeAlarm(aMor)
-      $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: returned from removeAlarm" if $vim_log
+      logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).removeMiqAlarm: returned from removeAlarm"
       @miqAlarmMor = nil
     end
   end
@@ -1177,9 +1178,9 @@ class MiqVimVm
       end
     end
 
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: calling reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: calling reconfigVM_Task"
     taskMor = @invObj.reconfigVM_Task(@vmMor, vmConfigSpec)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: returned from reconfigVM_Task" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).setExtraConfigAttributes: returned from reconfigVM_Task"
     waitForTask(taskMor)
 
     @extraConfig = nil
@@ -1287,16 +1288,16 @@ class MiqVimVm
   end
 
   def acquireMksTicket
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: calling acquireMksTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: calling acquireMksTicket"
     rv = @invObj.acquireMksTicket(@vmMor)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: returned from acquireMksTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireMksTicket: returned from acquireMksTicket"
     (rv)
   end # def acquireMksTicket
 
   def acquireTicket(ticketType)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: calling acquireTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: calling acquireTicket"
     rv = @invObj.acquireTicket(@vmMor, ticketType)
-    $vim_log.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: returned from acquireTicket" if $vim_log
+    logger.info "MiqVimVm(#{@invObj.server}, #{@invObj.username}).acquireTicket: returned from acquireTicket"
     (rv)
   end # def acquireTicket
 

data/lib/VMwareWebService/VimService.rb

@@ -1,8 +1,11 @@
 require "handsoap"
 require 'active_support/core_ext/numeric/bytes'
+require 'VMwareWebService/logging'
 require 'VMwareWebService/VimTypes'
 
 class VimService < Handsoap::Service
+  include VMwareWebService::Logging
+
   attr_reader :sic, :about, :apiVersion, :isVirtualCenter, :v20, :v2, :v4, :v5, :v6, :serviceInstanceMor, :session_cookie
 
   Handsoap.http_driver = :HTTPClient
@@ -1291,14 +1294,14 @@ class VimService < Handsoap::Service
       if @xml_payload_len > @xml_payload_max
         @xml_payload_len = 0
 
-        $vim_log.debug("#{log_prefix} Running garbage collection")
+        logger.debug("#{log_prefix} Running garbage collection")
 
         # Force a GC, because Ruby's GC is triggered on number of objects without
         #   regard to size.  The object we just freed may not be released right away.
         gc_time = Benchmark.realtime { GC.start }
 
         gc_log_level = gc_time >= 5 ? :warn : :debug
-        $vim_log.send(gc_log_level, "#{log_prefix} Garbage collection took #{gc_time} seconds")
+        logger.send(gc_log_level, "#{log_prefix} Garbage collection took #{gc_time} seconds")
       end
     end
   end

data/lib/VMwareWebService/VixDiskLib/VixDiskLib.rb

@@ -2,6 +2,8 @@ require 'drb/drb'
 require 'sync'
 require 'ffi-vix_disk_lib/const'
 require 'ffi-vix_disk_lib/enum'
+require 'VMwareWebService/logging'
+
 #
 # The path to the VixDiskLib directory to be added to the process' LD_LIBRARY_PATH
 #
@@ -17,6 +19,8 @@ end
 SERVER_PATH = File.expand_path(__dir__)
 
 class VixDiskLib
+  include VMwareWebService::Logging
+
   VIXDISKLIB_FLAG_OPEN_READ_ONLY = FFI::VixDiskLib::API::VIXDISKLIB_FLAG_OPEN_READ_ONLY
   @initialized = nil
   @drb_services = []
@@ -66,12 +70,12 @@ class VixDiskLib
       i = 0
       @drb_services.each do |vdl_service|
         i += 1
-        $vim_log.info "VixDiskLib.exit: shutting down service #{i} of #{@drb_services.size}" if $vim_log
+        logger.info "VixDiskLib.exit: shutting down service #{i} of #{@drb_services.size}"
         unless vdl_service.nil?
           begin
             vdl_service.shutdown = true
           rescue DRb::DRbConnError
-            $vim_log.info "VixDiskLib.exit: DRb connection closed due to service shutdown.  Continuing" if $vim_log
+            logger.info "VixDiskLib.exit: DRb connection closed due to service shutdown.  Continuing"
           end
         end
       end
@@ -95,8 +99,9 @@ class VixDiskLib
     end
 
     my_env["LD_LIBRARY_PATH"] = (my_env["LD_LIBRARY_PATH"].to_s.split(':') << VIXDISKLIB_PATH).compact.join(":")
-    raise VixDiskLibError, "VixDiskLib.connect() failed: No $vim_log defined" unless $vim_log
-    my_env["LOG_FILE"] = $vim_log.logdev.filename.to_s
+    raise VixDiskLibError, "VixDiskLib.connect() failed: No logger defined" unless logger
+    my_env["LOG_FILE"] = logger.logdev.filename.to_s if logger.logdev.kind_of?(Logger::LogDevice)
+
     my_env
   end
 
@@ -109,16 +114,19 @@ class VixDiskLib
     proc_reader, @proc_writer = IO.pipe
 
     server_cmd = "ruby #{SERVER_PATH}/VixDiskLibServer.rb"
-    $vim_log.info "VixDiskLib.start_service: running command = #{server_cmd}"
+    log_target = my_env["LOG_FILE"] ? [my_env["LOG_FILE"], "a"] : $stdout
+
+    logger.info "VixDiskLib.start_service: running command = #{server_cmd}"
+
     pid = Kernel.spawn(my_env, server_cmd,
-                       [:out, :err]     => [my_env["LOG_FILE"], "a"],
+                       [:out, :err]     => log_target,
                        :unsetenv_others => true,
                        3                => uri_writer,
                        4                => proc_reader)
     uri_writer.close
     proc_reader.close
     Process.detach(pid)
-    $vim_log.info "VixDiskLibServer Process #{pid} started" if $vim_log
+    logger.info "VixDiskLibServer Process #{pid} started"
     DRb.start_service
     retry_num = 5
     uri       = get_uri(uri_reader)