Class: MiqVimInventory

Inherits:
MiqVimClientBase show all
Includes:
MiqVimDump, MiqVimObjectSet, VimPropMaps
Defined in:
lib/VMwareWebService/MiqVimInventory.rb

Direct Known Subclasses

MiqVim, MiqVimEventMonitor

Constant Summary collapse

@@selectorHash = 
{}
@@cacheScope = 
:cache_scope_full

Constants included from VimPropMaps

VimPropMaps::CorePropMap, VimPropMaps::EmsRefreshPropMap, VimPropMaps::EventMonitorPropMap, VimPropMaps::FullPropMap, VimPropMaps::PropMapVCenter, VimPropMaps::UpdatePropMapsByType, VimPropMaps::VimCoreUpdaterPropMap

Instance Attribute Summary collapse

Attributes inherited from MiqVimClientBase

#connId, #password, #server, #username

Attributes inherited from VimService

#about, #apiVersion, #isVirtualCenter, #serviceInstanceMor, #session_cookie, #sic, #v2, #v20, #v4, #v5, #v6

Class Method Summary collapse

Instance Method Summary collapse

Methods included from MiqVimObjectSet

#objectSet

Methods included from MiqVimDump

#dumpAll, #dumpArray, #dumpClass, #dumpHash, #dumpHostInfo, #dumpMors, #dumpObj, #dumpToLog=, #globalIndent=, #indentedPrint

Methods included from VimPropMaps

#dupProps

Methods inherited from MiqVimClientBase

#acquireCloneTicket, #connect, #currentServerTime, #disconnect, #receiveTimeout, receiveTimeout, #receiveTimeout=, receiveTimeout=, #sdk_uri, #verify_callback

Methods inherited from VimService

#acquireCloneTicket, #acquireMksTicket, #acquireTicket, #addHost_Task, #addInternetScsiSendTargets, #addInternetScsiStaticTargets, #addStandaloneHost_Task, #cancelWaitForUpdates, #cloneVM_Task, #continueRetrievePropertiesEx, #createAlarm, #createCollectorForEvents, #createCustomizationSpec, #createFilter, #createFolder, #createNasDatastore, #createSnapshot_Task, #createVM_Task, #currentTime, #customizationSpecItemToXml, #deleteCustomizationSpec, #deselectVnicForNicType, #destroyCollector, #destroyPropertyFilter, #destroy_Task, #disableRuleset, #doesCustomizationSpecExist, #enableRuleset, #enterMaintenanceMode_Task, #exitMaintenanceMode_Task, #getAlarm, #getCustomizationSpec, #login, #logout, #markAsTemplate, #markAsVirtualMachine, #migrateVM_Task, #moveIntoFolder_Task, #powerDownHostToStandBy_Task, #powerOffVM_Task, #powerOnVM_Task, #powerUpHostFromStandBy_Task, #queryAvailablePerfMetric, #queryDescriptions, #queryDvsConfigTarget, #queryNetConfig, #queryOptions, #queryPerf, #queryPerfComposite, #queryPerfProviderSummary, #readNextEvents, #readPreviousEvents, #rebootGuest, #rebootHost_Task, #reconfigVM_Task, #reconfigureAlarm, #refreshFirewall, #refreshNetworkSystem, #refreshServices, #registerVM_Task, #relocateVM_Task, #removeAlarm, #removeAllSnapshots_Task, #removeSnapshot_Task, #renameSnapshot, #rename_Task, #resetCollector, #resetVM_Task, #restartService, #retrieveProperties, #retrievePropertiesCompat, #retrievePropertiesEx, #retrievePropertiesIter, #retrieveServiceContent, #revertToCurrentSnapshot_Task, #revertToSnapshot_Task, #rewindCollector, #searchDatastoreSubFolders_Task, #searchDatastore_Task, #selectVnicForNicType, #setCollectorPageSize, #setField, #setTaskDescription, #setTaskState, #shutdownGuest, #shutdownHost_Task, #standbyGuest, #startService, #stopService, #suspendVM_Task, #uninstallService, #unregisterVM, #updateDefaultPolicy, #updateServicePolicy, #updateSoftwareInternetScsiEnabled, #waitForUpdates, #waitForUpdatesEx, #xmlToCustomizationSpecItem

Constructor Details

#initialize(server, username, password, cacheScope = nil) ⇒ MiqVimInventory

Returns a new instance of MiqVimInventory.



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 21

def initialize(server, username, password, cacheScope = nil)
  super(server, username, password)

  cacheScope ||= @@cacheScope

  case cacheScope
  when :cache_scope_full
    @propMap = FullPropMap
    $vim_log.info "MiqVimInventory: using property map FullPropMap"
  when :cache_scope_ems_refresh
    @propMap = EmsRefreshPropMap
    $vim_log.info "MiqVimInventory: using property map EmsRefreshPropMap"
  when :cache_scope_core
    @propMap = CorePropMap
    $vim_log.info "MiqVimInventory: using property map CorePropMap"
  when :cache_scope_event_monitor
    @propMap = EventMonitorPropMap
    $vim_log.info "MiqVimInventory: using property map EventMonitorPropMap"
  else
    @propMap = FullPropMap
    $vim_log.info "MiqVimInventory: unrecognized cache scope #{cacheScope}, using FullPropMap"
  end

  # If we are connected to a virtual center then we can access additional properties
  @propMap.merge!(PropMapVCenter) if isVirtualCenter && cacheScope != :cache_scope_event_monitor

  @propCol    = @sic.propertyCollector
  @rootFolder = @sic.rootFolder
  @objectSet  = objectSet
  @spec       = spec
  @updateSpec = updateSpec

  @globalIndent         = ""
  @selectorHash         = @@selectorHash
  @selectorPropPathHash = {}

  @cacheLock  = Sync.new
  @configLock = Sync.new

  resetCache
  __connect
  @alive = true
end

Instance Attribute Details

#cacheLock ⇒ Object (readonly)

Returns the value of attribute cacheLock.



9
10
11
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 9

def cacheLock
  @cacheLock
end

#configLock ⇒ Object (readonly)

Returns the value of attribute configLock.



9
10
11
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 9

def configLock
  @configLock
end

Class Method Details

.cacheScope ⇒ Object 



75
76
77
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 75

def self.cacheScope
  @@cacheScope
end

.cacheScope=(val) ⇒ Object 



79
80
81
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 79

def self.cacheScope=(val)
  @@cacheScope = val
end

.dsPath?(p) ⇒ Boolean

Datastore/path utility methods.

Returns:

  • (Boolean) 


2016
2017
2018
2019
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2016

def self.dsPath?(p)
  return true if p =~ /^\[[^\]]*\].*/
  false
end

.dsRelativePath(p) ⇒ Object 



2060
2061
2062
2063
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2060

def self.dsRelativePath(p)
  raise "dsRelativePath: #{p} is not a datastore path" unless dsPath?(p)
  p.gsub(/^.*\]\s*/, '')
end

.path2dsName(p) ⇒ Object 



2025
2026
2027
2028
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2025

def self.path2dsName(p)
  return nil unless MiqVimInventory.dsPath?(p)
  p.gsub(/^\[([^\]]*)\].*/, '\1')
end

.removeSelector(selName) ⇒ Object 



2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2461

def self.removeSelector(selName)
  remKeys = nil
  if selName.kind_of?(Symbol)
    remKeys = [selName]
  elsif selName.kind_of?(Hash)
    remKeys = selName.keys
  elsif selName.kind_of?(Array)
    remKeys = selName
  else
    raise "MiqVimBroker.removeSelector: selName must be a symbol, hash or array, received #{selName.class}"
  end
  remKeys.each do |rk|
    raise "MiqVimBroker.removeSelector: keys must be symbols, received #{rk.class}" unless rk.kind_of?(Symbol)
  end

  remKeys.each do |rk|
    @@selectorHash.delete(rk)
  end
end

.setSelector(selSpec) ⇒ Object 



2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2439

def self.setSelector(selSpec)
  raise "MiqVimBroker.setSelector: selSpec must be a hash, received #{selSpec.class}" unless selSpec.kind_of?(Hash)
  selSpec.each_key do |k|
    raise "MiqVimBroker.setSelector: selSpec keys must be symbols, received #{k.class}" unless k.kind_of?(Symbol)
  end
  ov = nil
  selSpec.each_value do |v|
    if v.kind_of?(Array)
      v.each do |vv|
        unless vv.kind_of?(String)
          ov = vv
          break
        end
      end
    else
      ov = v unless v.kind_of?(String)
    end
    raise "MiqVimBroker.setSelector: selSpec values must be strings or arrays of strings, received #{ov.class}" unless ov.nil?
  end
  @@selectorHash.merge!(selSpec)
end

Instance Method Details

#addDataStore(dsMor) ⇒ Object 



1467
1468
1469
1470
1471
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1467

def addDataStore(dsMor)
  @cacheLock.synchronize(:EX) do
    addObjByMor(dsMor)
  end
end

#addDataStoreObj(dsObj) ⇒ Object 



1473
1474
1475
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1473

def addDataStoreObj(dsObj)
  addObjHash(:Datastore, dsObj)
end

#addDVPObj(dvpObj) ⇒ Object 



1561
1562
1563
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1561

def addDVPObj(dvpObj)
  addObjHash(:DistributedVirtualPortgroup, dvpObj)
end

#addDVSObj(dvsObj) ⇒ Object 



1655
1656
1657
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1655

def addDVSObj(dvsObj)
  addObjHash(:DistributedVirtualSwitch, dvsObj)
end

#addExtensionManager(extensionManagerMor) ⇒ Object 



1943
1944
1945
1946
1947
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1943

def addExtensionManager(extensionManagerMor)
  @cacheLock.synchronize(:EX) do
    return(addObjByMor(extensionManagerMor))
  end
end

#addHostSystem(hsMor) ⇒ Object 



1344
1345
1346
1347
1348
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1344

def addHostSystem(hsMor)
  @cacheLock.synchronize(:EX) do
    addObjByMor(hsMor)
  end
end

#addHostSystemObj(hsObj) ⇒ Object 



1350
1351
1352
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1350

def addHostSystemObj(hsObj)
  addObjHash(:HostSystem, hsObj)
end

#addLicenseManager(licenseManagerMor) ⇒ Object 



1833
1834
1835
1836
1837
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1833

def addLicenseManager(licenseManagerMor)
  @cacheLock.synchronize(:EX) do
    return(addObjByMor(licenseManagerMor))
  end
end

#addObjByMor(objMor) ⇒ Object

Extract the properties for the VIM object represented by objMor and hash them. Add the resulting property hash to the appropriate inventory hashes.



389
390
391
392
393
394
395
396
397
398
399
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 389

def addObjByMor(objMor)
  raise "addObjByMor: exclusive cache lock not held"      unless @cacheLock.sync_exclusive?
  objType = objMor.vimBaseType.to_sym
  raise "addObjByMor: Unknown VIM object type: #{objType}"  unless (pmap = @propMap[objType])

  objHash = getMoProp_local(objMor, pmap[:props])
  return nil unless objHash

  addObjHash(objType, objHash)
  objHash
end

#addObjHash(objType, objHash) ⇒ Object

Add the property hash for the VIM object to the appropriate inventory hashes.



306
307
308
309
310
311
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 306

def addObjHash(objType, objHash)
  raise "addObjHash: exclusive cache lock not held" unless @cacheLock.sync_exclusive?

  objHash = hashObj(objType, objHash)
  objFixUp(objType, objHash)
end

#addProperty(key, property) ⇒ Object

def initialize



65
66
67
68
69
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 65

def addProperty(key, property)
  return if (pm = @propMap[key]).nil?
  property.split('.').each { |p| return if pm.include?(p) }
  @propMap[key][:props] << property
end

#addStoragePodObj(spObj) ⇒ Object 



1742
1743
1744
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1742

def addStoragePodObj(spObj)
  addObjHash(:StoragePod, spObj)
end

#addToCollection(hash, tag, val) ⇒ Object 



2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2767

def addToCollection(hash, tag, val)
  unless (array = hash[tag])
    array = VimArray.new
    if (type = val.xsiType)
      nh            = VimHash.new
      array.xsiType = "ArrayOf#{type}"
      nh[type]      = array
      hash[tag]     = nh
    end
    hash[tag] = array
  end
  array << val
end

#addVirtualMachine(vmMor) ⇒ Object 



579
580
581
582
583
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 579

def addVirtualMachine(vmMor)
  @cacheLock.synchronize(:EX) do
    return(addObjByMor(vmMor))
  end
end

#allPropsFromCache(hashName, props) ⇒ Object 



437
438
439
440
441
442
443
444
445
446
447
448
449
450
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 437

def allPropsFromCache(hashName, props)
  props = [props] if props.kind_of?(String)
  @cacheLock.synchronize(:SH) do
    ret = {}
    send((hashName + "_locked").to_sym).each do |key, cv|
      props.each do |pn|
        cv = cv[pn]
        break unless cv
      end
      ret[key] = cv
    end
    return(dupObj(ret))
  end
end

#applyFilter(objArr, propFilter) ⇒ Object 



2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2627

def applyFilter(objArr, propFilter)
  retArr = []

  objArr.each do |obj|
    match = true
    propFilter.each do |pn, pv|
      pVal = propValue(obj, pn)
      if pVal.kind_of?(Array)
        nxt = false
        pVal.each do |v|
          if pv === v
            nxt = true
            break
          end
        end
        next if nxt
      else
        next if pv === pVal
      end

      match = false
      break
    end
    retArr << obj if match
  end
  retArr
end

#applySelector(topObj, selSpec) ⇒ Object 



2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2568

def applySelector(topObj, selSpec)
  selSpec = getSelSpec(selSpec)

  if topObj.kind_of?(VimHash)
    retObj = VimHash.new(topObj.xsiType, topObj.vimType)

    selSpec.each do |cs|
      applySelSpec(topObj, retObj, splitPropPath(cs))
    end
  #
  # When passed a collection of objects at the top level, apply
  # the selSpec to each object in the collection, returning a
  # new collection of new objects.
  #
  elsif topObj.kind_of?(Hash)
    retObj = {}
    topObj.each do |k, v|
      retObj[k] = applySelector(v, selSpec)
    end
  elsif topObj.kind_of?(VimArray)
    retObj = VimArray.new(topObj.xsiType, topObj.vimType)
    topObj.each do |v|
      retObj << applySelector(v, selSpec)
    end
  end

  retObj
end

#applySelSpec(topObj, retObj, pa) ⇒ Object 



2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2597

def applySelSpec(topObj, retObj, pa)
  prop, arrayKey = tagAndKey(pa.first)
  return unless topObj.kind_of?(Hash) && topObj.key?(prop)
  nextTopObj = topObj[prop]
  return if nextTopObj.nil?

  if pa.length == 1
    retObj[prop] = nextTopObj
    return
  end

  nextpa = pa[1..-1]

  if arrayKey == "*"
    raise "applySelSpec: #{pa.first} is not an array." unless nextTopObj.kind_of?(Array)
    retObj[prop] = VimArray.new(nextTopObj.xsiType, nextTopObj.vimType) if retObj[prop].nil?
    nextRetObj   = retObj[prop]

    nextTopObj.each_with_index do |ntoe, i|
      if (nroe = nextRetObj[i]).nil?
        nroe = nextRetObj[i] = VimHash.new(ntoe.xsiType, ntoe.vimType)
      end
      applySelSpec(ntoe, nroe, nextpa)
    end
  else
    retObj[prop] = VimHash.new(nextTopObj.xsiType, nextTopObj.vimType) if retObj[prop].nil?
    applySelSpec(nextTopObj, retObj[prop], nextpa)
  end
end

#assert_no_locks ⇒ Object 



203
204
205
206
207
208
209
210
211
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 203

def assert_no_locks
  return unless @lock_debug
  return unless @cacheLock.sync_locked?
  msg = ""
  msg += "Exclusive cache lock held\n" if @cacheLock.sync_exclusive?
  msg += "Shared cache lock held\n" if @cacheLock.sync_shared?
  msg += Kernel.caller.join("\n")
  raise msg
end

#browseDiagnosticLog(key, start = nil, lines = nil, host = nil) ⇒ Object 



2127
2128
2129
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2127

def browseDiagnosticLog(key, start = nil, lines = nil, host = nil)
  super(@sic.diagnosticManager, host, key, start, lines)
end

#browseDiagnosticLogEx(key, start = nil, lines = nil, host = nil) ⇒ Object 



2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2131

def browseDiagnosticLogEx(key, start = nil, lines = nil, host = nil)
  # Continually loop over the browseDiagnosticLog to get the number of lines
  #   requested, since it returns 1000 lines by default, even if specified
  #   to be higher.  Setting lines to nil returns all lines, as per the
  #   documentation.
  rv = nil
  next_start = (start || 1)
  lines_left = lines

  loop do
    l = browseDiagnosticLog(key, next_start, lines_left, host)
    l['lineText'] ||= []

    unless rv.nil?
      rv['lineText'] += l['lineText']
    else
      rv = l
      rv['lineStart'] = rv['lineStart'].to_i
    end

    read_lines = l['lineText'].length
    break if read_lines != 1000
    if lines
      lines_left -= read_lines
      break if lines_left <= 0
    end

    next_start += read_lines
  end

  rv['lineText'] = rv['lineText'][0..lines - 1] if lines && rv['lineText'].length > lines
  rv['lineEnd'] = rv['lineStart'] + rv['lineText'].length - 1
  rv
end

#cacheStats(pref) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 101

def cacheStats(pref)
  totalCacheSz = 0
  @cacheLock.synchronize(:SH) do
    @propMap.each_value do |pm|
      hn        = pm[:baseName]
      hnm       = pm[:baseName] + "ByMor"
      hashByMor = instance_variable_get(hnm)
      hashByKey = pm[:keyPath] ? instance_variable_get(hn) : nil

      if hashByMor.nil?
        $vim_log.info "#{pref}#{hnm}: is nil"
        next
      end

      keya = hashByMor.keys
      obja = hashByMor.values
      $vim_log.info "#{pref}#{hnm}: #keys = #{keya.length}"
      $vim_log.info "#{pref}#{hnm}: #objects = #{obja.length}"
      obja.compact!
      obja.uniq!
      $vim_log.info "#{pref}#{hnm}: #unique non-nill objects = #{obja.length}"

      unless hashByKey.nil?
        keyb = hashByKey.keys
        objb = hashByKey.values
        $vim_log.info "#{pref}#{hn}: #keys = #{keyb.length}"
        $vim_log.info "#{pref}#{hn}: #objects = #{objb.length}"
        objb.compact!
        objb.uniq!
        $vim_log.info "#{pref}#{hn}: #unique non-nill objects = #{objb.length}"
        obja.concat(objb).uniq!
      end
      $vim_log.info "#{pref}TOTAL: #unique non-nill objects = #{obja.length}"
      cacheSz = Marshal.dump(obja).length
      $vim_log.info "#{pref}TOTAL: size of objects = #{cacheSz}"
      $vim_log.info "#{pref}****"
      totalCacheSz += cacheSz
    end
    $vim_log.info "#{pref}****************"
    $vim_log.info "#{pref}TOTAL: cache size = #{totalCacheSz}"
    $vim_log.info "#{pref}****************"
  end
  totalCacheSz
end

#cancelTask(tmor) ⇒ Object 



2196
2197
2198
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2196

def cancelTask(tmor)
  super(getTaskMor(tmor))
end

#clusterComputeResourceByMor(ccrMor, selSpec = nil) ⇒ Object

Return a single clusterComputeResource object, given its MOR



786
787
788
789
790
791
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 786

def clusterComputeResourceByMor(ccrMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(clusterComputeResourcesByMor_locked[ccrMor])) if selSpec.nil?
    return(applySelector(clusterComputeResourcesByMor_locked[ccrMor], selSpec))
  end
end

#clusterComputeResources(selSpec = nil) ⇒ Object

Public accessor



754
755
756
757
758
759
760
761
762
763
764
765
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 754

def clusterComputeResources(selSpec = nil)
  ccrs = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      ccrs = dupObj(clusterComputeResources_locked)
    else
      ccrs = applySelector(clusterComputeResources_locked, selSpec)
    end
  end
  assert_no_locks
  ccrs
end

#clusterComputeResourcesByFilter(filter) ⇒ Object

Public accessor

Return an array of cluster compute resource objects that match the given property filter.



798
799
800
801
802
803
804
805
806
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 798

def clusterComputeResourcesByFilter(filter)
  crs = nil
  @cacheLock.synchronize(:SH) do
    crs = applyFilter(clusterComputeResourcesByMor_locked.values, filter)
    crs = dupObj(crs)
  end
  assert_no_locks
  crs
end

#clusterComputeResourcesByMor(selSpec = nil) ⇒ Object

Public accessor



770
771
772
773
774
775
776
777
778
779
780
781
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 770

def clusterComputeResourcesByMor(selSpec = nil)
  ccrs = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      ccrs = dupObj(clusterComputeResourcesByMor_locked)
    else
      ccrs = applySelector(clusterComputeResourcesByMor_locked, selSpec)
    end
  end
  assert_no_locks
  ccrs
end

#computeResourceByMor(crMor, selSpec = nil) ⇒ Object

Return a single computeResource object, given its MOR



683
684
685
686
687
688
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 683

def computeResourceByMor(crMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(computeResourcesByMor_locked[crMor])) if selSpec.nil?
    return(applySelector(computeResourcesByMor_locked[crMor], selSpec))
  end
end

#computeResources(selSpec = nil) ⇒ Object

Public accessor



651
652
653
654
655
656
657
658
659
660
661
662
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 651

def computeResources(selSpec = nil)
  crs = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      crs = dupObj(computeResources_locked)
    else
      crs = applySelector(computeResources_locked, selSpec)
    end
  end
  assert_no_locks
  crs
end

#computeResourcesByFilter(filter) ⇒ Object

Public accessor

Return an array of compute resource objects that match the given property filter.



695
696
697
698
699
700
701
702
703
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 695

def computeResourcesByFilter(filter)
  crs = nil
  @cacheLock.synchronize(:SH) do
    crs = applyFilter(computeResourcesByMor_locked.values, filter)
    crs = dupObj(crs)
  end
  assert_no_locks
  crs
end

#computeResourcesByMor(selSpec = nil) ⇒ Object

Public accessor



667
668
669
670
671
672
673
674
675
676
677
678
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 667

def computeResourcesByMor(selSpec = nil)
  crs = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      crs = dupObj(computeResourcesByMor_locked)
    else
      crs = applySelector(computeResourcesByMor_locked, selSpec)
    end
  end
  assert_no_locks
  crs
end

#conditionalCopy(obj) ⇒ Object

When used in the broker - DRB - this method is redefined to create a deep clone of the object.



2834
2835
2836
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2834

def conditionalCopy(obj)
  obj
end

#currentSession ⇒ Object

def resetCache



234
235
236
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 234

def currentSession
  getMoProp(@sic.sessionManager, "currentSession")
end

#datacenterByMor(dcMor, selSpec = nil) ⇒ Object

Return a single datacenter object, given its MOR



1207
1208
1209
1210
1211
1212
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1207

def datacenterByMor(dcMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(datacentersByMor_locked[dcMor])) if selSpec.nil?
    return(applySelector(datacentersByMor_locked[dcMor], selSpec))
  end
end

#datacenters(selSpec = nil) ⇒ Object

Public accessor



1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1175

def datacenters(selSpec = nil)
  dc = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      dc = dupObj(datacenters_locked)
    else
      dc = applySelector(datacenters_locked, selSpec)
    end
  end
  assert_no_locks
  dc
end

#datacentersByFilter(filter) ⇒ Object

Public accessor

Return an array of datacenter objects that match the given property filter.



1219
1220
1221
1222
1223
1224
1225
1226
1227
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1219

def datacentersByFilter(filter)
  dc = nil
  @cacheLock.synchronize(:SH) do
    dc = applyFilter(datacentersByMor_locked.values, filter)
    dc = dupObj(dc)
  end
  assert_no_locks
  dc
end

#datacentersByMor(selSpec = nil) ⇒ Object

Public accessor



1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1191

def datacentersByMor(selSpec = nil)
  dc = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      dc = dupObj(datacentersByMor_locked)
    else
      dc = applySelector(datacentersByMor_locked, selSpec)
    end
  end
  assert_no_locks
  dc
end

#dataStoreByMor(dsMor, selSpec = nil) ⇒ Object

Return a single hostSystem object, given its MOR



1435
1436
1437
1438
1439
1440
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1435

def dataStoreByMor(dsMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(dataStoresByMor_locked[dsMor])) if selSpec.nil?
    return(applySelector(dataStoresByMor_locked[dsMor], selSpec))
  end
end

#datastorePath(p) ⇒ Object

def localVmPath



2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2085

def datastorePath(p)
  return p if dsPath?(p)

  drp = nil
  @cacheLock.synchronize(:SH) do
    dataStores_locked.each do |n, o|
      if p[o['summary']['url']]
        drp = p.dup
        drp[o['summary']['url']] = "[#{n}] "
        break
      end
    end
  end
  raise "datastorePath: Could not find datastore for path #{p}" unless drp
  drp
end

#dataStores(selSpec = nil) ⇒ Object

Public accessor



1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1403

def dataStores(selSpec = nil)
  ds = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      ds = dupObj(dataStores_locked)
    else
      ds = applySelector(dataStores_locked, selSpec)
    end
  end
  assert_no_locks
  ds
end

#dataStoresByFilter(filter) ⇒ Object

Public accessor

Return an array of data store objects that match the given property filter.



1447
1448
1449
1450
1451
1452
1453
1454
1455
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1447

def dataStoresByFilter(filter)
  ds = nil
  @cacheLock.synchronize(:SH) do
    ds = applyFilter(dataStoresByMor_locked.values, filter)
    ds = dupObj(ds)
  end
  assert_no_locks
  ds
end

#dataStoresByFilter_local(filter) ⇒ Object 



1457
1458
1459
1460
1461
1462
1463
1464
1465
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1457

def dataStoresByFilter_local(filter)
  ds = nil
  @cacheLock.synchronize(:SH) do
    ds = applyFilter(dataStoresByMor_locked.values, filter)
    ds = deepClone(ds)
  end
  assert_no_locks
  ds
end

#dataStoresByMor(selSpec = nil) ⇒ Object

Public accessor



1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1419

def dataStoresByMor(selSpec = nil)
  ds = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      ds = dupObj(dataStoresByMor_locked)
    else
      ds = applySelector(dataStoresByMor_locked, selSpec)
    end
  end
  assert_no_locks
  ds
end

#deepClone(obj) ⇒ Object 



2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2838

def deepClone(obj)
  return nil unless obj
  nObj = obj.class.new
  nObj.vimType = obj.vimType if obj.respond_to?(:vimType)
  nObj.xsiType = obj.xsiType if obj.respond_to?(:xsiType)

  if obj.kind_of?(Hash)
    obj.each { |k, v| nObj[k] = deepClone(v) }
  elsif obj.kind_of?(Array)
    obj.each { |v| nObj << deepClone(v) }
  elsif obj.kind_of?(String)
    nObj.replace(obj)
  else
    raise "deepClone: unexpected object #{obj.class}"
  end

  nObj
end

#deleteProperty(key, property) ⇒ Object 



71
72
73
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 71

def deleteProperty(key, property)
  @propMap[key][:props].delete(property) unless @propMap[key].nil?
end

#dsName2mo(dsn) ⇒ Object 



2042
2043
2044
2045
2046
2047
2048
2049
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2042

def dsName2mo(dsn)
  ret = nil
  @cacheLock.synchronize(:SH) do
    ret = dupObj(dataStores_locked[dsn]['summary']["datastore"])
  end
  assert_no_locks
  ret
end

#dsName2mo_local(dsn) ⇒ Object 



2051
2052
2053
2054
2055
2056
2057
2058
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2051

def dsName2mo_local(dsn)
  ret = nil
  @cacheLock.synchronize(:SH) do
    ret = dataStores_locked[dsn]['summary']["datastore"]
  end
  assert_no_locks
  ret
end

#dsName2path(dsn) ⇒ Object 



2034
2035
2036
2037
2038
2039
2040
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2034

def dsName2path(dsn)
  ret = nil
  @cacheLock.synchronize(:SH) do
    ret = dataStores_locked[dsn]['summary']["url"]
  end
  ret
end

#dsPath?(p) ⇒ Boolean

Returns:

  • (Boolean) 


2021
2022
2023
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2021

def dsPath?(p)
  MiqVimInventory.dsPath?(p)
end

#dsRelativePath(p) ⇒ Object 



2065
2066
2067
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2065

def dsRelativePath(p)
  MiqVimInventory.dsRelativePath(p)
end

#dupObj(obj) ⇒ Object

When used in the broker - DRB - this method is redefined to carry the cacheLock into the DRB dump method.

When not used in the broker, there is no need to copy the object.



2826
2827
2828
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2826

def dupObj(obj)
  obj
end

#dvPortgroupByMor(dvpMor, selSpec = nil) ⇒ Object

Return a single storagePod object, given its MOR



1554
1555
1556
1557
1558
1559
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1554

def dvPortgroupByMor(dvpMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(dvPortgroupsByMor_locked[dvpMor])) if selSpec.nil?
    return(applySelector(dvPortgroupsByMor_locked[dvpMor], selSpec))
  end
end

#dvPortgroups(selSpec = nil) ⇒ Object

Public accessor



1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1522

def dvPortgroups(selSpec = nil)
  dvp = nil
  @cacheLock.synchronize(:SH) do
    dvp = if selSpec.nil?
            dupObj(dvPortgroups_locked)
          else
            applySelector(dvPortgroups_locked, selSpec)
          end
  end
  assert_no_locks
  dvp
end

#dvPortgroupsByMor(selSpec = nil) ⇒ Object

Public accessor



1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1538

def dvPortgroupsByMor(selSpec = nil)
  dvp = nil
  @cacheLock.synchronize(:SH) do
    dvp = if selSpec.nil?
            dupObj(dvPortgroupsByMor_locked)
          else
            applySelector(dvPortgroupsByMor_locked, selSpec)
          end
  end
  assert_no_locks
  dvp
end

#dvSwitchByMor(dvsMor, selSpec = nil) ⇒ Object

Return a single DV Switch object, given its MOR



1648
1649
1650
1651
1652
1653
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1648

def dvSwitchByMor(dvsMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(dvSwitchesByMor_locked[dvsMor])) if selSpec.nil?
    return(applySelector(dvSwitchesByMor_locked[dvsMor], selSpec))
  end
end

#dvSwitches(selSpec = nil) ⇒ Object

Public accessor



1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1616

def dvSwitches(selSpec = nil)
  dvs = nil
  @cacheLock.synchronize(:SH) do
    dvs = if selSpec.nil?
            dupObj(dvSwitches_locked)
          else
            applySelector(dvSwitches_locked, selSpec)
          end
  end
  assert_no_locks
  dvs
end

#dvSwitchesByMor(selSpec = nil) ⇒ Object

Public accessor



1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1632

def dvSwitchesByMor(selSpec = nil)
  dvs = nil
  @cacheLock.synchronize(:SH) do
    dvs = if selSpec.nil?
            dupObj(dvSwitchesByMor_locked)
          else
            applySelector(dvSwitchesByMor_locked, selSpec)
          end
  end
  assert_no_locks
  dvs
end

#extensionManagerByMor(extensionManagerMor, selSpec = nil) ⇒ Object

Return a single Extension Manager object, given its MOR



1921
1922
1923
1924
1925
1926
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1921

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

#extensionManagersByFilter(filter) ⇒ Object

Public accessor

Return an array of extension manager objects that match the given property filter.



1933
1934
1935
1936
1937
1938
1939
1940
1941
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1933

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

#extensionManagersByMor(selSpec = nil) ⇒ Object

Public accessor



1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1905

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

#folderByMor(fMor, selSpec = nil) ⇒ Object

Return a single folder object, given its MOR



1104
1105
1106
1107
1108
1109
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1104

def folderByMor(fMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(foldersByMor_locked[fMor])) if selSpec.nil?
    return(applySelector(foldersByMor_locked[fMor], selSpec))
  end
end

#folders(selSpec = nil) ⇒ Object

Public accessor



1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1072

def folders(selSpec = nil)
  f = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      f = dupObj(folders_locked)
    else
      f = applySelector(folders_locked, selSpec)
    end
  end
  assert_no_locks
  f
end

#foldersByFilter(filter) ⇒ Object

Public accessor

Return an array of folder objects that match the given property filter.



1116
1117
1118
1119
1120
1121
1122
1123
1124
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1116

def foldersByFilter(filter)
  f = nil
  @cacheLock.synchronize(:SH) do
    f = applyFilter(foldersByMor_locked.values, filter)
    f = dupObj(f)
  end
  assert_no_locks
  f
end

#foldersByMor(selSpec = nil) ⇒ Object

Public accessor



1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1088

def foldersByMor(selSpec = nil)
  f = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      f = dupObj(foldersByMor_locked)
    else
      f = applySelector(foldersByMor_locked, selSpec)
    end
  end
  assert_no_locks
  f
end

#getMoProp(mo, path = nil) ⇒ Object

Public accessor



2359
2360
2361
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2359

def getMoProp(mo, path = nil)
  getMoProp_local(mo, path)
end

#getMoProp_local(mo, path = nil) ⇒ Object

Retrieve the properties for a single object, given its managed object reference.



2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2302

def getMoProp_local(mo, path = nil)
  pfSpec = VimHash.new("PropertyFilterSpec") do |pfs|
    pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
      psa << VimHash.new("PropertySpec") do |ps|
        ps.type = mo.vimType
        if !path
          ps.all = "true"
        else
          ps.all = "false"
          ps.pathSet = path
        end
      end
    end
    pfs.objectSet = VimArray.new("ArrayOfObjectSpec") do |osa|
      osa << VimHash.new("ObjectSpec") do |os|
        os.obj = mo
      end
    end
  end

  $vim_log.info "MiqVimInventory(#{@server}, #{@username}).getMoProp_local: calling retrieveProperties(#{mo.vimType})" if $vim_log
  oca = retrievePropertiesCompat(@propCol, pfSpec)
  $vim_log.info "MiqVimInventory(#{@server}, #{@username}).getMoProp_local: return from retrieveProperties(#{mo.vimType})" if $vim_log

  return nil if !oca || !oca[0] || !oca[0].propSet

  oc = oca[0]
  oc.MOR = oc.obj
  oc.delete('obj')

  oc.propSet = Array(oc.propSet) unless oc.propSet.kind_of?(Array)
  oc.propSet.each do |ps|
    #
    # Here, ps.name can be a property path in the form: a.b.c
    # If that's the case, we should set the target to: propHash['a']['b']['c']
    # creating intermediate nodes as needed.
    #
    h, k = hashTarget(oc, ps.name)
    if !h[k]
      h[k] = ps.val
    elsif h[k].kind_of? Array
      h[k] << ps.val
    else
      h[k] = VimArray.new do |arr|
        arr << h[k]
        arr << ps.val
      end
    end
  end # oc.propSet.each
  oc.delete('propSet')

  oc
end

#getMoPropMulti(moa, path = nil) ⇒ Object

Retrieve the properties for multiple objects of the same type, given an array of managed object references.



2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2367

def getMoPropMulti(moa, path = nil)
  return [] if !moa || moa.empty?
  tmor = moa.first
  raise "getMoPropMulti: item is not a managed object reference" unless tmor.respond_to? :vimType

  args = VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
    pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
      pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
        psa << VimHash.new("PropertySpec") do |ps|
          ps.type = tmor.vimType
          if !path
            ps.all = "true"
          else
            ps.all = "false"
            ps.pathSet = path
          end
        end
      end

      pfs.objectSet = VimArray.new("ArrayOfObjectSpec") do |osa|
        moa.each do |mor|
          VimHash.new("ObjectSpec") do |os|
            os.obj = mor
            osa << os
          end
        end
      end
    end
  end

  oca = VimArray.new('ArrayOfObjectContent')

  retrievePropertiesIter(@propCol, args) do |oc|
    oc.MOR = oc.obj
    oc.delete('obj')

    oc.propSet = Array(oc.propSet) unless oc.propSet.kind_of?(Array)
    oc.propSet.each do |ps|
      #
      # Here, ps.name can be a property path in the form: a.b.c
      # If that's the case, we should set the target to: propHash['a']['b']['c']
      # creating intermediate nodes as needed.
      #
      h, k = hashTarget(oc, ps.name)
      if !h[k]
        h[k] = ps.val
      elsif h[k].kind_of? Array
        h[k] << ps.val
      else
        h[k] = VimArray.new do |arr|
          arr << h[k]
          arr << ps.val
        end
      end
    end # oc.propSet.each
    oc.delete('propSet')

    oca << oc
  end

  oca
end

#getMoPropMultiIter(moa, path = nil) ⇒ Object

def getMoPropMulti



2430
2431
2432
2433
2434
2435
2436
2437
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2430

def getMoPropMultiIter(moa, path = nil)
  oca = []
  moa.each do |mo|
    oc = getMoProp_local(mo, path)
    oca << oc if oc
  end
  oca
end

#getSelector(selName) ⇒ Object 



2506
2507
2508
2509
2510
2511
2512
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2506

def getSelector(selName)
  raise "getSelector: selName must be a symbol, received #{selName.class}" unless selName.kind_of?(Symbol)

  @configLock.synchronize(:SH) do
    return @selectorHash[selName]
  end
end

#getSelSpec(selSpec) ⇒ Object 



2537
2538
2539
2540
2541
2542
2543
2544
2545
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2537

def getSelSpec(selSpec)
  ss = selSpec
  if ss.kind_of?(Symbol)
    ss = getSelector(ss)
    raise "getSelSpec: selector #{selSpec} not found" if ss.nil?
  end
  ss = [] if ss.nil?
  ss.kind_of?(Array) ? ss : [ss]
end

#getTaskMor(tmor) ⇒ Object 



2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2180

def getTaskMor(tmor)
  if tmor.respond_to?(:vimType)
    $vim_log.debug "getTaskMor: returning #{tmor}, no search"
    return tmor
  else
    $vim_log.debug "getTaskMor: searching for task #{tmor}"
    getTasks.each do |tmo|
      if tmo.to_str == tmor
        $vim_log.debug "getTaskMor: returning #{tmo} (#{tmo.vimType})"
        return tmo
      end
    end
    raise "getTaskMor: task #{tmor} not found."
  end
end

#getTasks ⇒ Object

Task utility methods.



2170
2171
2172
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2170

def getTasks
  getMoProp_local(@sic.taskManager, "recentTask")['recentTask']
end

#getTasksByFilter(filter) ⇒ Object

private :getTasks



2175
2176
2177
2178
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2175

def getTasksByFilter(filter)
  ta = applyFilter(getMoPropMulti(getTasks, 'info'), filter)
  dupObj(ta)
end

#hasProp?(baseHash, prop) ⇒ Boolean

Returns:

  • (Boolean) 


2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2674

def hasProp?(baseHash, prop)
  return baseHash.key?(prop) unless prop.index('.')

  h  = baseHash
  ka = splitPropPath(prop)
  ka[0...-1].each do |k|
    k, arrayKey = tagAndKey(k)
    if arrayKey
      array, idx = getVimArrayEnt(h[k], arrayKey, false)
      return(false) unless array
      h = array[idx]
    else
      return(false) unless h[k]
      h = h[k]
    end
  end
  h.key?(ka[-1])
end

#hostSystemByMor(hsMor, selSpec = nil) ⇒ Object

Return a single hostSystem object, given its MOR



1310
1311
1312
1313
1314
1315
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1310

def hostSystemByMor(hsMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(hostSystemsByMor_locked[hsMor])) if selSpec.nil?
    return(applySelector(hostSystemsByMor_locked[hsMor], selSpec))
  end
end

#hostSystems(selSpec = nil) ⇒ Object

Public accessor



1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1278

def hostSystems(selSpec = nil)
  hs = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      hs = dupObj(hostSystems_locked)
    else
      hs = applySelector(hostSystems_locked, selSpec)
    end
  end
  assert_no_locks
  hs
end

#hostSystemsByFilter(filter) ⇒ Object

Public accessor

Return an array of host system objects that match the given property filter.



1322
1323
1324
1325
1326
1327
1328
1329
1330
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1322

def hostSystemsByFilter(filter)
  hs = nil
  @cacheLock.synchronize(:SH) do
    hs = applyFilter(hostSystemsByMor_locked.values, filter)
    hs = dupObj(hs)
  end
  assert_no_locks
  hs
end

#hostSystemsByMor(selSpec = nil) ⇒ Object

Public accessor



1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1294

def hostSystemsByMor(selSpec = nil)
  hs = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      hs = dupObj(hostSystemsByMor_locked)
    else
      hs = applySelector(hostSystemsByMor_locked, selSpec)
    end
  end
  assert_no_locks
  hs
end

#hostSystemsStorageDevice(hostMors, selSpec = nil) ⇒ Object 



1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1332

def hostSystemsStorageDevice(hostMors, selSpec = nil)
  if selSpec.nil?
    sd = getMoPropMulti(hostMors, "config.storageDevice")
  else
    pp = selSpecToPropPath(selSpec)
    sd = getMoPropMulti(hostMors, pp)
    sd = applySelector(sd, selSpec)
  end

  sd
end

#inventoryHash ⇒ Object 



1995
1996
1997
1998
1999
2000
2001
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1995

def inventoryHash
  ih = nil
  @cacheLock.synchronize(:SH) do
    ih = dupObj(inventoryHash_locked)
  end
  ih
end

#inventoryHash_locked ⇒ Object

A hash of managed object references for all the objects we care about.

For internal use. Locking handled by caller



1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1971

def inventoryHash_locked
  raise "inventoryHash_locked: cache lock not held" unless @cacheLock.sync_locked?
  return(@inventoryHash) if @inventoryHash

  $vim_log.info "MiqVimInventory.inventoryHash_locked: loading inventoryHash for #{@connId}"
  begin
    @cacheLock.sync_lock(:EX) if (unlock = @cacheLock.sync_shared?)

    $vim_log.info "MiqVimInventory(#{@server}, #{@username}).inventoryHash_locked: calling retrieveProperties" if $vim_log

    @inventoryHash = {}
    retrievePropertiesIter(@propCol, @spec) do |oc|
      (@inventoryHash[oc.obj.vimType] ||= []) << oc.obj
    end

    $vim_log.info "MiqVimInventory(#{@server}, #{@username}).inventoryHash_locked: returned from retrieveProperties" if $vim_log
  ensure
    @cacheLock.sync_unlock if unlock
  end
  $vim_log.info "MiqVimInventory.inventoryHash_locked: loaded inventoryHash for #{@connId}"

  @inventoryHash
end

#isAlive? ⇒ Boolean

Returns:

  • (Boolean) 


238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 238

def isAlive?
  return false unless @alive
  begin
      unless currentSession
        $vim_log.info "MiqVimInventory.isAlive?: Current session no longer exists."
        @alive = false
      end
    rescue Exception => err
      $vim_log.info "MiqVimInventory.isAlive?: Could not access connection - #{err}"
      @alive = false
    end
  @alive
end

#isDead ⇒ Object

For testing



255
256
257
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 255

def isDead
  @alive = false
end

#isHostAgent? ⇒ Boolean

Returns:

  • (Boolean) 


263
264
265
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 263

def isHostAgent?
  !@isVirtualCenter
end

#isVirtualCenter? ⇒ Boolean

Returns:

  • (Boolean) 


259
260
261
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 259

def isVirtualCenter?
  @isVirtualCenter
end

#keyExistsInCache?(hashName, key) ⇒ Boolean

Returns:

  • (Boolean) 


470
471
472
473
474
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 470

def keyExistsInCache?(hashName, key)
  @cacheLock.synchronize(:SH) do
    return send((hashName + "_locked").to_sym).key?(key)
  end
end

#keyFromCache(hashName, props, value = nil) ⇒ Object 



452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 452

def keyFromCache(hashName, props, value = nil)
  raise "no block given" if value.nil? && !block_given?
  raise "block given with value" if !value.nil? && block_given?

  props = [props] if props.kind_of?(String)
  @cacheLock.synchronize(:SH) do
    ck, = send((hashName + "_locked").to_sym).detect do |_k, v|
      cv = v
      props.each do |pn|
        cv = cv[pn]
        break unless cv
      end
      block_given? ? yield(cv) : cv == value
    end
    return(dupObj(ck))
  end
end

#licenseManagerByMor(licenseManagerMor, selSpec = nil) ⇒ Object

Return a single License Manager object, given its MOR



1811
1812
1813
1814
1815
1816
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1811

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

#licenseManagersByFilter(filter) ⇒ Object

Public accessor

Return an array of license manager objects that match the given property filter.



1823
1824
1825
1826
1827
1828
1829
1830
1831
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1823

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

#licenseManagersByMor(selSpec = nil) ⇒ Object

Public accessor



1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1795

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

#loadCache ⇒ Object 



213
214
215
216
217
218
219
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 213

def loadCache
  @cacheLock.synchronize(:EX) do
    @propMap.each_value do |pm|
      send("#{pm[:baseName][1..-1]}_locked".to_sym)
    end
  end
end

#localVmPath(p) ⇒ Object 



2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2069

def localVmPath(p)
  return p unless dsPath?(p)

  ds   = path2dsName(p)
  path = dsRelativePath(p)

  begin
    dsPath = dsName2path(ds)
  rescue
    return nil
  end

  return dsPath if !path || path == "/"
  File.join(dsPath, path)
end

#logCacheCounts(pref) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 83

def logCacheCounts(pref)
  @cacheLock.synchronize(:SH) do
    @propMap.each_value do |pm|
      hn  = pm[:baseName]
      hnm = pm[:baseName] + "ByMor"

      unless instance_variable_get(hnm).nil?
        hnmc = instance_variable_get(hnm).keys.length
        $vim_log.info "#{pref}#{hnm}: #{hnmc}"
      end
      unless instance_variable_get(hn).nil?
        hnc = instance_variable_get(hn).keys.length
        $vim_log.info "#{pref}#{hn}: #{hnc}"
      end
    end
  end
end

#logUserEvent(entity, msg) ⇒ Object

Generate a user event associated with the given managed object.



2006
2007
2008
2009
2010
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2006

def logUserEvent(entity, msg)
  $vim_log.info "MiqVimInventory(#{@server}, #{@username}).logUserEvent: calling logUserEvent" if $vim_log
  super(@sic.eventManager, entity, msg)
  $vim_log.info "MiqVimInventory(#{@server}, #{@username}).logUserEvent: returned from logUserEvent" if $vim_log
end

#objFixUp(objType, objHash) ⇒ Object 



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 313

def objFixUp(objType, objHash)
  objType = objType.to_sym if objType.kind_of? String

  #
  # Type-specific processing
  #
  case objType
  when :VirtualMachine
    #
    # The above hashObj call will hash by datastore path.
    # Below, we also hash by local path.
    #
    if (dsPath = objHash.fetch_path('summary', 'config', 'vmPathName'))
      localPath = localVmPath(dsPath)
      if localPath && !localPath.empty?
        objHash['summary']['config']['vmLocalPathName'] = localPath
        @virtualMachines[localPath] = objHash
      else
        objHash['summary']['config']['vmLocalPathName'] = nil
      end
    end

    if (ssObj = objHash["snapshot"])
      ssMorHash = VimHash.new
      rsl = ssObj['rootSnapshotList']
      rsl = [rsl] unless rsl.kind_of?(Array)
      rsl.each { |rs| snapshotFixup(rs, ssMorHash) }
      ssObj['ssMorHash'] = ssMorHash
    end

    if (hostMor = objHash.fetch_path('summary', 'runtime', 'host'))
      hostObj = hostSystemsByMor_locked[hostMor]
      return unless hostObj
      objHash['summary']["runtime"]["hostName"] = hostObj.fetch_path("summary", "config", "name")
    end

  when :ResourcePool
    objHash['summary']['name'] = objHash['name']
  end
end

#path2dsName(p) ⇒ Object 



2030
2031
2032
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2030

def path2dsName(p)
  MiqVimInventory.path2dsName(p)
end

#pollTask(tmor, className = nil) ⇒ Object

def waitForTask



2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2243

def pollTask(tmor, className = nil)
  className ||= self.class.to_s

  $vim_log.info "#{className}(#{@server}, #{@username})::pollTask(#{tmor})" if $vim_log
  args = VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
    pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
      pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
        psa << VimHash.new("PropertySpec") do |ps|
          ps.type    = tmor.vimType
          ps.all     = "false"
          ps.pathSet = ["info.state", "info.error", "info.result", "info.progress"]
        end
      end
      pfs.objectSet = VimArray.new("ArrayOfObjectSpec") do |osa|
        VimHash.new("ObjectSpec") do |os|
          os.obj = tmor
          osa << os
        end
      end
    end
  end

  state = result = error = progress = nil

  oca = retrievePropertiesCompat(@propCol, args)
  raise "pollTask: task not found #{tmor}" if !oca || !oca[0] || !oca[0].propSet

  oca[0].propSet.each do |ps|
    case ps.name
    when "info.state"
      state = ps.val
    when "info.error"
      error = ps.val
    when "info.result"
      result = ps.val
    when "info.progress"
      progress = ps.val
    end
  end

  case state
  when TaskInfoState::Error
    raise error.localizedMessage
  when TaskInfoState::Success
    return state, result
  when TaskInfoState::Running
    return state, progress
  else
    return state, nil
  end
end

#propFromCache(hashName, key, props) ⇒ Object 



422
423
424
425
426
427
428
429
430
431
432
433
434
435
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 422

def propFromCache(hashName, key, props)
  props = [props] if props.kind_of?(String)
  @cacheLock.synchronize(:SH) do
    cv = send((hashName + "_locked").to_sym)[key]
    raise "propFromCache: key \"#{key}\" not found in hash #{hashName}" unless cv
    ppn = key
    props.each do |pn|
      cv = cv[pn]
      raise "propFromCache: property \"#{pn}\" not found under \"#{ppn}\"" unless cv
      ppn = pn
    end
    return(dupObj(cv))
  end
end

#propValue(baseHash, prop) ⇒ Object 



2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2655

def propValue(baseHash, prop)
  return baseHash[prop] unless prop.index('.')

  h  = baseHash
  ka = splitPropPath(prop)
  ka[0...-1].each do |k|
    k, arrayKey = tagAndKey(k)
    if arrayKey
      array, idx = getVimArrayEnt(h[k], arrayKey, false)
      return(nil) unless array
      h = array[idx]
    else
      return(nil) unless h[k]
      h = h[k]
    end
  end
  (h[ka[-1]])
end

#queryLogDescriptions(host = nil) ⇒ Object

Log and diagnostic methods.



2123
2124
2125
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2123

def queryLogDescriptions(host = nil)
  queryDescriptions(@sic.diagnosticManager, host)
end

#refreshExtensionManager(extensionManagerMor) ⇒ Object 



1949
1950
1951
1952
1953
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1949

def refreshExtensionManager(extensionManagerMor)
  @cacheLock.synchronize(:EX) do
    return(conditionalCopy(addObjByMor(extensionManagerMor)))
  end
end

#refreshLicenseManager(licenseManagerMor) ⇒ Object 



1839
1840
1841
1842
1843
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1839

def refreshLicenseManager(licenseManagerMor)
  @cacheLock.synchronize(:EX) do
    return(conditionalCopy(addObjByMor(licenseManagerMor)))
  end
end

#refreshVirtualMachine(vmMor) ⇒ Object 



585
586
587
588
589
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 585

def refreshVirtualMachine(vmMor)
  @cacheLock.synchronize(:EX) do
    return(conditionalCopy(addObjByMor(vmMor)))
  end
end

#removeExtensionManager(extensionManagerMor) ⇒ Object 



1960
1961
1962
1963
1964
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1960

def removeExtensionManager(extensionManagerMor)
  @cacheLock.synchronize(:EX) do
    removeObjByMor(extensionManagerMor)
  end
end

#removeLicenseManager(licenseManagerMor) ⇒ Object 



1850
1851
1852
1853
1854
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1850

def removeLicenseManager(licenseManagerMor)
  @cacheLock.synchronize(:EX) do
    removeObjByMor(licenseManagerMor)
  end
end

#removeObjByMor(objMor) ⇒ Object 



401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 401

def removeObjByMor(objMor)
  raise "removeObjByMor: exclusive cache lock not held"   unless @cacheLock.sync_exclusive?
  objType = objMor.vimBaseType.to_sym
  raise "removeObjByMor: Unknown VIM object type: #{objType}" unless (pmap = @propMap[objType])

  baseName  = pmap[:baseName]
  keyPath   = pmap[:keyPath]
  keyPath2  = pmap[:keyPath2]

  objHash = instance_variable_get("#{baseName}ByMor")
  return unless (props = objHash.delete(objMor))

  if keyPath
    key     = props.fetch_path(keyPath)
    key2    = keyPath2 ? props.fetch_path(keyPath2) : nil
    objHash = instance_variable_get(baseName)
    objHash.delete(key)
    objHash.delete(key2) if key2
  end
end

#removeSelector(selName) ⇒ Object 



2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2514

def removeSelector(selName)
  remKeys = nil
  if selName.kind_of?(Symbol)
    remKeys = [selName]
  elsif selName.kind_of?(Hash)
    remKeys = selName.keys
  elsif selName.kind_of?(Array)
    remKeys = selName
  else
    raise "removeSelector: selName must be a symbol, hash or array, received #{selName.class}"
  end
  remKeys.each do |rk|
    raise "removeSelector: keys must be symbols, received #{rk.class}" unless rk.kind_of?(Symbol)
  end

  @configLock.synchronize(:EX) do
    remKeys.each do |rk|
      @selectorHash.delete(rk)
      @selectorPropPathHash.delete(rk)
    end
  end
end

#removeVirtualMachine(vmMor) ⇒ Object 



596
597
598
599
600
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 596

def removeVirtualMachine(vmMor)
  @cacheLock.synchronize(:EX) do
    removeObjByMor(vmMor)
  end
end

#resetCache ⇒ Object 



221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 221

def resetCache
  $vim_log.info "MiqVimInventory.resetCache: clearing cache for #{@connId}"
  @cacheLock.synchronize(:EX) do
    @inventoryHash = nil

    @propMap.each_value do |pm|
      instance_variable_set("#{pm[:baseName]}ByMor", nil)
      instance_variable_set(pm[:baseName], nil)
    end
  end
  $vim_log.info "MiqVimInventory.resetCache: cleared cache for #{@connId}"
end

#resourcePoolByMor(rpMor, selSpec = nil) ⇒ Object

Return a single resourcePool object, given its MOR



889
890
891
892
893
894
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 889

def resourcePoolByMor(rpMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(resourcePoolsByMor_locked[rpMor])) if selSpec.nil?
    return(applySelector(resourcePoolsByMor_locked[rpMor], selSpec))
  end
end

#resourcePools(selSpec = nil) ⇒ Object

Public accessor



857
858
859
860
861
862
863
864
865
866
867
868
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 857

def resourcePools(selSpec = nil)
  rp = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      rp = dupObj(resourcePools_locked)
    else
      rp = applySelector(resourcePools_locked, selSpec)
    end
  end
  assert_no_locks
  rp
end

#resourcePoolsByFilter(filter) ⇒ Object

Public accessor

Return an array of resource pool objects that match the given property filter.



901
902
903
904
905
906
907
908
909
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 901

def resourcePoolsByFilter(filter)
  rps = nil
  @cacheLock.synchronize(:SH) do
    rps = applyFilter(resourcePoolsByMor_locked.values, filter)
    rps = dupObj(rps)
  end
  assert_no_locks
  rps
end

#resourcePoolsByMor(selSpec = nil) ⇒ Object

Public accessor



873
874
875
876
877
878
879
880
881
882
883
884
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 873

def resourcePoolsByMor(selSpec = nil)
  rp = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      rp = dupObj(resourcePoolsByMor_locked)
    else
      rp = applySelector(resourcePoolsByMor_locked, selSpec)
    end
  end
  assert_no_locks
  rp
end

#selSpecToPropPath(selSpec) ⇒ Object 



2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2547

def selSpecToPropPath(selSpec)
  return ss2pp(selSpec) unless selSpec.kind_of?(Symbol)

  @configLock.synchronize(:EX) do
    pp = @selectorPropPathHash[selSpec]
    return pp unless pp.nil?

    ss = getSelSpec(selSpec)
    raise "selSpecToPropPath: selector #{selSpec} not found" if ss.nil?

    return (@selectorPropPathHash[selSpec] = ss2pp(ss))
  end
end

#setSelector(selSpec) ⇒ Object 



2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2481

def setSelector(selSpec)
  raise "setSelector: selSpec must be a hash, received #{selSpec.class}" unless selSpec.kind_of?(Hash)
  selSpec.each_key do |k|
    raise "setSelector: selSpec keys must be symbols, received #{k.class}" unless k.kind_of?(Symbol)
  end
  ov = nil
  selSpec.each_value do |v|
    if v.kind_of?(Array)
      v.each do |vv|
        unless vv.kind_of?(String)
          ov = vv
          break
        end
      end
    else
      ov = v unless v.kind_of?(String)
    end
    raise "setSelector: selSpec values must be strings or arrays of strings, received #{ov.class}" unless ov.nil?
  end

  @configLock.synchronize(:EX) do
    @selectorHash.merge!(selSpec) { |k, _o, n| @selectorPropPathHash.delete(k); n }
  end
end

#snapshotFixup(ssObj, ssMorHash) ⇒ Object 



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 354

def snapshotFixup(ssObj, ssMorHash)
  #
  # There can be more than one root snapshot.
  # When this is the case, ssObj is an array instead of a hash.
  #
  ssObj.each { |sso| snapshotFixup(sso, ssMorHash) } if ssObj.kind_of? Array

  #
  # Hash snapshot info by MOR.
  #
  ssMorHash[String.new(ssObj['snapshot'].to_s)] = ssObj

  #
  # Hash snapshot info by create time.
  #
  ssMorHash[ssObj['createTime']] = ssObj

  #
  # Ensure childSnapshotList is always present and always an array,
  # evne if it's empty.
  #
  childList = ssObj['childSnapshotList']
  if !childList
    ssObj['childSnapshotList'] = VimArray.new
  elsif !childList.kind_of? Array
    ssObj['childSnapshotList'] = VimArray.new { |a| a << childList }
  end

  ssObj['childSnapshotList'].each { |sso| snapshotFixup(sso, ssMorHash) }
end

#spec ⇒ Object

Construct an array of PropertySpec objects to retrieve the MORs for all the inventory objects we’re interested in.

Most of thosse objects are subclasses of ManagedEntity, so they are all covered by the first entry. Datastore is a special case that requires its own entry.



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 154

def spec
  propSpecAry = VimArray.new("ArrayOfPropertySpec") do |psa|
    psa << VimHash.new("PropertySpec") do |ps|
      ps.type = "ManagedEntity"
      ps.all  = "false"
    end
    psa << VimHash.new("PropertySpec") do |ps|
      ps.type = "Datastore"
      ps.all  = "false"
    end

    if isVirtualCenter
      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
  end
  VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
    pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
      pfs.propSet   = propSpecAry
      pfs.objectSet = @objectSet
    end
  end
end

#storagePodByMor(spMor, selSpec = nil) ⇒ Object

Return a single storagePod object, given its MOR



1735
1736
1737
1738
1739
1740
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1735

def storagePodByMor(spMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(storagePodsByMor_locked[spMor])) if selSpec.nil?
    return(applySelector(storagePodsByMor_locked[spMor], selSpec))
  end
end

#storagePods(selSpec = nil) ⇒ Object

Public accessor



1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1703

def storagePods(selSpec = nil)
  sp = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      sp = dupObj(storagePods_locked)
    else
      sp = applySelector(storagePods_locked, selSpec)
    end
  end
  assert_no_locks
  sp
end

#storagePodsByMor(selSpec = nil) ⇒ Object

Public accessor



1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1719

def storagePodsByMor(selSpec = nil)
  sp = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      sp = dupObj(storagePodsByMor_locked)
    else
      sp = applySelector(storagePodsByMor_locked, selSpec)
    end
  end
  assert_no_locks
  sp
end

#updateSpec ⇒ Object 



199
200
201
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 199

def updateSpec
  updateSpecByPropMap(@propMap)
end

#updateSpecByPropMap(propMap) ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 184

def updateSpecByPropMap(propMap)
  VimHash.new("PropertyFilterSpec") do |pfs|
    pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
      propMap.each do |type, h|
        psa << VimHash.new("PropertySpec") do |ps|
          ps.type    = type
          ps.all     = h[:props].nil?.to_s
          ps.pathSet = h[:props] if h[:props]
        end
      end
    end
    pfs.objectSet = @objectSet
  end
end

#virtualAppByMor(vaMor, selSpec = nil) ⇒ Object

Return a single virtualApp object, given its MOR



1001
1002
1003
1004
1005
1006
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1001

def virtualAppByMor(vaMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(virtualAppsByMor_locked[vaMor])) if selSpec.nil?
    return(applySelector(virtualAppsByMor_locked[vaMor], selSpec))
  end
end

#virtualApps(selSpec = nil) ⇒ Object

Public accessor



969
970
971
972
973
974
975
976
977
978
979
980
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 969

def virtualApps(selSpec = nil)
  rp = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      rp = dupObj(virtualApps_locked)
    else
      rp = applySelector(virtualApps_locked, selSpec)
    end
  end
  assert_no_locks
  rp
end

#virtualAppsByFilter(filter) ⇒ Object

Public accessor

Return an array of virtualApp objects that match the given property filter.



1013
1014
1015
1016
1017
1018
1019
1020
1021
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1013

def virtualAppsByFilter(filter)
  rps = nil
  @cacheLock.synchronize(:SH) do
    rps = applyFilter(virtualAppsByMor_locked.values, filter)
    rps = dupObj(rps)
  end
  assert_no_locks
  rps
end

#virtualAppsByMor(selSpec = nil) ⇒ Object

Public accessor



985
986
987
988
989
990
991
992
993
994
995
996
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 985

def virtualAppsByMor(selSpec = nil)
  rp = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      rp = dupObj(virtualAppsByMor_locked)
    else
      rp = applySelector(virtualAppsByMor_locked, selSpec)
    end
  end
  assert_no_locks
  rp
end

#virtualMachineByMor(vmMor, selSpec = nil) ⇒ Object

Return a single VM object, given its MOR



557
558
559
560
561
562
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 557

def virtualMachineByMor(vmMor, selSpec = nil)
  @cacheLock.synchronize(:SH) do
    return(dupObj(virtualMachinesByMor_locked[vmMor])) if selSpec.nil?
    return(applySelector(virtualMachinesByMor_locked[vmMor], selSpec))
  end
end

#virtualMachines(selSpec = nil) ⇒ Object

Public accessor



525
526
527
528
529
530
531
532
533
534
535
536
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 525

def virtualMachines(selSpec = nil)
  vms = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      vms = dupObj(virtualMachines_locked)
    else
      vms = applySelector(virtualMachines_locked, selSpec)
    end
  end
  assert_no_locks
  vms
end

#virtualMachinesByFilter(filter) ⇒ Object

Public accessor

Return an array of virtual machine objects that match the given property filter.



569
570
571
572
573
574
575
576
577
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 569

def virtualMachinesByFilter(filter)
  vms = nil
  @cacheLock.synchronize(:SH) do
    vms = applyFilter(virtualMachinesByMor_locked.values, filter)
    vms = dupObj(vms)
  end
  assert_no_locks
  vms
end

#virtualMachinesByMor(selSpec = nil) ⇒ Object

Public accessor



541
542
543
544
545
546
547
548
549
550
551
552
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 541

def virtualMachinesByMor(selSpec = nil)
  vms = nil
  @cacheLock.synchronize(:SH) do
    if selSpec.nil?
      vms = dupObj(virtualMachinesByMor_locked)
    else
      vms = applySelector(virtualMachinesByMor_locked, selSpec)
    end
  end
  assert_no_locks
  vms
end

#vmDatacenterName(vmMor) ⇒ Object 



2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2102

def vmDatacenterName(vmMor)
  @cacheLock.synchronize(:SH) do
    datacentersByMor_locked.each do |_n, o|
      begin
        f = foldersByMor_locked[o['vmFolder']]
        fVms = f['childEntity']
        fVms.each do |vmMo|
          return o['name'] if vmMor == vmMo
        end
      rescue
        # Ignore errors, keep going and return nil if not found.
      end
    end
    return nil
  end
end

#waitForTask(tmor, className = nil) ⇒ Object

Raises:



2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2200

def waitForTask(tmor, className = nil)
  className ||= self.class.to_s

  $vim_log.info "#{className}(#{@server}, #{@username})::waitForTask(#{tmor})" if $vim_log
  args = VimArray.new("ArrayOfPropertyFilterSpec") do |pfsa|
    pfsa << VimHash.new("PropertyFilterSpec") do |pfs|
      pfs.propSet = VimArray.new("ArrayOfPropertySpec") do |psa|
        psa << VimHash.new("PropertySpec") do |ps|
          ps.type    = tmor.vimType
          ps.all     = "false"
          ps.pathSet = ["info.state", "info.error", "info.result"]
        end
      end
      pfs.objectSet = VimArray.new("ArrayOfObjectSpec") do |osa|
        VimHash.new("ObjectSpec") do |os|
          os.obj = tmor
          osa << os
        end
      end
    end
  end

  state = result = error = nil

  until state
    oca = retrievePropertiesCompat(@propCol, args)
    raise "waitForTask: task not found #{tmor}" if !oca || !oca[0] || !oca[0].propSet

    oca[0].propSet.each do |ps|
      if ps.name == "info.state"
        state = ps.val if ps.val == TaskInfoState::Success || ps.val == TaskInfoState::Error
      end
      error  = ps.val if ps.name == "info.error"
      result = ps.val if ps.name == "info.result"
    end
    sleep 1 unless state
  end

  raise VimFault.new(error) if state == TaskInfoState::Error
  $vim_log.info "#{className}(#{@server}, #{@username})::waitForTask: result = #{result}" if $vim_log
  result
end