vmware_web_service 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77fcee14b8adf4ff299e6f703078e3d2bbf62aba13be17e4a6253a010cae18f1
-  data.tar.gz: 86972a49c90161ae859753f7470e4e415b336e1178a554036aac0f24362588f2
+  metadata.gz: 1288852b072deb0fafe3ad1283dc4f82937da979aafdb8408a4f2938e93525bb
+  data.tar.gz: 980e17603b753629a0dfbffa4c7c9141b347da64492e39400bb4feca1c129bda
 SHA512:
-  metadata.gz: eb2c3b6c7e80fed7f4b5d2cc63d4556103ffd0a6b57442896b0edc262601de38e0ab394bf2d75b1a2bc7e67788f766d4864668d47ad1c1d3001bcd0395db135d
-  data.tar.gz: def519ee4ed00ad05cb3590f7decddbf90a5e8b408b3df34223685a27cb3387675120a210ae5c1e58135a6c1609bb022ad56428a816ef81df6f1190437a91962
+  metadata.gz: 4fa9b4c773f5868376fd9d1d816146c614d4ecd6f05bcdc17db918df45cdb39a07cea91cc329db3d7601dece163d63b63bb14820bd8ad1fa1415849df05a0a5d
+  data.tar.gz: 15156757e0bdfecd73a1199eb0d7fbc6f514c61f7c530a2528a21608ae34fce966badbe9e2b6141e4ff7d16a60c0dc86e0f7e27f9fbc878e697cb3094ffe047f

data/lib/VMwareWebService/MiqHostDatastoreSystem.rb

@@ -1,4 +1,8 @@
+require 'VMwareWebService/logging'
+
 class MiqHostDatastoreSystem
+  include VMwareWebService::Logging
+
   attr_reader :invObj
 
   def initialize(dssMor, invObj)
@@ -44,7 +48,7 @@ class MiqHostDatastoreSystem
     localPath = dsh.info.nas.name
     type    = dsh.info.nas.type
 
-    $vim_log.info "MiqHostDatastoreSystem.addNasDatastoreByName: remoteHost = #{remoteHost}, remotePath = #{remotePath}, localPath = #{localPath}"
+    logger.info "MiqHostDatastoreSystem.addNasDatastoreByName: remoteHost = #{remoteHost}, remotePath = #{remotePath}, localPath = #{localPath}"
     createNasDatastore(remoteHost, remotePath, localPath, accessMode, type)
   end
 end # class MiqHostDatastoreSystem

data/lib/VMwareWebService/MiqVim.rb

@@ -20,49 +20,73 @@ class MiqVim < MiqVimInventory
 
   attr_reader :updateThread, :monitor_updates
 
-  # @param server [String] DNS name or IP address of the vCenter Server 
+  # @param server [String] DNS name or IP address of the vCenter Server
   # @param username [String] Username to connect to the vCenter Server
   # @param password [String] Password to connect to the vCenter Server
-  # @param cacheScope [Symbol] A pre-defined set of properties to cache (default: nil)
+  # @param port [Integer] Port to connect to the vCenter Server (default: 443)
+  # @param ssl_options [Hash] SSL connection options, :verify_mode and :ca_file
+  # @param cache_scope [Symbol] A pre-defined set of properties to cache (default: nil)
   # @param monitor_updates [Bool] Should a thread be started to monitor updates (default: false)
-  # @param preLoad [Bool] Should the cache be built before returning the connection (default: false)
-  # @param debugUpdates [Bool] Should we print debug info for each update (default: false)
-  # @param notifyMethod [Method] A optional method to call for each update (default: nil)
-  # @param maxWait [Integer] How many seconds to wait before breaking out of WaitForUpdates (default: 60)
-  # @param maxObjects [Integer] How many objects to return from each WaitForUpdates page (default: 250)
-  def initialize(server, username, password, cacheScope = nil, monitor_updates = false, preLoad = false, debugUpdates = false, notifyMethod = nil, maxWait = 60, maxObjects = 250)
-    super(server, username, password, cacheScope)
+  # @param pre_load [Bool] Should the cache be built before returning the connection (default: false)
+  # @param debug_updates [Bool] Should we print debug info for each update (default: false)
+  # @param notify_method [Method] A optional method to call for each update (default: nil)
+  # @param max_wait [Integer] How many seconds to wait before breaking out of WaitForUpdates (default: 60)
+  # @param max_objects [Integer] How many objects to return from each WaitForUpdates page (default: 250)
+  def initialize(server:, username:, password:, port: 443, ssl_options: {}, cache_scope: nil, monitor_updates: nil, pre_load: nil, debug_updates: false, notify_method: nil, max_wait: 60, max_objects: 250)
+    super(:server => server, :port => port, :ssl_options => ssl_options, :username => username, :password => password, :cache_scope => cache_scope)
+
+    monitor_updates = self.class.monitor_updates if monitor_updates.nil?
+    pre_load        = self.class.pre_load        if pre_load.nil?
 
     @monitor_updates    = monitor_updates
     @updateMonitorReady = false
     @error              = nil
-    @notifyMethod       = notifyMethod
-    @debugUpdates       = debugUpdates
-    @maxWait            = maxWait
-    @maxObjects         = maxObjects
+    @notifyMethod       = notify_method
+    @debugUpdates       = debug_updates
+    @maxWait            = max_wait
+    @maxObjects         = max_objects
+
+    start_monitor_updates_thread(pre_load) if @monitor_updates
+  end
+
+  @@monitor_updates = false
+  @@pre_load        = false
+
+  def self.monitor_updates
+    @@monitor_updates
+  end
+
+  def self.monitor_updates=(val)
+    @@monitor_updates = val
+  end
+
+  def self.pre_load
+    @@pre_load
+  end
 
-    start_monitor_updates_thread(preLoad) if @monitor_updates
+  def self.pre_load=(val)
+    @@pre_load = val
   end
 
   def getVimVm(path)
-    $vim_log.info "MiqVimMod.getVimVm: called"
+    logger.info "MiqVimMod.getVimVm: called"
     miqVimVm = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find VM: #{path}" unless (vmh = virtualMachines_locked[path])
       miqVimVm = MiqVimVm.new(self, conditionalCopy(vmh))
     end
-    $vim_log.info "MiqVimMod.getVimVm: returning object #{miqVimVm.object_id}"
+    logger.info "MiqVimMod.getVimVm: returning object #{miqVimVm.object_id}"
     (miqVimVm)
   end # def getVimVm
 
   def getVimVmByMor(vmMor)
-    $vim_log.info "MiqVimMod.getVimVmByMor: called"
+    logger.info "MiqVimMod.getVimVmByMor: called"
     miqVimVm = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find VM: #{vmMor}" unless (vmh = virtualMachinesByMor_locked[vmMor])
       miqVimVm = MiqVimVm.new(self, conditionalCopy(vmh))
     end
-    $vim_log.info "MiqVimMod.getVimVmByMor: returning object #{miqVimVm.object_id}"
+    logger.info "MiqVimMod.getVimVmByMor: returning object #{miqVimVm.object_id}"
     (miqVimVm)
   end # def getVimVmByMor
 
@@ -71,36 +95,36 @@ class MiqVim < MiqVimInventory
   # matches the criteria defined by the filter.
   #
   def getVimVmByFilter(filter)
-    $vim_log.info "MiqVimMod.getVimVmByFilter: called"
+    logger.info "MiqVimMod.getVimVmByFilter: called"
     miqVimVm = nil
     @cacheLock.synchronize(:SH) do
       vms = applyFilter(virtualMachinesByMor_locked.values, filter)
       raise MiqException::MiqVimResourceNotFound, "getVimVmByFilter: Could not find VM matching filter" if vms.empty?
       miqVimVm = MiqVimVm.new(self, conditionalCopy(vms[0]))
     end
-    $vim_log.info "MiqVimMod.getVimVmByFilter: returning object #{miqVimVm.object_id}"
+    logger.info "MiqVimMod.getVimVmByFilter: returning object #{miqVimVm.object_id}"
     (miqVimVm)
   end # def getVimVmByFilter
 
   def getVimHost(name)
-    $vim_log.info "MiqVimMod.getVimHost: called"
+    logger.info "MiqVimMod.getVimHost: called"
     miqVimHost = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find Host: #{name}" unless (hh = hostSystems_locked[name])
       miqVimHost = MiqVimHost.new(self, conditionalCopy(hh))
     end
-    $vim_log.info "MiqVimMod.getVimHost: returning object #{miqVimHost.object_id}"
+    logger.info "MiqVimMod.getVimHost: returning object #{miqVimHost.object_id}"
     (miqVimHost)
   end # def getVimHost
 
   def getVimHostByMor(hMor)
-    $vim_log.info "MiqVimMod.getVimHostByMor: called"
+    logger.info "MiqVimMod.getVimHostByMor: called"
     miqVimHost = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find Host: #{hMor}" unless (hh = hostSystemsByMor_locked[hMor])
       miqVimHost = MiqVimHost.new(self, conditionalCopy(hh))
     end
-    $vim_log.info "MiqVimMod.getVimHostByMor: returning object #{miqVimHost.object_id}"
+    logger.info "MiqVimMod.getVimHostByMor: returning object #{miqVimHost.object_id}"
     (miqVimHost)
   end # def getVimHostByMor
 
@@ -109,48 +133,48 @@ class MiqVim < MiqVimInventory
   # matches the criteria defined by the filter.
   #
   def getVimHostByFilter(filter)
-    $vim_log.info "MiqVimMod.getVimHostByFilter: called"
+    logger.info "MiqVimMod.getVimHostByFilter: called"
     miqVimHost = nil
     @cacheLock.synchronize(:SH) do
       ha = applyFilter(hostSystemsByMor_locked.values, filter)
       raise MiqException::MiqVimResourceNotFound, "getVimHostByFilter: Could not find Host matching filter" if ha.empty?
       miqVimHost = MiqVimHost.new(self, conditionalCopy(ha[0]))
     end
-    $vim_log.info "MiqVimMod.getVimHostByFilter: returning object #{miqVimHost.object_id}"
+    logger.info "MiqVimMod.getVimHostByFilter: returning object #{miqVimHost.object_id}"
     (miqVimHost)
   end # def getVimHostByFilter
 
   def getVimFolder(name)
-    $vim_log.info "MiqVimMod.getVimFolder: called"
+    logger.info "MiqVimMod.getVimFolder: called"
     miqVimFolder = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find Folder: #{name}" unless (fh = folders_locked[name])
       miqVimFolder = MiqVimFolder.new(self, conditionalCopy(fh))
     end
-    $vim_log.info "MiqVimMod.getVimFolder: returning object #{miqVimFolder.object_id}"
+    logger.info "MiqVimMod.getVimFolder: returning object #{miqVimFolder.object_id}"
     (miqVimFolder)
   end # def getVimFolder
 
   def getVimFolderByMor(fMor)
-    $vim_log.info "MiqVimMod.getVimFolderByMor: called"
+    logger.info "MiqVimMod.getVimFolderByMor: called"
     miqVimFolder = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find Folder: #{fMor}" unless (fh = foldersByMor_locked[fMor])
       miqVimFolder = MiqVimFolder.new(self, conditionalCopy(fh))
     end
-    $vim_log.info "MiqVimMod.getVimFolderByMor: returning object #{miqVimFolder.object_id}"
+    logger.info "MiqVimMod.getVimFolderByMor: returning object #{miqVimFolder.object_id}"
     (miqVimFolder)
   end # def getVimFolderByMor
 
   def getVimFolderByFilter(filter)
-    $vim_log.info "MiqVimMod.getVimFolderByFilter: called"
+    logger.info "MiqVimMod.getVimFolderByFilter: called"
     miqVimFolder = nil
     @cacheLock.synchronize(:SH) do
       folders = applyFilter(foldersByMor_locked.values, filter)
       raise MiqException::MiqVimResourceNotFound, "getVimFolderByFilter: Could not find folder matching filter" if folders.empty?
       miqVimFolder = MiqVimFolder.new(self, conditionalCopy(folders[0]))
     end
-    $vim_log.info "MiqVimMod.getVimFolderByFilter: returning object #{miqVimFolder.object_id}"
+    logger.info "MiqVimMod.getVimFolderByFilter: returning object #{miqVimFolder.object_id}"
     (miqVimFolder)
   end # def getVimFolderByFilter
 
@@ -158,36 +182,36 @@ class MiqVim < MiqVimInventory
   # Cluster
   #
   def getVimCluster(name)
-    $vim_log.info "MiqVimMod.getVimCluster: called"
+    logger.info "MiqVimMod.getVimCluster: called"
     miqVimCluster = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find Cluster: #{name}" unless (ch = clusterComputeResources_locked[name])
       miqVimCluster = MiqVimCluster.new(self, conditionalCopy(ch))
     end
-    $vim_log.info "MiqVimMod.getVimCluster: returning object #{miqVimCluster.object_id}"
+    logger.info "MiqVimMod.getVimCluster: returning object #{miqVimCluster.object_id}"
     (miqVimCluster)
   end # def getVimCluster
 
   def getVimClusterByMor(cMor)
-    $vim_log.info "MiqVimMod.getVimClusterByMor: called"
+    logger.info "MiqVimMod.getVimClusterByMor: called"
     miqVimCluster = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find Cluster: #{cMor}" unless (ch = clusterComputeResourcesByMor_locked[cMor])
       miqVimCluster = MiqVimCluster.new(self, conditionalCopy(ch))
     end
-    $vim_log.info "MiqVimMod.getVimClusterByMor: returning object #{miqVimCluster.object_id}"
+    logger.info "MiqVimMod.getVimClusterByMor: returning object #{miqVimCluster.object_id}"
     (miqVimCluster)
   end # def getVimClusterByMor
 
   def getVimClusterByFilter(filter)
-    $vim_log.info "MiqVimMod.getVimClusterByFilter: called"
+    logger.info "MiqVimMod.getVimClusterByFilter: called"
     miqVimCluster = nil
     @cacheLock.synchronize(:SH) do
       clusters = applyFilter(clusterComputeResourcesByMor_locked.values, filter)
       raise MiqException::MiqVimResourceNotFound, "getVimClusterByFilter: Could not find Cluster matching filter" if clusters.empty?
       miqVimCluster = MiqVimCluster.new(self, conditionalCopy(clusters[0]))
     end
-    $vim_log.info "MiqVimMod.getVimClusterByFilter: returning object #{miqVimCluster.object_id}"
+    logger.info "MiqVimMod.getVimClusterByFilter: returning object #{miqVimCluster.object_id}"
     (miqVimCluster)
   end # def getVimClusterByFilter
 
@@ -195,54 +219,54 @@ class MiqVim < MiqVimInventory
   # DataStore
   #
   def getVimDataStore(dsName)
-    $vim_log.info "MiqVimMod.getVimDataStore: called"
+    logger.info "MiqVimMod.getVimDataStore: called"
     miqVimDs = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find datastore: #{dsName}" unless (dsh = dataStores_locked[dsName])
       miqVimDs = MiqVimDataStore.new(self, conditionalCopy(dsh))
     end
-    $vim_log.info "MiqVimMod.getVimDataStore: returning object #{miqVimDs.object_id}"
+    logger.info "MiqVimMod.getVimDataStore: returning object #{miqVimDs.object_id}"
     (miqVimDs)
   end
 
   def getVimDataStoreByMor(dsMor)
-    $vim_log.info "MiqVimMod.getVimDataStoreByMor: called"
+    logger.info "MiqVimMod.getVimDataStoreByMor: called"
     miqVimDs = nil
     @cacheLock.synchronize(:SH) do
       raise MiqException::MiqVimResourceNotFound, "Could not find datastore: #{dsMor}" unless (dsh = dataStoresByMor_locked[dsMor])
       miqVimDs = MiqVimDataStore.new(self, conditionalCopy(dsh))
     end
-    $vim_log.info "MiqVimMod.getVimDataStoreByMor: returning object #{miqVimDs.object_id}"
+    logger.info "MiqVimMod.getVimDataStoreByMor: returning object #{miqVimDs.object_id}"
     (miqVimDs)
   end
 
   def getVimPerfHistory
     miqVimPh = MiqVimPerfHistory.new(self)
-    $vim_log.info "MiqVimMod.getVimPerfHistory: returning object #{miqVimPh.object_id}"
+    logger.info "MiqVimMod.getVimPerfHistory: returning object #{miqVimPh.object_id}"
     (miqVimPh)
   end
 
   def getVimEventHistory(eventFilterSpec = nil, pgSize = 20)
     miqVimEh = MiqVimEventHistoryCollector.new(self, eventFilterSpec, pgSize)
-    $vim_log.info "MiqVimMod.getVimEventHistory: returning object #{miqVimEh.object_id}"
+    logger.info "MiqVimMod.getVimEventHistory: returning object #{miqVimEh.object_id}"
     (miqVimEh)
   end
 
   def getMiqCustomFieldsManager
     miqVimCfm = MiqCustomFieldsManager.new(self)
-    $vim_log.info "MiqVimMod.getMiqCustomFieldsManager: returning object #{miqVimCfm.object_id}"
+    logger.info "MiqVimMod.getMiqCustomFieldsManager: returning object #{miqVimCfm.object_id}"
     (miqVimCfm)
   end
 
   def getVimAlarmManager
     miqVimAm = MiqVimAlarmManager.new(self)
-    $vim_log.info "MiqVimMod.getVimAlarmManager: returning object #{miqVimAm.object_id}"
+    logger.info "MiqVimMod.getVimAlarmManager: returning object #{miqVimAm.object_id}"
     (miqVimAm)
   end
 
   def getVimCustomizationSpecManager
     miqVimCsm = MiqVimCustomizationSpecManager.new(self)
-    $vim_log.info "MiqVimMod.getVimCustomizationSpecManager: returning object #{miqVimCsm.object_id}"
+    logger.info "MiqVimMod.getVimCustomizationSpecManager: returning object #{miqVimCsm.object_id}"
     (miqVimCsm)
   end
 
@@ -257,28 +281,28 @@ class MiqVim < MiqVimInventory
   def start_monitor_updates_thread(preLoad)
     checkForOrphanedMonitors
     log_prefix          = "MiqVim.initialize (#{@connId})"
-    $vim_log.info "#{log_prefix}: starting update monitor thread" if $vim_log
+    logger.info "#{log_prefix}: starting update monitor thread"
     @updateThread = Thread.new { monitor(preLoad) }
     @updateThread[:vim_connection_id] = connId
-    $vim_log.info "#{log_prefix}: waiting for update monitor to become ready" if $vim_log
+    logger.info "#{log_prefix}: waiting for update monitor to become ready"
     until @updateMonitorReady
       raise @error unless @error.nil?
       break unless @updateThread.alive?
       Thread.pass
     end
-    $vim_log.info "#{log_prefix}: update monitor ready" if $vim_log
+    logger.info "#{log_prefix}: update monitor ready"
   end
 
   def checkForOrphanedMonitors
     log_prefix = "MiqVim.checkForOrphanedMonitors (#{@connId})"
-    $vim_log.debug "#{log_prefix}: called..."
+    logger.debug "#{log_prefix}: called..."
     Thread.list.each do |thr|
       next unless thr[:vim_connection_id] == connId
-      $vim_log.error "#{log_prefix}: Terminating orphaned update monitor <#{thr.object_id}>"
+      logger.error "#{log_prefix}: Terminating orphaned update monitor <#{thr.object_id}>"
       thr.raise "Orphaned update monitor (#{@connId}) <#{thr.object_id}>, terminated by <#{Thread.current.object_id}>"
       thr.wakeup
     end
-    $vim_log.debug "#{log_prefix}: done."
+    logger.debug "#{log_prefix}: done."
   end
 
   def monitor(preLoad)
@@ -286,7 +310,7 @@ class MiqVim < MiqVimInventory
     begin
       monitorUpdates(preLoad)
     rescue Exception => err
-      $vim_log.info "#{log_prefix}: returned from monitorUpdates via #{err.class} exception" if $vim_log
+      logger.info "#{log_prefix}: returned from monitorUpdates via #{err.class} exception"
       @error = err
     end
   end
@@ -296,9 +320,9 @@ class MiqVim < MiqVimInventory
     stopUpdateMonitor
     begin
       if @updateThread != Thread.current && @updateThread.alive?
-        $vim_log.info "#{log_prefix}: waiting for Update Monitor Thread...Starting" if $vim_log
+        logger.info "#{log_prefix}: waiting for Update Monitor Thread...Starting"
         @updateThread.join
-        $vim_log.info "#{log_prefix}: waiting for Update Monitor Thread...Complete" if $vim_log
+        logger.info "#{log_prefix}: waiting for Update Monitor Thread...Complete"
       end
     rescue
     end

data/lib/VMwareWebService/MiqVimClientBase.rb

@@ -8,10 +8,11 @@ require 'VMwareWebService/VimService'
 class MiqVimClientBase < VimService
   @@receiveTimeout = 120
 
-  attr_reader :server, :username, :password, :connId
+  attr_reader :server, :port, :username, :password, :connId
 
-  def initialize(server, username, password)
+  def initialize(server:, username:, password:, port: 443, ssl_options: {})
     @server   = server
+    @port     = port
     @username = username
     @password = password
     @connId   = "#{@server}_#{@username}"
@@ -19,13 +20,13 @@ class MiqVimClientBase < VimService
     @receiveTimeout = @@receiveTimeout
 
     on_http_client_init do |http_client, _headers|
-      http_client.ssl_config.verify_mode    = OpenSSL::SSL::VERIFY_NONE
-      http_client.ssl_config.verify_callback  = method(:verify_callback).to_proc
-      http_client.receive_timeout       = @receiveTimeout
+      http_client.receive_timeout        = @receiveTimeout
+      http_client.ssl_config.verify_mode = ssl_options[:verify_ssl] || OpenSSL::SSL::VERIFY_NONE
+      http_client.ssl_config.cert_store.add_cert(OpenSSL::X509::Certificate.new(ssl_options[:ca_file])) if ssl_options[:ca_file]
     end
 
-    on_log_header { |msg| $vim_log.info msg }
-    on_log_body   { |msg| $vim_log.debug msg } if $miq_wiredump
+    on_log_header { |msg| logger.info msg }
+    on_log_body   { |msg| logger.debug msg } if $miq_wiredump
 
     super(:uri => sdk_uri, :version => 1)
 
@@ -34,7 +35,7 @@ class MiqVimClientBase < VimService
   end
 
   def sdk_uri
-    URI::HTTPS.build(:host => server, :path => "/sdk")
+    URI::HTTPS.build(:host => server, :port => port, :path => "/sdk")
   end
 
   def self.receiveTimeout=(val)
@@ -59,7 +60,7 @@ class MiqVimClientBase < VimService
   end
 
   def connect
-    $vim_log.debug "#{self.class.name}.connect(#{@connId}): #{$PROGRAM_NAME} #{ARGV.join(' ')}" if $vim_log.debug?
+    logger.debug { "#{self.class.name}.connect(#{@connId}): #{$PROGRAM_NAME} #{ARGV.join(' ')}" }
     @connLock.synchronize(:EX) do
       return if @connected
       login(@sic.sessionManager, @username, @password)
@@ -68,7 +69,7 @@ class MiqVimClientBase < VimService
   end
 
   def disconnect
-    $vim_log.debug "#{self.class.name}.disconnect(#{@connId}): #{$PROGRAM_NAME} #{ARGV.join(' ')}" if $vim_log.debug?
+    logger.debug { "#{self.class.name}.disconnect(#{@connId}): #{$PROGRAM_NAME} #{ARGV.join(' ')}" }
     @connLock.synchronize(:EX) do
       return unless @connected
       logout(@sic.sessionManager)

data/lib/VMwareWebService/MiqVimCluster.rb

@@ -1,4 +1,8 @@
+require 'VMwareWebService/logging'
+
 class MiqVimCluster
+  include VMwareWebService::Logging
+
   attr_reader :name, :invObj
 
   def initialize(invObj, ch)
@@ -44,9 +48,9 @@ class MiqVimCluster
       cs.vmFolder       = ah[:vmFolder]       unless ah[:vmFolder].nil?
     end
 
-    $vim_log.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addHost: calling addHost_Task" if $vim_log
+    logger.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addHost: calling addHost_Task"
     taskMor = @invObj.addHost_Task(@cMor, cspec, ah[:asConnected].to_s, ah[:resourcePool], ah[:license])
-    $vim_log.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addHost: returned from addHost_Task" if $vim_log
+    logger.info "MiqVimCluster(#{@invObj.server}, #{@invObj.username}).addHost: returned from addHost_Task"
     return taskMor unless ah[:wait]
     waitForTask(taskMor)
   end # def addHost