vmware_web_service 2.1.1 → 3.0.0

data/lib/VMwareWebService/DMiqVim.rb

@@ -1,95 +0,0 @@
-require 'VMwareWebService/MiqVim'
-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 DMiqVimSync
-
-  # @param server [String] DNS name or IP address of the vCenter Server 
-  # @param username [String] Username to connect to the vCenter Server
-  # @param password [String] Password to connect to the vCenter Server
-  # @param broker [MiqVimBroker] Instance of the broker worker this connection belongs to
-  # @param preLoad [Bool] Should the cache be built before returning the connection (default: false)
-  # @param debugUpdates [Bool] Should we print debug info for each update (default: false)
-  # @param notifyMethod [Method] A optional method to call for each update (default: nil)
-  # @param cacheScope [Symbol] A pre-defined set of properties to cache (default: nil)
-  # @param maxWait [Integer] How many seconds to wait before breaking out of WaitForUpdates (default: 60)
-  # @param maxObjects [Integer] How many objects to return from each WaitForUpdates page (default: 250)
-  def initialize(server, username, password, broker, preLoad = false, debugUpdates = false, notifyMethod = nil, cacheScope = nil, maxWait = 60, maxObjects = 250)
-    super(server, username, password, cacheScope, monitor_updates = true, preLoad, debugUpdates, notifyMethod, maxWait, maxObjects)
-
-    @broker                 = broker
-    @connectionShuttingDown = false
-    @connectionRemoved      = false
-  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
-    serverPrivateDisconnect if self.isAlive?
-    $vim_log.info "#{log_prefix}: for address=<#{@server}>, username=<#{@username}>...Complete" if $vim_log
-  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

@@ -1,45 +0,0 @@
-
-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/MiqVimBroker.rb

@@ -1,581 +0,0 @@
-require 'drb'
-require 'drb/acl'
-require 'sync'
-require 'tmpdir'
-
-require 'VMwareWebService/MiqVimInventory'
-require 'VMwareWebService/VimTypes'
-
-class MiqVimBroker
-  class VimBrokerIdConv < DRb::DRbIdConv
-    def to_obj(ref)
-      obj = super(ref)
-      if obj.respond_to?(:connectionRemoved?) && obj.connectionRemoved?
-        $vim_log.info "VimBrokerIdConv: #{obj.class.name} - connection removed"
-        raise RangeError, "#{ref} is recycled object"
-      end
-      obj
-    end
-  end
-
-  attr_reader :shuttingDown
-
-  MB = 1048576
-  DRb::DRbServer.default_load_limit(100 * MB)
-
-  @@preLoad   = false
-  @@debugUpdates  = false
-  @@classModed  = false
-  @@notifyMethod  = nil
-  @@updateDelay = nil
-  @@cacheScope  = :cache_scope_full
-  @@selectorHash  = {}
-  @@maxWait    = 60
-  @@maxObjects = 250
-
-  def initialize(mode = :client, uri = nil)
-    if mode == :client
-      require 'rubygems'
-      require 'httpclient'  # needed for exception classes
-      require 'VMwareWebService/MiqVimDump'
-      require 'VMwareWebService/MiqVimVdlMod'
-      #
-      # Modify the meta-class of DRb::DRbObject
-      # so we can alias class methods
-      #
-      unless @@classModed
-        class <<DRb::DRbObject
-          alias_method :new_with_original, :new_with
-          def new_with(uri, ref)
-            obj = new_with_original(uri, ref)
-            obj.extend(MiqVimVdlVcConnectionMod) if obj.respond_to?(:vdlVcConnection)
-            obj.registerBrokerObj($$) if obj.respond_to?(:registerBrokerObj)
-            (obj)
-          end
-        end
-
-        DRb.instance_variable_set(:@mutex, Sync.new)
-        DRb::DRbConn.instance_variable_set(:@mutex, Sync.new)
-        @@classModed = true
-      end
-
-      @mode = :client
-
-      # start DRb service if it hasn't been started before
-      begin
-        DRb.current_server
-      rescue DRb::DRbServerNotFound
-        DRb.start_service
-      end
-
-      @broker = DRbObject.new(nil, uri)
-    elsif mode == :server
-      require 'timeout'
-      require 'VMwareWebService/broker_timeout'
-
-      unless @@classModed
-        DRb.instance_variable_set(:@mutex, sync_for_drb)
-        DRb::DRbConn.instance_variable_set(:@mutex, sync_for_drb_drbconn)
-      end
-      @@classModed = true
-
-      require 'VMwareWebService/MiqVimBrokerMods' # only needed by the server
-      @mode = :server
-      @shuttingDown = false
-
-      @connectionHash = {}
-      @lockHash = {}        # Protects individual @connectionHash entries
-      @connectionLock = connection_lock # Protects @lockHash
-
-      @configLock   = config_lock
-      @selectorHash = @@selectorHash
-      @cacheScope   = @@cacheScope
-
-      acl = ACL.new(%w( deny all allow 127.0.0.1/32 ))
-      DRb.install_acl(acl)
-
-      Dir::Tmpname.create('MiqVimBroker', nil) do |path|
-        DRb.start_service("drbunix://#{path}", self, :idconv => VimBrokerIdConv.new)
-        FileUtils.chmod(0o750, path)
-      end
-    else
-      raise "MiqVimBroker: unrecognized mode #{mode}"
-    end
-  end
-
-  def connection_lock
-    Sync.new
-  end
-
-  def config_lock
-    Sync.new
-  end
-
-  def sync_for_lock_hash(_key)
-    Sync.new
-  end
-
-  def sync_for_drb_drbconn
-    Sync.new
-  end
-
-  def sync_for_drb
-    Sync.new
-  end
-
-  def self.cacheScope
-    @@cacheScope
-  end
-
-  def self.cacheScope=(val)
-    @@cacheScope = val
-  end
-
-  attr_reader :cacheScope
-
-  attr_writer :cacheScope
-
-  #
-  # The setSelector() and removeSelector() class methods, set the Selector specs that will be inherited
-  # by all subsequent MiqVimBroker instances.
-  #
-  # Should only be called on the server-side.
-  #
-  def self.setSelector(selSpec)
-    raise "MiqVimBroker.setSelector: selSpec must be a hash, received #{selSpec.class}" unless selSpec.kind_of?(Hash)
-    selSpec.each_key do |k|
-      raise "MiqVimBroker.setSelector: selSpec keys must be symbols, received #{k.class}" unless k.kind_of?(Symbol)
-    end
-    ov = nil
-    selSpec.each_value do |v|
-      if v.kind_of?(Array)
-        v.each do |vv|
-          unless vv.kind_of?(String)
-            ov = vv
-            break
-          end
-        end
-      else
-        ov = v unless v.kind_of?(String)
-      end
-      raise "MiqVimBroker.setSelector: selSpec values must be strings or arrays of strings, received #{ov.class}" unless ov.nil?
-    end
-    @@selectorHash.merge!(selSpec)
-  end
-
-  def self.removeSelector(selName)
-    remKeys = nil
-    if selName.kind_of?(Symbol)
-      remKeys = [selName]
-    elsif selName.kind_of?(Hash)
-      remKeys = selName.keys
-    elsif selName.kind_of?(Array)
-      remKeys = selName
-    else
-      raise "MiqVimBroker.removeSelector: selName must be a symbol, hash or array, received #{selName.class}"
-    end
-    remKeys.each do |rk|
-      raise "MiqVimBroker.removeSelector: keys must be symbols, received #{rk.class}" unless rk.kind_of?(Symbol)
-    end
-
-    remKeys.each do |rk|
-      @@selectorHash.delete(rk)
-    end
-  end
-
-  #
-  # The setSelector() and removeSelector() instance methods, set the Selector specs that will be inherited
-  # by all subsequent connections.
-  #
-  def setSelector(selSpec)
-    if @mode == :client
-      return @broker.setSelector(selSpec)
-    end
-
-    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)
-    end
-  end
-
-  def removeSelector(selName)
-    if @mode == :client
-      return @broker.removeSelector(selName)
-    end
-
-    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)
-      end
-    end
-  end
-
-  def self.preLoad=(val)
-    @@preLoad = val
-  end
-
-  def self.preLoad
-    @@preLoad
-  end
-
-  def self.debugUpdates=(val)
-    @@debugUpdates = val
-  end
-
-  def self.debugUpdates
-    @@debugUpdates
-  end
-
-  #
-  # Instance method changes the debugUpdates value of existing connections.
-  #
-  def debugUpdates=(val)
-    return if @mode == :client
-    @connectionHash.keys.each do |key|
-      @lockHash[key].synchronize(:SH) do
-        next if (vim = @connectionHash[key]).nil?
-        vim.debugUpdates = val
-      end
-    end
-  end
-
-  def self.notifyMethod=(val)
-    @@notifyMethod = val
-  end
-
-  def self.notifyMethod
-    @@notifyMethod
-  end
-
-  #
-  # Instance method changes the notifyMethod value of existing connections.
-  #
-  def notifyMethod=(val)
-    return if @mode == :client
-    @connectionHash.keys.each do |key|
-      @lockHash[key].synchronize(:SH) do
-        next if (vim = @connectionHash[key]).nil?
-        vim.notifyMethod = val
-      end
-    end
-  end
-
-  def self.updateDelay=(val)
-    @@updateDelay = val
-  end
-
-  def self.updateDelay
-    @@updateDelay
-  end
-
-  #
-  # Instance method changes the updateDelay value of existing connections.
-  #
-  def updateDelay=(val)
-    return if @mode == :client
-    @connectionHash.keys.each do |key|
-      @lockHash[key].synchronize(:SH) do
-        next if (vim = @connectionHash[key]).nil?
-        vim.updateDelay = val
-      end
-    end
-  end
-
-  def self.maxWait=(val)
-    @@maxWait = val
-  end
-
-  def self.maxWait
-    @@maxWait
-  end
-
-  def self.maxObjects=(val)
-    @@maxObjects = val
-  end
-
-  def self.maxObjects
-    @@maxObjects
-  end
-
-  def releaseSession(sessionId)
-    if @mode == :client
-      $vim_log.info "Client releaseSession: #{sessionId}"
-      @broker.releaseSession(sessionId)
-    else
-      $vim_log.info "Server releaseSession: #{sessionId}"
-      $miqBrokerObjRegistry[sessionId].dup.each(&:release)
-    end
-  end
-
-  def objectCounts
-    if @mode == :client
-      @broker.objectCounts
-    else
-      $miqBrokerObjRegistryLock.synchronize(:SH) do
-        return $miqBrokerObjCounts.dup
-      end
-    end
-  end
-
-  def self.connectionKey(server, username)
-    "#{server}_#{username}"
-  end
-
-  def connectionKey(server, username)
-    self.class.connectionKey(server, username)
-  end
-
-  def lockHash(key)
-    @connectionLock.synchronize(:EX) do
-      raise "MiqVimBroker is shutting down" if @shuttingDown
-      #
-      # Once set, @lockHash[key] doesn't change.
-      #
-      @lockHash[key] ||= sync_for_lock_hash(key)
-    end
-  end
-
-  def connSync(mode, server, username, &block)
-    key = connectionKey(server, username)
-    lock = lockHash(key)
-
-    begin
-      lock.sync_lock(mode)
-      if block.arity < 1
-        block.call
-      elsif block.arity == 1
-        block.call(key)
-      elsif block.arity == 2
-        block.call(key, @connectionHash[key])
-      else
-        raise "MiqVimBroker.connSync: unexpected number of block args: #{block.arity}"
-      end
-    ensure
-      lock.sync_unlock
-    end
-  end
-
-  def connTrySync(mode, server, username, &block)
-    key = connectionKey(server, username)
-    lock = lockHash(key)
-
-    begin
-      locked = lock.sync_try_lock(mode)
-      return unless locked
-
-      if block.arity < 1
-        block.call
-      elsif block.arity == 1
-        block.call(key)
-      elsif block.arity == 2
-        block.call(key, @connectionHash[key])
-      else
-        raise "MiqVimBroker.connTrySync: unexpected number of block args: #{block.arity}"
-      end
-    ensure
-      lock.sync_unlock if locked
-    end
-  end
-
-  def getMiqVim(server, username, password)
-    if @mode == :client
-      vim = @broker.getMiqVim(server, username, password)
-      vim.extend(MiqVimDump)
-      vim.extend(MiqVimVdlConnectionMod)
-      return(vim)
-    else # :server
-      connSync(:EX, server, username) do |key, vim|
-        if vim
-          $vim_log.info "MiqVimBroker.getMiqVim: found connection for #{key}"
-          if vim.isAlive?
-            $vim_log.info "MiqVimBroker.getMiqVim: returning existing connection for #{key}"
-            return(vim)
-          end
-          $vim_log.info "MiqVimBroker.getMiqVim: existing connection for #{key} not alive"
-          removeMiqVimSS(key, vim)
-        end
-        begin
-          vim = DMiqVim.new(server.untaint, username, password, self, @@preLoad, @@debugUpdates, @@notifyMethod, @cacheScope, @@maxWait, @@maxObjects)
-          vim.updateDelay = @@updateDelay if @@updateDelay
-          vim.setSelector(@selectorHash) unless @selectorHash.empty?
-          $vim_log.info "MiqVimBroker.getMiqVim: returning new connection for #{key}"
-          @connectionHash[key] = vim
-          return(vim)
-        rescue Exception => err
-          $vim_log.error "MiqVimBroker.getMiqVim: failed to create new connection for #{key}"
-          $vim_log.error "#{err.class}: #{err}"
-          if $vim_log.debug?
-            $vim_log.debug "Stack trace START"
-            $vim_log.debug err.backtrace.join("\n")
-            $vim_log.debug "Stack trace END"
-          end
-          raise err
-        end
-      end
-    end # :server
-  end
-
-  def removeMiqVim(server, username)
-    if @mode == :client
-      @broker.removeMiqVim(server, username)
-      return
-    end
-
-    # server
-    log_prefix = "MiqVimBroker.removeMiqVim"
-    $vim_log.info "#{log_prefix}: client request to remove connection (#{server}, #{username})...Starting"
-    connSync(:EX, server, username) do |key, vim|
-      removeMiqVimSS(key, vim)
-    end
-    $vim_log.info "#{log_prefix}: client request to remove connection (#{server}, #{username})...Comolete"
-  end
-
-  #
-  # Server-side removal of VIM connection.
-  # Must be called within a connSync(:EX, server, username) context.
-  #
-  def removeMiqVimSS(key, vim)
-    log_prefix = "MiqVimBroker.removeMiqVimSS"
-    $vim_log.info "#{log_prefix}: removing connection for #{key}...Starting"
-
-    if @shuttingDown
-      $vim_log.info "#{log_prefix}: not removing connection for #{key} - broker shutting down"
-      return
-    end
-    if vim.nil?
-      $vim_log.info "#{log_prefix}: not removing connection for #{key} - connection not found"
-      return
-    end
-    if vim.connectionRemoved?
-      $vim_log.info "#{log_prefix}: not removing connection for #{key} - connection already removed"
-      return
-    end
-
-    vim.shutdownConnection
-    $miqBrokerObjRegistryByConn[key].dup.each(&:release)
-    @connectionHash.delete(key)
-    vim.connectionRemoved
-
-    $vim_log.info "#{log_prefix}: removing connection for #{key}...Complete"
-  end
-
-  def shutdown
-    raise "MiqVimBroker: shutdown cannot be called from client" if @mode == :client
-    log_prefix = "MiqVimBroker.shutdown"
-    $vim_log.info "#{log_prefix}...Starting"
-    @connectionLock.synchronize(:EX) do
-      @shuttingDown = true
-    end
-    @connectionHash.keys.each do |id|
-      @lockHash[id].synchronize(:EX) do
-        next if (vim = @connectionHash[id]).nil?
-        vim.shutdownConnection
-        @connectionHash.delete(id)
-        vim.connectionRemoved
-      end
-    end
-    DRb.stop_service
-    $vim_log.info "#{log_prefix}...Complete"
-  end
-
-  def serverAlive?
-    if @mode == :client
-      begin
-        return @broker.serverAlive?
-      rescue DRb::DRbConnError
-        return false
-      end
-    end
-    true
-  end
-
-  def connectionInfo
-    return @broker.connectionInfo if @mode == :client
-
-    # server
-    ra = []
-    @connectionHash.keys.each do |key|
-      @lockHash[key].synchronize(:SH) do
-        next if (vim = @connectionHash[key]).nil?
-        ra << [vim.server, vim.username]
-      end
-    end
-    ra
-  end
-
-  def logStatus
-    if @mode == :client
-      @broker.logStatus
-      return
-    end
-
-    return unless $vim_log.info?
-
-    # server
-    $vim_log.info "MiqVimBroker status start"
-    $vim_log.info "\tMiqVimBroker: Threads = #{Thread.list.length}"
-
-    $vim_log.info "\tMiqVimBroker client object counts by type:"
-    objectCounts.each { |t, c| $vim_log.info "\t\t#{t}: #{c}" }
-    $vim_log.info "\tEnd MiqVimBroker client object counts by type"
-
-    brokerCacheSz = 0
-
-    $vim_log.info "\tMiqVimBroker open connections: #{@connectionHash.keys.length}"
-    @connectionHash.keys.each do |k|
-      @lockHash[k].synchronize(:SH) do
-        next if (vim = @connectionHash[k]).nil?
-        $vim_log.info "\t\tMiqVimBroker connection #{k} cache counts:"
-        # vim.logCacheCounts("\t\t\t")
-        brokerCacheSz += vim.cacheStats("\t\t\t#{k} - ")
-        $vim_log.info "\t\tEnd MiqVimBroker connection #{k} cache counts"
-      end
-    end
-    $vim_log.info "\tEnd MiqVimBroker open connections"
-    $vim_log.info "MiqVimBroker status end - Total broker cache size = #{brokerCacheSz}"
-  end
-
-  def forceGC
-    if @mode == :client
-      @broker.forceGC
-      return
-    end
-
-    log_prefix = "MiqVimBroker.forceGC"
-    $vim_log.info "#{log_prefix}: GC.start...Starting"
-    GC.start
-    $vim_log.info "#{log_prefix}: GC.start...Complete"
-  end
-end # class MiqVimBroker