vmware_web_service 2.0.3 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e574683780708a47c577b3917ed87bf1557bc5cf74754a316779dbf22078e41
-  data.tar.gz: adaf9d2ceee9103c3f1f523c09741f851265b3a751b3bc4485f2d94f778c6dcf
+  metadata.gz: 6f5cfe645f59b74bbc745d9b8ca87f3f812ef66825ed97d1ae9e9ff90581f78b
+  data.tar.gz: 4159afd750db2f67f086ee758e92f30b9af934003471f6d0e7f721e352e7c1b1
 SHA512:
-  metadata.gz: 8bbd90473121a7d542350232dca9525e33c836e84274e41574550e4dd2123b317d23345a73ff8cf5bc6e8f98b849358571288aef91a44d5fbc076a979c0ac7ca
-  data.tar.gz: c423d660ce2d62115449de15b130495794625344b58a1ba7d7d331155b62e4d29738a69c55991931050a0dba29ddbad318b367189edf990113ca5745c983fbe3
+  metadata.gz: 6e6d105b56f251292a513a69f077fe65636fe54d46df9d92739c008a1d8dbfb4a793edb546bc55f67a8f7fcb2dd53f23aa90cc8234bb5c717d9a569fece53bc4
+  data.tar.gz: fbac5ac0d635a9233fe35195247fdca265e506c4da997f6aa072daad516c160ef9a040b87ab478e6b425b6a0728b7d7674468907abac9df2fb384a748ae81cd4

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

data/lib/VMwareWebService/MiqVimDataStore.rb

@@ -1,7 +1,10 @@
 require 'sync'
 require 'util/miq-extensions'  # Required patch to open-uri for get_file_content
+require 'VMwareWebService/logging'
 
 class MiqVimDataStore
+  include VMwareWebService::Logging
+
   attr_reader :accessible, :multipleHostAccess, :name, :dsType, :url, :freeBytes, :capacityBytes, :uncommitted, :invObj
 
   def initialize(invObj, dsh)
@@ -127,13 +130,13 @@ class MiqVimDataStore
 
     taskMor = nil
     if recurse
-      $vim_log.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: calling searchDatastoreSubFolders_Task" if $vim_log
+      logger.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: calling searchDatastoreSubFolders_Task"
       taskMor = @invObj.searchDatastoreSubFolders_Task(browserMor, dsPath, searchSpec)
-      $vim_log.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: returned from searchDatastoreSubFolders_Task" if $vim_log
+      logger.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: returned from searchDatastoreSubFolders_Task"
     else
-      $vim_log.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: calling searchDatastore_Task" if $vim_log
+      logger.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: calling searchDatastore_Task"
       taskMor = @invObj.searchDatastore_Task(browserMor, dsPath, searchSpec)
-      $vim_log.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: returned from searchDatastore_Task" if $vim_log
+      logger.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsSearch: returned from searchDatastore_Task"
     end
 
     retObj = waitForTask(taskMor)
@@ -200,9 +203,9 @@ class MiqVimDataStore
         hdbs.sortFoldersFirst = "true"
       end
 
-      $vim_log.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsHash_locked: calling searchDatastoreSubFolders_Task" if $vim_log
+      logger.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsHash_locked: calling searchDatastoreSubFolders_Task"
       taskMor = @invObj.searchDatastoreSubFolders_Task(browser_locked, "[#{@name}]", searchSpec)
-      $vim_log.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsHash_locked: returned from searchDatastoreSubFolders_Task" if $vim_log
+      logger.info "MiqVimDataStore(#{@invObj.server}, #{@invObj.username}).dsHash_locked: returned from searchDatastoreSubFolders_Task"
 
       retObj = waitForTask(taskMor)
       retObj = [retObj] unless retObj.kind_of?(Array)

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