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, #port, #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

Methods included from VMwareWebService::Logging

#logger

Constructor Details

#initialize(server:, username:, password:, port: 443, ssl_options: {}, cache_scope: nil) ⇒ MiqVimInventory

Returns a new instance of MiqVimInventory.



20
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
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 20

def initialize(server:, username:, password:, port: 443, ssl_options: {}, cache_scope: nil)
  super(:server => server, :port => port, :ssl_options => ssl_options, :username => username, :password => password)

  cache_scope ||= @@cacheScope

  case cache_scope
  when :cache_scope_full
    @propMap = FullPropMap
    logger.info "MiqVimInventory: using property map FullPropMap"
  when :cache_scope_ems_refresh
    @propMap = EmsRefreshPropMap
    logger.info "MiqVimInventory: using property map EmsRefreshPropMap"
  when :cache_scope_core
    @propMap = CorePropMap
    logger.info "MiqVimInventory: using property map CorePropMap"
  when :cache_scope_event_monitor
    @propMap = EventMonitorPropMap
    logger.info "MiqVimInventory: using property map EventMonitorPropMap"
  else
    @propMap = FullPropMap
    logger.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 && cache_scope != :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.



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

def cacheLock
  @cacheLock
end

#configLock ⇒ Object (readonly)

Returns the value of attribute configLock.



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

def configLock
  @configLock
end

Class Method Details

.cacheScope ⇒ Object 



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

def self.cacheScope
  @@cacheScope
end

.cacheScope=(val) ⇒ Object 



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

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

.dsPath?(p) ⇒ Boolean

Datastore/path utility methods.

Returns:

  • (Boolean) 


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

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

.dsRelativePath(p) ⇒ Object 



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

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

.path2dsName(p) ⇒ Object 



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

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

.removeSelector(selName) ⇒ Object 



2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2465

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 "MiqVimInventory.removeSelector: selName must be a symbol, hash or array, received #{selName.class}"
  end
  remKeys.each do |rk|
    raise "MiqVimInventory.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 



2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2443

def self.setSelector(selSpec)
  raise "MiqVimInventory.setSelector: selSpec must be a hash, received #{selSpec.class}" unless selSpec.kind_of?(Hash)
  selSpec.each_key do |k|
    raise "MiqVimInventory.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 "MiqVimInventory.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 



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

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

#addDataStoreObj(dsObj) ⇒ Object 



1477
1478
1479
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1477

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

#addDVPObj(dvpObj) ⇒ Object 



1565
1566
1567
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1565

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

#addDVSObj(dvsObj) ⇒ Object 



1659
1660
1661
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1659

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

#addExtensionManager(extensionManagerMor) ⇒ Object 



1947
1948
1949
1950
1951
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1947

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

#addHostSystem(hsMor) ⇒ Object 



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

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

#addHostSystemObj(hsObj) ⇒ Object 



1354
1355
1356
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1354

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

#addLicenseManager(licenseManagerMor) ⇒ Object 



1837
1838
1839
1840
1841
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1837

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.



393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 393

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.



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

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



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

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 



1746
1747
1748
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1746

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

#addToCollection(hash, tag, val) ⇒ Object 



2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2771

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 



583
584
585
586
587
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 583

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

#allPropsFromCache(hashName, props) ⇒ Object 



441
442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 441

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 



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

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 



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

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 



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
2626
2627
2628
2629
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2601

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 



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

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 



2131
2132
2133
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2131

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 



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
2165
2166
2167
2168
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2135

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 



100
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
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 100

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?
        logger.info "#{pref}#{hnm}: is nil"
        next
      end

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

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

#cancelTask(tmor) ⇒ Object 



2200
2201
2202
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2200

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

#clusterComputeResourceByMor(ccrMor, selSpec = nil) ⇒ Object

Return a single clusterComputeResource object, given its MOR



790
791
792
793
794
795
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 790

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



758
759
760
761
762
763
764
765
766
767
768
769
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 758

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.



802
803
804
805
806
807
808
809
810
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 802

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



774
775
776
777
778
779
780
781
782
783
784
785
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 774

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



687
688
689
690
691
692
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 687

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



655
656
657
658
659
660
661
662
663
664
665
666
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 655

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.



699
700
701
702
703
704
705
706
707
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 699

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



671
672
673
674
675
676
677
678
679
680
681
682
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 671

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.



2838
2839
2840
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2838

def conditionalCopy(obj)
  obj
end

#currentSession ⇒ Object

def resetCache



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

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

#datacenterByMor(dcMor, selSpec = nil) ⇒ Object

Return a single datacenter object, given its MOR



1211
1212
1213
1214
1215
1216
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1211

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



1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1179

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.



1223
1224
1225
1226
1227
1228
1229
1230
1231
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1223

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



1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1195

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



1439
1440
1441
1442
1443
1444
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1439

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



2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2089

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



1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1407

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.



1451
1452
1453
1454
1455
1456
1457
1458
1459
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1451

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 



1461
1462
1463
1464
1465
1466
1467
1468
1469
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1461

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



1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1423

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 



2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2842

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 



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

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

#dsName2mo(dsn) ⇒ Object 



2046
2047
2048
2049
2050
2051
2052
2053
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2046

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 



2055
2056
2057
2058
2059
2060
2061
2062
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2055

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 



2038
2039
2040
2041
2042
2043
2044
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2038

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

#dsPath?(p) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#dsRelativePath(p) ⇒ Object 



2069
2070
2071
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2069

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.



2830
2831
2832
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2830

def dupObj(obj)
  obj
end

#dvPortgroupByMor(dvpMor, selSpec = nil) ⇒ Object

Return a single storagePod object, given its MOR



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

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



1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1526

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



1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1542

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



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

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



1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1620

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



1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1636

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



1925
1926
1927
1928
1929
1930
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1925

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.



1937
1938
1939
1940
1941
1942
1943
1944
1945
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1937

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



1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1909

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



1108
1109
1110
1111
1112
1113
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1108

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



1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1076

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.



1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1120

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



1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1092

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



2363
2364
2365
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2363

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.



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
2355
2356
2357
2358
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2306

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

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

  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.



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
2429
2430
2431
2432
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2371

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



2434
2435
2436
2437
2438
2439
2440
2441
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2434

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 



2510
2511
2512
2513
2514
2515
2516
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2510

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 



2541
2542
2543
2544
2545
2546
2547
2548
2549
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2541

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 



2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2184

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

#getTasks ⇒ Object

Task utility methods.



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

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

#getTasksByFilter(filter) ⇒ Object

private :getTasks



2179
2180
2181
2182
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2179

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

#hasProp?(baseHash, prop) ⇒ Boolean

Returns:

  • (Boolean) 


2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2678

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



1314
1315
1316
1317
1318
1319
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1314

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



1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1282

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.



1326
1327
1328
1329
1330
1331
1332
1333
1334
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1326

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



1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1298

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 



1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1336

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 



1999
2000
2001
2002
2003
2004
2005
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1999

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



1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1975

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

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

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

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

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

  @inventoryHash
end

#isAlive? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#isDead ⇒ Object

For testing



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

def isDead
  @alive = false
end

#isHostAgent? ⇒ Boolean

Returns:

  • (Boolean) 


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

def isHostAgent?
  !@isVirtualCenter
end

#isVirtualCenter? ⇒ Boolean

Returns:

  • (Boolean) 


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

def isVirtualCenter?
  @isVirtualCenter
end

#keyExistsInCache?(hashName, key) ⇒ Boolean

Returns:

  • (Boolean) 


474
475
476
477
478
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 474

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

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



456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 456

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



1815
1816
1817
1818
1819
1820
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1815

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.



1827
1828
1829
1830
1831
1832
1833
1834
1835
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1827

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



1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1799

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 



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

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 



2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2073

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 



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

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
        logger.info "#{pref}#{hnm}: #{hnmc}"
      end
      unless instance_variable_get(hn).nil?
        hnc = instance_variable_get(hn).keys.length
        logger.info "#{pref}#{hn}: #{hnc}"
      end
    end
  end
end

#logUserEvent(entity, msg) ⇒ Object

Generate a user event associated with the given managed object.



2010
2011
2012
2013
2014
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2010

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

#objFixUp(objType, objHash) ⇒ Object 



312
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
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 312

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 



2034
2035
2036
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2034

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

#pollTask(tmor, className = nil) ⇒ Object

def waitForTask



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
2294
2295
2296
2297
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2247

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

  logger.info "#{className}(#{@server}, #{@username})::pollTask(#{tmor})"
  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 



426
427
428
429
430
431
432
433
434
435
436
437
438
439
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 426

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 



2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2659

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.



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

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

#refreshExtensionManager(extensionManagerMor) ⇒ Object 



1953
1954
1955
1956
1957
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1953

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

#refreshLicenseManager(licenseManagerMor) ⇒ Object 



1843
1844
1845
1846
1847
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1843

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

#refreshVirtualMachine(vmMor) ⇒ Object 



589
590
591
592
593
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 589

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

#removeExtensionManager(extensionManagerMor) ⇒ Object 



1964
1965
1966
1967
1968
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1964

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

#removeLicenseManager(licenseManagerMor) ⇒ Object 



1854
1855
1856
1857
1858
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1854

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

#removeObjByMor(objMor) ⇒ Object 



405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 405

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 



2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2518

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 



600
601
602
603
604
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 600

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

#resetCache ⇒ Object 



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

def resetCache
  logger.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
  logger.info "MiqVimInventory.resetCache: cleared cache for #{@connId}"
end

#resourcePoolByMor(rpMor, selSpec = nil) ⇒ Object

Return a single resourcePool object, given its MOR



893
894
895
896
897
898
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 893

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



861
862
863
864
865
866
867
868
869
870
871
872
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 861

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.



905
906
907
908
909
910
911
912
913
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 905

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



877
878
879
880
881
882
883
884
885
886
887
888
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 877

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 



2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2551

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 



2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2485

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 



353
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
384
385
386
387
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 353

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.
  #
  # VMware API strips trailing '0's from the fractional seconds
  # which causes the string to not match what .iso8601(6) returns
  #
  # Example 12:12:59.123Z instead of 12:12:59.123000Z
  create_time = Time.parse(ssObj['createTime']).iso8601(6)
  ssMorHash[create_time] = 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.



153
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
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 153

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



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

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



1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1707

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



1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1723

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 



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

def updateSpec
  updateSpecByPropMap(@propMap)
end

#updateSpecByPropMap(propMap) ⇒ Object 



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

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



1005
1006
1007
1008
1009
1010
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1005

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



973
974
975
976
977
978
979
980
981
982
983
984
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 973

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.



1017
1018
1019
1020
1021
1022
1023
1024
1025
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 1017

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



989
990
991
992
993
994
995
996
997
998
999
1000
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 989

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



561
562
563
564
565
566
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 561

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



529
530
531
532
533
534
535
536
537
538
539
540
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 529

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.



573
574
575
576
577
578
579
580
581
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 573

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



545
546
547
548
549
550
551
552
553
554
555
556
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 545

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 



2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2106

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:



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
2242
2243
2244
2245
 
# File 'lib/VMwareWebService/MiqVimInventory.rb', line 2204

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

  logger.info "#{className}(#{@server}, #{@username})::waitForTask(#{tmor})"
  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
  logger.info "#{className}(#{@server}, #{@username})::waitForTask: result = #{result}"
  result
end