vmware_web_service 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: daa16922be53440c037ba428c5c6b9d075104a11c435582bc090c70adc597238
-  data.tar.gz: dbdf3a842e42f0ba00de9bdb56c94ecbd19fd2edbf6710e8017e7434c2c6bf05
+  metadata.gz: 226087a0ff6c13ce429b1afcc992b15be50f5bdd1b69cfff1d7ac6dd7783f947
+  data.tar.gz: fe185b7ae7a35bbb2b7c35e620b7a867644ab58d40b31dc927d1199d5ba9d528
 SHA512:
-  metadata.gz: 2ff2e07d99b520fbbe9a77babe42049b2535588a54ea1a163c5b5e9f82b7c36479ff31bfdf803035a0da8b7b215b3b3c0149768ccc98221d79884586f8afaec9
-  data.tar.gz: 25dd53f1a810605d3fd4a34a1077c71b8988f67508517b266c39bc8628d235b318c1ee0ed7fa46fc9573760bffc9b833a6ec592f60db2d192405c7f90fd1caa2
+  metadata.gz: 56d673e90ebcd77929efdd966466d074fb47a244c8ab98de0ff1f31ffd25d210396e9e9a2ac3a1d8984ac20980af76e5e176263c362ac6bd5bfd28880fcae0a3
+  data.tar.gz: 75d6e04f83ef0fee9df9d73dbaaca3497c0aa4f214da4ef83572e74c5697d9f40541e1bda8a3dad31ba628a37aa8e010b69c4b3286dc54a2a6141b21471a329a

data/lib/VMwareWebService/MiqVimBroker.rb

@@ -73,10 +73,6 @@ class MiqVimBroker
       require 'timeout'
       require 'VMwareWebService/broker_timeout'
 
-      # Un-comment following 2 lines to enable Sync lock debugging.
-      # require 'broker_sync_debug'
-      # extend BrokerSyncDebug
-
       unless @@classModed
         DRb.instance_variable_set(:@mutex, sync_for_drb)
         DRb::DRbConn.instance_variable_set(:@mutex, sync_for_drb_drbconn)
@@ -107,27 +103,22 @@ class MiqVimBroker
     end
   end
 
-  # Can be overridden by BrokerSyncDebug.
   def connection_lock
     Sync.new
   end
 
-  # Can be overridden by BrokerSyncDebug.
   def config_lock
     Sync.new
   end
 
-  # Can be overridden by BrokerSyncDebug.
   def sync_for_lock_hash(_key)
     Sync.new
   end
 
-  # Can be overridden by BrokerSyncDebug.
   def sync_for_drb_drbconn
     Sync.new
   end
 
-  # Can be overridden by BrokerSyncDebug.
   def sync_for_drb
     Sync.new
   end

data/lib/VMwareWebService/MiqVimInventory.rb

@@ -1,4 +1,3 @@
-require 'VMwareWebService/VimSyncDebug'
 require 'sync'
 require 'enumerator'
 require 'VMwareWebService/MiqVimClientBase'
@@ -94,9 +93,6 @@ class MiqVimInventory < MiqVimClientBase
     @cacheLock  = Sync.new
     @configLock = Sync.new
 
-    # Un-comment to enable Sync lock debugging.
-    # extend VimSyncDebug
-
     resetCache
     __connect
     @alive = true
@@ -201,6 +197,14 @@ class MiqVimInventory < MiqVimClientBase
         ps.type = "Datastore"
         ps.all  = "false"
       end
+      psa << VimHash.new("PropertySpec") do |ps|
+        ps.type = "LicenseManager"
+        ps.all  = "false"
+      end
+      psa << VimHash.new("PropertySpec") do |ps|
+        ps.type = "ExtensionManager"
+        ps.all  = "false"
+      end
     end
     VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
       pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
@@ -1772,6 +1776,226 @@ class MiqVimInventory < MiqVimClientBase
     addObjHash(:StoragePod, spObj)
   end
 
+  ###################
+  # License Managers
+  ###################
+
+  #
+  # For internal use.
+  # Must be called with cache lock held
+  # Returns with the cache lock held - must be unlocked by caller.
+  #
+  def licenseManagers_locked
+    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}"
+    begin
+      @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
+
+      ra = getMoPropMulti(inventoryHash_locked['LicenseManager'], @propMap[:LicenseManager][:props])
+
+      @licenseManagers      = {}
+      @licenseManagersByMor = {}
+      ra.each do |licenseManagerObj|
+        addLicenseManagerObj(licenseManagerObj)
+      end
+    ensure
+      @cacheLock.sync_unlock if unlock
+    end
+    $vim_log.info "MiqVimInventory.licenseManagers_locked: loaded LicenseManager cache for #{@connId}"
+
+    @licenseManagers
+  end # def licenseManagers_locked
+  protected :licenseManagers_locked
+
+  #
+  # For internal use.
+  # Must be called with cache lock held
+  # Returns with the cache lock held - must be unlocked by caller.
+  #
+  def licenseManagersByMor_locked
+    raise "licenseManagerByMor_locked: cache lock not held" unless @cacheLock.sync_locked?
+    return(@licenseManagersByMor) if @licenseManagersByMor
+    licenseManagers_locked
+    @licenseManagersByMor
+  end # def licenseManagersByMor_locked
+  protected :licenseManagersByMor_locked
+
+  #
+  # Public accessor
+  #
+  def licenseManagersByMor(selSpec = nil)
+    license_managers = nil
+    @cacheLock.synchronize(:SH) do
+      if selSpec.nil?
+        license_managers = dupObj(licenseManagersByMor_locked)
+      else
+        license_managers = applySelector(licenseManagersByMor_locked, selSpec)
+      end
+    end
+    assert_no_locks
+    license_managers
+  end
+
+  #
+  # Return a single License Manager object, given its MOR
+  #
+  def licenseManagerByMor(licenseManagerMor, selSpec = nil)
+    @cacheLock.synchronize(:SH) do
+      return(dupObj(licenseManagersByMor_locked[licenseManagerMor])) if selSpec.nil?
+      return(applySelector(licenseManagersByMor_locked[licenseManagerMor], selSpec))
+    end
+  end
+
+  #
+  # Public accessor
+  #
+  # Return an array of license manager objects that match the given property filter.
+  #
+  def licenseManagersByFilter(filter)
+    license_managers = nil
+    @cacheLock.synchronize(:SH) do
+      license_managers = applyFilter(licenseManagersByMor_locked.values, filter)
+      license_managers = dupObj(license_managers)
+    end
+    assert_no_locks
+    license_managers
+  end
+
+  def addLicenseManager(licenseManagerMor)
+    @cacheLock.synchronize(:EX) do
+      return(addObjByMor(licenseManagerMor))
+    end
+  end
+
+  def refreshLicenseManager(licenseManagerMor)
+    @cacheLock.synchronize(:EX) do
+      return(conditionalCopy(addObjByMor(licenseManagerMor)))
+    end
+  end
+
+  def addLicenseManagerObj(licenseManagerObj)
+    addObjHash(:LicenseManager, licenseManagerObj)
+  end
+  protected :addLicenseManagerObj
+
+  def removeLicenseManager(licenseManagerMor)
+    @cacheLock.synchronize(:EX) do
+      removeObjByMor(licenseManagerMor)
+    end
+  end
+
+  ###################
+  # Extension Managers
+  ###################
+
+  #
+  # For internal use.
+  # Must be called with cache lock held
+  # Returns with the cache lock held - must be unlocked by caller.
+  #
+  def extensionManagers_locked
+    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}"
+    begin
+      @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)
+
+      ra = getMoPropMulti(inventoryHash_locked['ExtensionManager'], @propMap[:ExtensionManager][:props])
+
+      @extensionManagers      = {}
+      @extensionManagersByMor = {}
+      ra.each do |extensionManagerObj|
+        addExtensionManagerObj(extensionManagerObj)
+      end
+    ensure
+      @cacheLock.sync_unlock if unlock
+    end
+    $vim_log.info "MiqVimInventory.extensionManagers_locked: loaded ExtensionManager cache for #{@connId}"
+
+    @extensionManagers
+  end # def extensionManagers_locked
+  protected :extensionManagers_locked
+
+  #
+  # For internal use.
+  # Must be called with cache lock held
+  # Returns with the cache lock held - must be unlocked by caller.
+  #
+  def extensionManagersByMor_locked
+    raise "extensionManagersByMor_locked: cache lock not held" unless @cacheLock.sync_locked?
+    return(@extensionManagersByMor) if @extensionManagersByMor
+    extensionManagers_locked
+    @extensionManagersByMor
+  end # def extensionManagersByMor_locked
+  protected :extensionManagersByMor_locked
+
+  #
+  # Public accessor
+  #
+  def extensionManagersByMor(selSpec = nil)
+    extension_managers = nil
+    @cacheLock.synchronize(:SH) do
+      if selSpec.nil?
+        extension_managers = dupObj(extensionManagersByMor_locked)
+      else
+        extension_managers = applySelector(extensionManagersByMor_locked, selSpec)
+      end
+    end
+    assert_no_locks
+    extension_managers
+  end
+
+  #
+  # Return a single Extension Manager object, given its MOR
+  #
+  def extensionManagerByMor(extensionManagerMor, selSpec = nil)
+    @cacheLock.synchronize(:SH) do
+      return(dupObj(extensionManagersByMor_locked[extensionManagerMor])) if selSpec.nil?
+      return(applySelector(extensionManagersByMor_locked[extensionManagerMor], selSpec))
+    end
+  end
+
+  #
+  # Public accessor
+  #
+  # Return an array of extension manager objects that match the given property filter.
+  #
+  def extensionManagersByFilter(filter)
+    extension_managers = nil
+    @cacheLock.synchronize(:SH) do
+      extension_managers = applyFilter(extensionManagersByMor_locked.values, filter)
+      extension_managers = dupObj(extension_managers)
+    end
+    assert_no_locks
+    extension_managers
+  end
+
+  def addExtensionManager(extensionManagerMor)
+    @cacheLock.synchronize(:EX) do
+      return(addObjByMor(extensionManagerMor))
+    end
+  end
+
+  def refreshExtensionManager(extensionManagerMor)
+    @cacheLock.synchronize(:EX) do
+      return(conditionalCopy(addObjByMor(extensionManagerMor)))
+    end
+  end
+
+  def addExtensionManagerObj(extensionManagerObj)
+    addObjHash(:ExtensionManager, extensionManagerObj)
+  end
+  protected :addExtensionManagerObj
+
+  def removeExtensionManager(extensionManagerMor)
+    @cacheLock.synchronize(:EX) do
+      removeObjByMor(extensionManagerMor)
+    end
+  end
+
   #
   # A hash of managed object references for all the objects we care about.
   #

data/lib/VMwareWebService/MiqVimObjectSet.rb

@@ -139,6 +139,12 @@ module MiqVimObjectSet
         os.skip      = "false"
         os.selectSet = VimArray.new("ArrayOfSelectionSpec") { |ssa| ssa << folderTs }
       end
+      osa << VimHash.new("ObjectSpec") do |os|
+        os.obj = @sic.licenseManager
+      end
+      osa << VimHash.new("ObjectSpec") do |os|
+        os.obj = @sic.extensionManager
+      end
     end
 
     (aOobjSpec)

data/lib/VMwareWebService/VimPropMaps.rb

@@ -86,6 +86,20 @@ module VimPropMaps
         'summary',
         'parent'
       ]
+    },
+    :LicenseManager              => {
+      :baseName => "@licenseManagers",
+      :keyPath  => nil,
+      :props    => [
+        'licenses'
+      ]
+    },
+    :ExtensionManager            => {
+      :baseName => "@extensionManagers",
+      :keyPath  => nil,
+      :props    => [
+        'extensionList'
+      ]
     }
   }
 
@@ -303,6 +317,8 @@ module VimPropMaps
         "config.network.dnsConfig.domainName",
         "config.network.dnsConfig.hostName",
         "config.network.ipRouteConfig.defaultGateway",
+        "config.network.opaqueNetwork",
+        "config.network.opaqueSwitch",
         "config.network.pnic",
         "config.network.portgroup",
         "config.network.vnic",
@@ -393,6 +409,20 @@ module VimPropMaps
         'summary.hostMember',
         'parent'
       ]
+    },
+    :LicenseManager              => {
+      :baseName => "@licenseManagers",
+      :keyPath  => nil,
+      :props    => [
+        'licenses'
+      ]
+    },
+    :ExtensionManager            => {
+      :baseName => "@extensionManagers",
+      :keyPath  => nil,
+      :props    => [
+        'extensionList'
+      ]
     }
   }
 

data/lib/VMwareWebService/version.rb

@@ -1,3 +1,3 @@
 module VMwareWebService
-  VERSION = '0.4.2'.freeze
+  VERSION = '0.4.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vmware_web_service
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-18 00:00:00.000000000 Z
+date: 2019-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -106,14 +106,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -255,12 +255,10 @@ files:
 - lib/VMwareWebService/VimMappingRegistry.rb
 - lib/VMwareWebService/VimPropMaps.rb
 - lib/VMwareWebService/VimService.rb
-- lib/VMwareWebService/VimSyncDebug.rb
 - lib/VMwareWebService/VimTypes.rb
 - lib/VMwareWebService/VixDiskLib/VixDiskLib.rb
 - lib/VMwareWebService/VixDiskLib/VixDiskLibServer.rb
 - lib/VMwareWebService/VixDiskLib/vdl_wrapper.rb
-- lib/VMwareWebService/broker_sync_debug.rb
 - lib/VMwareWebService/broker_timeout.rb
 - lib/VMwareWebService/esx_thumb_print.rb
 - lib/VMwareWebService/exception.rb
@@ -268,7 +266,6 @@ files:
 - lib/VMwareWebService/thumb_print.rb
 - lib/VMwareWebService/vcenter_thumb_print.rb
 - lib/VMwareWebService/version.rb
-- lib/VMwareWebService/vim_base_sync_debug.rb
 - lib/VMwareWebService/wsdl41/convert_mapping_registry_to_yaml.rb
 - lib/VMwareWebService/wsdl41/core-types.xsd
 - lib/VMwareWebService/wsdl41/methods/AboutInfo.yml

data/lib/VMwareWebService/VimSyncDebug.rb

@@ -1,16 +0,0 @@
-require 'util/SyncDebug'
-require 'VMwareWebService/vim_base_sync_debug'
-
-module VimSyncDebug
-  def self.extended(obj)
-    obj.cacheLock.extend(SyncDebug_m)
-    obj.cacheLock.lock_name = "#{obj.class.name}#cacheLock(#{obj.connId})"
-    VimBaseSyncDebug.vsd_set_callbacks(obj.cacheLock)
-    obj.cacheLock.watchdog_enabled = true
-
-    obj.configLock.extend(SyncDebug_m)
-    obj.configLock.lock_name = "#{obj.class.name}#configLock(#{obj.connId})"
-    VimBaseSyncDebug.vsd_set_callbacks(obj.configLock)
-    obj.configLock.watchdog_enabled = true
-  end
-end

data/lib/VMwareWebService/broker_sync_debug.rb

@@ -1,33 +0,0 @@
-require 'util/SyncDebug'
-require 'VMwareWebService/vim_base_sync_debug'
-
-module BrokerSyncDebug
-  def connection_lock
-    alloc_sync_lock("#{self.class.name}#connectionLock")
-  end
-
-  def config_lock
-    alloc_sync_lock("#{self.class.name}#configLock")
-  end
-
-  def sync_for_lock_hash(key)
-    alloc_sync_lock("#{self.class.name}#lockHash[#{key}]")
-  end
-
-  def sync_for_drb
-    alloc_sync_lock("DRB#mutex")
-  end
-
-  def sync_for_drb_drbconn
-    alloc_sync_lock("DRb::DRbConn#mutex")
-  end
-
-  def alloc_sync_lock(lock_name)
-    lock = Sync.new
-    lock.extend(SyncDebug_m)
-    lock.lock_name = lock_name
-    VimBaseSyncDebug.vsd_set_callbacks(lock)
-    lock.watchdog_enabled = true
-    lock
-  end
-end

data/lib/VMwareWebService/vim_base_sync_debug.rb

@@ -1,68 +0,0 @@
-module VimBaseSyncDebug
-  def self.vsd_set_callbacks(lock)
-    lock.on_lock_request do |li|
-      $vim_log.info "VimSyncDebug - Requesting lock: #{li[:lock].lock_name}, from_mode = #{li[:lock].sync_mode}, to_mode = #{li[:mode]} [#{li[:call_stack][0]}]"
-    end
-
-    lock.on_lock_acquire do |li|
-      $vim_log.info "VimSyncDebug - Acquired lock: #{li[:lock].lock_name}, acquired_mode = #{li[:lock].sync_mode}, requested_mode = #{li[:mode]} [#{li[:call_stack][0]}]"
-    end
-
-    lock.on_unlock_request do |li|
-      $vim_log.info "VimSyncDebug - Releasing lock: #{li[:lock].lock_name}, pre-release_mode = #{li[:lock].sync_mode}, [#{li[:call_stack][0]}]"
-    end
-
-    lock.on_unlock do |li|
-      $vim_log.info "VimSyncDebug - Released lock: #{li[:lock].lock_name}, post-release_mode = #{li[:lock].sync_mode}, [#{li[:call_stack][0]}]"
-    end
-
-    lock.on_dead_locker do |lia|
-      li  = lia.first
-      thr = li[:thread]
-      ln  = li[:lock].lock_name
-      $vim_log.error "VimSyncDebug - Locking Thread has terminated: Lock(#{ln}), Thread(#{thr.object_id})."
-      $vim_log.error "VimSyncDebug - Start backtrace"
-      $vim_log.error li[:call_stack].join("\n")
-      $vim_log.error "VimSyncDebug - End backtrace"
-    end
-
-    lock.on_lock_timeout lambda { |li, dt|
-      thr = li[:thread]
-      $vim_log.error "VimSyncDebug - Lock timeout: thread #{thr.object_id} has held #{li[:lock].lock_name} for #{dt} seconds"
-      $vim_log.error "VimSyncDebug - Lock acquisition: Start backtrace"
-      $vim_log.error li[:call_stack].join("\n")
-      $vim_log.error "VimSyncDebug - Lock acquisition: End backtrace"
-
-      $vim_log.error "VimSyncDebug - Locking thread: Start backtrace"
-      $vim_log.error thr.backtrace.join("\n") if thr.alive?
-      $vim_log.error "VimSyncDebug - Locking thread: End backtrace"
-      return false # don't raise an exception
-    }
-
-    lock.on_watchdog_start do |l|
-      $vim_log.info "VimSyncDebug - Watchdog starting for #{l.lock_name}"
-    end
-
-    lock.on_watchdog_stop do |l, err|
-      $vim_log.info "VimSyncDebug - Watchdog for #{l.lock_name} stopping"
-      if err
-        $vim_log.error "VimSyncDebug - Watchdog ERROR: #{err}"
-        $vim_log.error "VimSyncDebug - Watchdog: Start backtrace"
-        $vim_log.error err.backtrace.join("\n")
-        $vim_log.error "VimSyncDebug - Watchdog: End backtrace"
-      end
-    end
-
-    lock.on_watchdog_heartbeat do |l|
-      $vim_log.debug "Watchdog for #{l.lock_name}: HEARTBEAT"
-    end
-
-    # lock.on_watchdog_acquire_mutex do |l|
-    #   $vim_log.debug "Watchdog for #{l.lock_name}: MUTEX acquired"
-    # end
-    #
-    # lock.on_watchdog_release_mutex do |l|
-    #   $vim_log.debug "Watchdog for #{l.lock_name}: MUTEX released"
-    # end
-  end
-end