vmware_web_service 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30cb65afb7c15cd5ac5ff915222cd5eea2be5054
+  data.tar.gz: e4bd273688f4acde4a97924d2eadd5eeeff54b08
+SHA512:
+  metadata.gz: b5257f53ce1d069d4719fb597e8b3d800628bdc6c04733607044afa00cb82ed9250bdcc4865854f9e2766fe5dd14347fde530ec14f74f17f190812fa90557bb0
+  data.tar.gz: ede66142c347c05aa90d3d60248bce61710fd07c68f978ccbe06741d91a0d398c1fe38847e0d454d7aa54e3dbb38df915c6e43c38c4d20446c32a07755ceb87b

data/lib/VMwareWebService/DMiqVim.rb

@@ -0,0 +1,159 @@
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimUpdate'
+require 'VMwareWebService/DMiqVimSync'
+
+#
+# Class used to wrap locked object and return it through DRB.
+#
+class MiqDrbReturn
+  attr_accessor :obj, :lock
+
+  def initialize(obj, lock = nil)
+    @obj = obj
+    @lock = lock
+  end
+end
+
+class DMiqVim < MiqVim
+  alias_method :serverPrivateConnect, :connect
+  alias_method :serverPrivateDisconnect, :disconnect
+  alias_method :conditionalCopy, :deepClone
+
+  include DRb::DRbUndumped
+  include MiqVimUpdate
+  include DMiqVimSync
+
+  attr_reader :updateThread
+
+  def initialize(server, username, password, broker, preLoad = false, debugUpdates = false, notifyMethod = nil, cacheScope = nil, maxWait = 60, maxObjects = 250)
+    super(server, username, password, cacheScope)
+
+    log_prefix        = "DMiqVim.initialize (#{@connId})"
+    @broker         = broker
+    @updateMonitorReady   = false
+    @error          = nil
+    @notifyMethod     = notifyMethod
+    @connectionShuttingDown = false
+    @connectionRemoved    = false
+    @debugUpdates     = debugUpdates
+    @maxWait          = maxWait
+    @maxObjects       = maxObjects
+
+    checkForOrphanedMonitors
+    $vim_log.info "#{log_prefix}: starting update monitor thread" if $vim_log
+    @updateThread = Thread.new { monitor(preLoad) }
+    @updateThread[:vim_connection_id] = connId
+    $vim_log.info "#{log_prefix}: waiting for update monitor to become ready" if $vim_log
+    until @updateMonitorReady
+      raise @error unless @error.nil?
+      break unless @updateThread.alive?
+      Thread.pass
+    end
+    $vim_log.info "#{log_prefix}: update monitor ready" if $vim_log
+  end
+
+  # VC sometimes throws: Handsoap::Fault { :code => 'ServerFaultCode', :reason => 'The session is not authenticated.' }
+  # Handle this condition by reconnecting and monitoring again
+  # See http://communities.vmware.com/thread/190531
+  def handleSessionNotAuthenticated(err)
+    return false unless err.respond_to?(:reason) && err.reason == 'The session is not authenticated.'
+
+    log_prefix = "DMiqVim.handleSessionNotAuthenticated (#{@connId})"
+    $vim_log.error "#{log_prefix}: Reconnecting Session because '#{err.reason}'" if $vim_log
+    $vim_log.info "#{log_prefix}: Session(server=#{server}, username=#{username}) isAlive? => #{self.isAlive?.inspect}" if $vim_log
+
+    begin
+      $vim_log.info  "#{log_prefix}: Disconnecting Session" if $vim_log
+      serverPrivateDisconnect
+      $vim_log.info  "#{log_prefix}: Disconnecting Session...Complete" if $vim_log
+    rescue => disconnect_err
+      $vim_log.error "#{log_prefix}: Disconnecting Session...Error #{disconnect_err}" if $vim_log
+    end
+
+    begin
+      $vim_log.info  "#{log_prefix}: Connecting Session" if $vim_log
+      serverPrivateConnect
+      $vim_log.info  "#{log_prefix}: Connecting Session...Complete" if $vim_log
+    rescue => connect_err
+      $vim_log.error "#{log_prefix}: Connecting Session...Error #{connect_err}" if $vim_log
+      @error = err
+    end
+
+    @error.nil?
+  end
+
+  def monitor(preLoad)
+    log_prefix = "DMiqVim.monitor (#{@connId})"
+    begin
+      monitorUpdates(preLoad)
+    rescue Exception => err
+      # if handleSessionNotAuthenticated(err)
+      #   $vim_log.info "#{log_prefix}: Restarting Update Monitor" if $vim_log
+      #   retry
+      # end
+      $vim_log.info "#{log_prefix}: returned from monitorUpdates via #{err.class} exception" if $vim_log
+      @error = err
+    ensure
+      $vim_log.info "#{log_prefix}: returned from monitorUpdates" if $vim_log
+      if @updateMonitorReady && !@broker.shuttingDown
+        @broker.connTrySync(:EX, server, username) do |key|
+          @broker.removeMiqVimSS(key, self)
+        end
+
+        if @notifyMethod
+          @notifyMethod.call(:server   => @server,
+                             :username => @username,
+                             :op       => 'MiqVimRemoved',
+                             :error    => @error
+                            )
+        end
+      end
+    end
+  end
+
+  def shutdownConnection
+    return if @connectionShuttingDown
+    log_prefix = "DMiqVim.shutdownConnection (#{@connId})"
+    $vim_log.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Starting" if $vim_log
+    @connectionShuttingDown = true
+    stopUpdateMonitor
+    begin
+      if @updateThread != Thread.current && @updateThread.alive?
+        $vim_log.info "#{log_prefix}: waiting for Update Monitor Thread...Starting" if $vim_log
+        @updateThread.join
+        $vim_log.info "#{log_prefix}: waiting for Update Monitor Thread...Complete" if $vim_log
+      end
+    rescue => err
+    end
+    serverPrivateDisconnect if self.isAlive?
+    $vim_log.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Complete" if $vim_log
+  end
+
+  def checkForOrphanedMonitors
+    log_prefix = "DMiqVim.checkForOrphanedMonitors (#{@connId})"
+    $vim_log.debug "#{log_prefix}: called..."
+    Thread.list.each do |thr|
+      next unless thr[:vim_connection_id] == connId
+      $vim_log.error "#{log_prefix}: Terminating orphaned update monitor <#{thr.object_id}>"
+      thr.raise "Orphaned update monitor (#{@connId}) <#{thr.object_id}>, terminated by <#{Thread.current.object_id}>"
+      thr.wakeup
+    end
+    $vim_log.debug "#{log_prefix}: done."
+  end
+
+  def connectionRemoved?
+    @connectionRemoved
+  end
+
+  def connectionRemoved
+    @connectionRemoved = true
+  end
+
+  def connect
+    (true)
+  end
+
+  def disconnect
+    (true)
+  end
+end # class DMiqVim

data/lib/VMwareWebService/DMiqVimSync.rb

@@ -0,0 +1,45 @@
+
+module DMiqVimSync
+  #
+  # This method is called - with the cacheLock held - when returning an object from the cache to the client.
+  # It used to produce a full recursive copy of the object before releasing the lock.
+  # When used in the broker, the DRB layer would then marshal the copy of the object to return it to the remote client.
+  # This new scheme enables us to hold the cacheLock until after DRB marshals the object, eliminating the need
+  # for this method to produce a full recursive copy.
+  #
+  # The lock count of the cacheLock is incremented, so when this method's caller releases the lock, the lock
+  # will still be held. The object to be returned and the cacheLock are wraped in a MiqDrbReturn object
+  # and returned to the DRB layer, which will marshal the object and release the lock. See below.
+  #
+  def dupObj(obj)
+    return(obj) unless @cacheLock.sync_locked?
+    $vim_log.debug "DMiqVim::dupObj: LOCKING [#{Thread.current.object_id}] <#{obj.object_id}>" if $vim_log.debug?
+    @cacheLock.sync_lock(:SH)
+    (MiqDrbReturn.new(obj, @cacheLock))
+  end
+end # module DMiqVimSync
+
+class DRb::DRbMessage
+  alias_method :dump_original, :dump
+
+  #
+  # This is the DRB half of the dupObj locking scheme. If we get a MiqDrbReturn object,
+  # we marshal the object it wraps and release the lock.
+  #
+  def dump(obj, error = false)
+    #
+    # Place a temp hold on the object until the client registers it.
+    #
+    obj.holdBrokerObj if obj.respond_to?(:holdBrokerObj)
+
+    return(dump_original(obj, error)) unless obj.kind_of?(MiqDrbReturn)
+    begin
+      return(dump_original(obj.obj, error))
+    ensure
+      if obj.lock && obj.lock.sync_locked?
+        $vim_log.debug "DRb::DRbMessage.dump: UNLOCKING [#{Thread.current.object_id}] <#{obj.obj.object_id}>" if $vim_log.debug?
+        obj.lock.sync_unlock
+      end
+    end
+  end
+end # class DRb::DRbMessage

data/lib/VMwareWebService/MiqCustomFieldsManager.rb

@@ -0,0 +1,45 @@
+class MiqCustomFieldsManager
+  attr_reader :invObj
+
+  def initialize(invObj)
+    @invObj             = invObj
+    @sic                = invObj.sic
+
+    @cfManager      = @sic.customFieldsManager
+    raise "The customFieldsManager is not supported on this system." unless @cfManager
+  end
+
+  def field
+    f = @invObj.getMoProp(@cfManager, 'field')
+    return nil unless f
+    f.field
+  end
+
+  def addCustomFieldDef(_name, _moType = nil)
+  end
+
+  def removeCustomFieldDef(_key)
+  end
+
+  def renameCustomFieldDef(_key, _name)
+  end
+
+  def setField(entity, key, value)
+    @invObj.setField(@cfManager, entity, key, value)
+  end
+
+  def fieldDefByFilter(filter)
+    @invObj.applyFilter(field, filter)
+  end
+
+  def getFieldKey(name, moType)
+    fda = fieldDefByFilter('name' => name, 'managedObjectType' => moType)
+    # Check the global fields (moType = nil) if we fail to find it by moType.
+    fda = fieldDefByFilter('name' => name, 'managedObjectType' => nil) if fda.empty?
+    raise "Definition of field #{name} for type #{moType}, not found" if fda.empty?
+    fda.first.key
+  end
+
+  def release
+  end
+end

data/lib/VMwareWebService/MiqHostAdvancedOptionManager.rb

@@ -0,0 +1,20 @@
+class MiqHostAdvancedOptionManager
+  attr_reader :invObj
+
+  def initialize(aomMor, invObj)
+    @invObj = invObj
+    @aomMor = aomMor
+  end
+
+  def setting
+    @invObj.getMoProp(@aomMor)['setting']
+  end
+
+  def supportedOption
+    @invObj.getMoProp(@aomMor)['supportedOption']
+  end
+
+  def queryOptions(name)
+    @invObj.queryOptions(@aomMor, name)
+  end
+end # class MiqHostAdvancedOptionManager

data/lib/VMwareWebService/MiqHostDatastoreSystem.rb

@@ -0,0 +1,50 @@
+class MiqHostDatastoreSystem
+  attr_reader :invObj
+
+  def initialize(dssMor, invObj)
+    @invObj = invObj
+    @dssMor = dssMor
+  end
+
+  def capabilities
+    @capabilities ||= @invObj.getMoProp(@dssMor, 'capabilities')['capabilities']
+  end
+
+  def datastore
+    @invObj.getMoProp(@dssMor, 'datastore')['datastore']
+  end
+
+  def createNasDatastore(remoteHost, remotePath, localPath, accessMode = "readWrite", type = "nfs", userName = nil, password = nil)
+    spec = VimHash.new('HostNasVolumeSpec') do |s|
+      s.remoteHost  = remoteHost
+      s.remotePath  = remotePath
+      s.localPath   = localPath
+      s.accessMode  = accessMode
+      s.type      = type
+      s.userName    = userName
+      s.password    = password
+    end
+    @invObj.createNasDatastore(@dssMor, spec)
+  end
+
+  #
+  # Utility method to add an existing NAS datastore to the host in question.
+  #
+  def addNasDatastoreByName(dsName, accessMode = "readWrite")
+    if (dsh = @invObj.dataStoresByFilter_local("summary.name" => dsName).first).nil?
+      raise "MiqHostDatastoreSystem.addNasDatastoreByName: datastore #{sdName} not found"
+    end
+
+    unless dsh.summary.type.casecmp('nfs') == 0 || dsh.summary.type.casecmp('nas') == 0
+      raise "MiqHostDatastoreSystem.addNasDatastoreByName: datastore #{dsName} is not NAS"
+    end
+
+    remoteHost  = dsh.info.nas.remoteHost
+    remotePath  = dsh.info.nas.remotePath
+    localPath = dsh.info.nas.name
+    type    = dsh.info.nas.type
+
+    $vim_log.info "MiqHostDatastoreSystem.addNasDatastoreByName: remoteHost = #{remoteHost}, remotePath = #{remotePath}, localPath = #{localPath}"
+    createNasDatastore(remoteHost, remotePath, localPath, accessMode, type)
+  end
+end # class MiqHostDatastoreSystem

data/lib/VMwareWebService/MiqHostFirewallSystem.rb

@@ -0,0 +1,32 @@
+class MiqHostFirewallSystem
+  attr_reader :invObj
+
+  def initialize(fwsMor, invObj)
+    @invObj = invObj
+    @fwsMor = fwsMor
+  end
+
+  def firewallInfo
+    @invObj.getMoProp(@fwsMor)['firewallInfo']
+  end
+
+  def getRulesByFilter(filter)
+    @invObj.applyFilter(firewallInfo['ruleset'], filter)
+  end
+
+  def disableRuleset(rskey)
+    @invObj.disableRuleset(@fwsMor, rskey)
+  end
+
+  def enableRuleset(rskey)
+    @invObj.enableRuleset(@fwsMor, rskey)
+  end
+
+  def refreshFirewall
+    @invObj.refreshFirewall(@fwsMor)
+  end
+
+  def updateDefaultPolicy(defaultPolicy)
+    @invObj.updateDefaultPolicy(@fwsMor, defaultPolicy)
+  end
+end # class MiqHostFirewallSystem

data/lib/VMwareWebService/MiqHostNetworkSystem.rb

@@ -0,0 +1,16 @@
+class MiqHostNetworkSystem
+  attr_reader :invObj
+
+  def initialize(nsMor, invObj)
+    @invObj = invObj
+    @nsMor = nsMor
+  end
+
+  def networkInfo
+    @invObj.getMoProp(@nsMor)
+  end
+
+  def refreshNetworkSystem
+    @invObj.refreshNetworkSystem(@nsMor)
+  end
+end # class MiqHostNetworkSystem

data/lib/VMwareWebService/MiqHostServiceSystem.rb

@@ -0,0 +1,40 @@
+class MiqHostServiceSystem
+  attr_reader :invObj
+
+  def initialize(ssMor, invObj)
+    @invObj = invObj
+    @ssMor = ssMor
+  end
+
+  def serviceInfo
+    @invObj.getMoProp(@ssMor)['serviceInfo']
+  end
+
+  def getServicesByFilter(filter)
+    @invObj.applyFilter(serviceInfo['service'], filter)
+  end
+
+  def refreshServices
+    @invObj.refreshServices(@ssMor)
+  end
+
+  def restartService(skey)
+    @invObj.restartService(@ssMor, skey)
+  end
+
+  def startService(skey)
+    @invObj.startService(@ssMor, skey)
+  end
+
+  def stopService(skey)
+    @invObj.stopService(@ssMor, skey)
+  end
+
+  def uninstallService(skey)
+    @invObj.uninstallService(@ssMor, skey)
+  end
+
+  def updateServicePolicy(skey, policy)
+    @invObj.updateServicePolicy(@ssMor, skey, policy)
+  end
+end # class MiqHostServiceSystem

data/lib/VMwareWebService/MiqHostSnmpSystem.rb

@@ -0,0 +1,12 @@
+class MiqHostSnmpSystem
+  attr_reader :invObj
+
+  def initialize(ssMor, invObj)
+    @invObj = invObj
+    @ssMor = ssMor
+  end
+
+  def snmpSystem
+    @invObj.getMoProp(@ssMor)
+  end
+end # class MiqHostSnmpSystem

data/lib/VMwareWebService/MiqHostStorageSystem.rb

@@ -0,0 +1,54 @@
+class MiqHostStorageSystem
+  attr_reader :invObj
+
+  def initialize(hssMor, invObj)
+    @invObj = invObj
+    @hssMor = hssMor
+  end
+
+  def fileSystemVolumeInfo
+    @invObj.getMoProp(@hssMor, 'fileSystemVolumeInfo')['fileSystemVolumeInfo']
+  end
+
+  def multipathStateInfo
+    @invObj.getMoProp(@hssMor, 'multipathStateInfo')['multipathStateInfo']
+  end
+
+  def storageDeviceInfo
+    @invObj.getMoProp(@hssMor, 'storageDeviceInfo')['storageDeviceInfo']
+  end
+
+  #
+  # hbaType:
+  #   HostBlockHba, HostFibreChannelHba, HostInternetScsiHba, HostParallelScsiHba
+  #
+  def hostBusAdaptersByType(hbaType)
+    storageDeviceInfo.hostBusAdapter.delete_if { |hba| hba.xsiType != hbaType }
+  end
+
+  def softwareInternetScsiEnabled?
+    sise = @invObj.getMoProp(@hssMor, 'storageDeviceInfo.softwareInternetScsiEnabled')['storageDeviceInfo']['softwareInternetScsiEnabled']
+    sise == 'true'
+  end
+
+  def updateSoftwareInternetScsiEnabled(enabled)
+    @invObj.updateSoftwareInternetScsiEnabled(@hssMor, enabled)
+  end
+
+  def addInternetScsiSendTargets(iScsiHbaDevice, targets)
+    ta = targets.kind_of?(Array) ? targets : [targets]
+    unless ta.first.kind_of?(VimHash)
+      nta = VimArray.new("ArrayOfHostInternetScsiHbaSendTarget") do |nt|
+        ta.each do |t|
+          nt << VimHash.new("HostInternetScsiHbaSendTarget") { |st| st.address = t }
+        end
+      end
+      ta = nta
+    end
+    @invObj.addInternetScsiSendTargets(@hssMor, iScsiHbaDevice, ta)
+  end
+
+  def addInternetScsiStaticTargets(iScsiHbaDevice, targets)
+    @invObj.addInternetScsiStaticTargets(@hssMor, iScsiHbaDevice, targets)
+  end
+end # class MiqHostStorageSystem

data/lib/VMwareWebService/MiqHostVirtualNicManager.rb

@@ -0,0 +1,34 @@
+class MiqHostVirtualNicManager
+  attr_reader :invObj
+
+  def initialize(vnmMor, invObj)
+    @invObj = invObj
+    @vnmMor = vnmMor
+  end
+
+  def info
+    @invObj.getMoProp(@vnmMor)['info']
+  end
+
+  def queryNetConfig(nicType)
+    @invObj.queryNetConfig(@vnmMor, nicType)
+  end
+
+  def candidateVnicsByType(nicType)
+    return [] if (nc = queryNetConfig(nicType)).nil?
+    (nc.candidateVnic || [])
+  end
+
+  def selectedVnicsByType(nicType)
+    return [] if (nc = queryNetConfig(nicType)).nil?
+    (nc.selectedVnic || [])
+  end
+
+  def deselectVnicForNicType(nicType, device)
+    @invObj.deselectVnicForNicType(@vnmMor, nicType, device)
+  end
+
+  def selectVnicForNicType(nicType, device)
+    @invObj.selectVnicForNicType(@vnmMor, nicType, device)
+  end
+end # class MiqHostVirtualNicManager

data/lib/VMwareWebService/MiqPbmInventory.rb

@@ -0,0 +1,70 @@
+require 'VMwareWebService/PbmService'
+
+module MiqPbmInventory
+  def pbm_initialize(vim)
+    begin
+      # SPBM endpoint was introduced in vSphere Management SDK 5.5
+      if @apiVersion < '5.5'
+        $vim_log.info("MiqPbmInventory: VC version < 5.5, not connecting to SPBM endpoint")
+      else
+        @pbm_svc = PbmService.new(vim)
+      end
+    rescue => err
+      $vim_log.warn("MiqPbmInventory: Failed to connect to SPBM endpoint: #{err}")
+    end
+  end
+
+  def pbmProfilesByUid(_selspec = nil)
+    profiles = {}
+    return profiles if @pbm_svc.nil?
+
+    begin
+      profile_ids = @pbm_svc.queryProfile
+      @pbm_svc.retrieveContent(profile_ids).to_a.each do |pbm_profile|
+        uid = pbm_profile.profileId.uniqueId
+
+        profiles[uid] = pbm_profile
+      end
+    rescue => err
+      $vim_log.warn("MiqPbmInventory: pbmProfilesByUid: #{err}")
+    end
+
+    profiles
+  end
+
+  def pbmQueryAssociatedEntity(profile_ids)
+    assoc_entities = {}
+    return assoc_entities if @pbm_svc.nil?
+
+    begin
+      profile_ids.each do |profile_id|
+        # If a string was passed in create a PbmProfileId object
+        profile_id = RbVmomi::PBM::PbmProfileId(:uniqueId => profile_id) if profile_id.kind_of?(String)
+
+        assoc_entities[profile_id.uniqueId] = @pbm_svc.queryAssociatedEntity(profile_id)
+      end
+    rescue => err
+      $vim_log.warn("MiqPbmInventory: pbmQueryAssociatedEntity: #{err}")
+    end
+
+    assoc_entities
+  end
+
+  def pbmQueryMatchingHub(profile_ids)
+    hubs = {}
+    return hubs if @pbm_svc.nil?
+
+    begin
+      profile_ids.each do |profile_id|
+        # If a string was passed in create a PbmProfileId object
+        profile_id = RbVmomi::PBM::PbmProfileId(:uniqueId => profile_id) if profile_id.kind_of?(String)
+
+        hubs[profile_id.uniqueId] = @pbm_svc.queryMatchingHub(profile_id)
+      end
+    rescue => err
+      $vim_log.warn("MiqPbmInventory: pbmQueryMatchingHub: #{err}")
+    end
+
+    hubs
+  end
+end