vmware_web_service 0.1.0

data/lib/VMwareWebService/test/customFieldsManagerTest.rb

@@ -0,0 +1,57 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+# $DEBUG = true
+vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+TARGET_VM = ""
+TARGET_HOST = ""
+
+begin
+  puts "vim.class: #{vim.class}"
+  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+  puts "API version: #{vim.apiVersion}"
+  puts
+
+  #
+  # Test the raw CustomFieldsManager
+  #
+  miqCfm = vim.getMiqCustomFieldsManager
+
+  fields = miqCfm.field
+  if fields
+    vim.dumpObj(fields)
+  else
+    puts "No custom fields currently defined"
+  end
+  puts
+
+  fKey = miqCfm.getFieldKey('EVM Policy', 'VirtualMachine')
+
+  miqVm = vim.getVimVmByFilter("config.name" => TARGET_VM)
+  puts "Target VM: #{TARGET_VM}, MOR: #{miqVm.vmMor}"
+  puts
+
+  # Test raw method.
+  miqCfm.setField(miqVm.vmMor, fKey, 'Test data')
+
+  #
+  # Test VM-specific method.
+  #
+  miqVm.setCustomField('EVM Policy', 'Test data VM')
+
+  #
+  # Now, test for host.
+  #
+  miqHost = vim.getVimHost(TARGET_HOST)
+  miqHost.setCustomField('EVM Policy', 'Test data HOST')
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  miqCfm.release if miqCfm
+  vim.disconnect
+end

data/lib/VMwareWebService/test/customizationSpecManagerTest.rb

@@ -0,0 +1,69 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+$miq_wiredump = true
+
+vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+
+CSI_XML_FILE = File.join(File.dirname(__FILE__), "CustomizationSpec", "sles10-x64-vanilla-cust-spec.xml")
+
+begin
+
+  puts "vim.class: #{vim.class}"
+  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+  puts "API version: #{vim.apiVersion}"
+
+  miqCsm = vim.getVimCustomizationSpecManager
+
+  # puts "***** encryptionKey:"
+  # vim.dumpObj(miqCsm.encryptionKey)
+  # puts
+  puts "***** info:"
+  vim.dumpObj(miqCsm.info)
+
+  puts
+  puts "***** doesCustomizationSpecExist('Win2K3'):"
+  vim.dumpObj(miqCsm.doesCustomizationSpecExist('Win2K3'))
+
+  puts
+  puts "***** doesCustomizationSpecExist('foo'):"
+  vim.dumpObj(miqCsm.doesCustomizationSpecExist('foo'))
+
+  puts
+  puts "***** CustomizationSpecExist('Win2K3'):"
+  csi = miqCsm.getCustomizationSpec('Win2K3')
+  vim.dumpObj(csi)
+
+  puts
+  puts "***** customizationSpecItemToXml:"
+  csiXml = miqCsm.customizationSpecItemToXml(csi)
+  vim.dumpObj(csiXml)
+
+  csiXml = nil
+  File.open(CSI_XML_FILE) { |f| csiXml = f.read }
+
+  puts
+  puts "***** xmlToCustomizationSpecItem:"
+  csi = miqCsm.xmlToCustomizationSpecItem(csiXml)
+  vim.dumpObj(csi)
+
+  if miqCsm.doesCustomizationSpecExist(csi.info.name)
+    puts "***** #{csi.info.name} already exists, deleting..."
+    miqCsm.deleteCustomizationSpec(csi.info.name)
+  end
+
+  puts
+  puts "***** createCustomizationSpec:"
+  vim.dumpObj(miqCsm.createCustomizationSpec(csi))
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  miqCsm.release if miqCsm
+  vim.disconnect
+end

data/lib/VMwareWebService/test/diskPerf.rb

@@ -0,0 +1,122 @@
+require 'manageiq-gems-pending'
+require 'enumerator'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+$stdout.sync = true
+$stderr.sync = true
+
+$miq_wiredump = false
+
+host2 = raise "please define"
+vm = raise "please define"
+
+begin
+    vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+    
+    puts "vim.class: #{vim.class}"
+    puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+    puts "API version: #{vim.apiVersion}"
+    puts
+
+    miqPh = vim.getVimPerfHistory
+    puts "*** Avail intervals:"
+    vim.dumpObj(miqPh.intervals)
+    puts
+    
+    vmo = vim.virtualMachinesByFilter("config.name" => vm)
+    if vmo.empty?
+        puts "VM: #{vm} not found"
+        exit
+    end
+    vmMor = vmo[0]['MOR']
+    
+    # vim.dumpObj(vim.getMoProp(vmMor))
+    puts "*** Calling: queryProviderSummary for #{vm}"
+    psum = miqPh.queryProviderSummary(vmMor)
+    vim.dumpObj(psum)
+    puts
+    
+    puts "Calling: availMetricsForEntity"
+    pmids = miqPh.availMetricsForEntity(vmMor, :intervalId => psum['refreshRate'])
+
+    puts "*** Available Counters for: #{vm}"
+    pmids.each do |pmid|
+        cinfo = miqPh.id2Counter[pmid.counterId]
+        puts "\t#{cinfo['groupInfo']['key']}.#{cinfo['nameInfo']['key']}"
+        puts "\t\tcounterId = #{pmid.counterId}"
+        puts "\t\tinstance = >#{pmid.instance}<"
+    end
+    puts
+    
+    numberRead  = miqPh.getCounterInfo('disk', 'numberRead',  'summation',  'delta')
+    numberWrite = miqPh.getCounterInfo('disk', 'numberWrite', 'summation',  'delta')
+    read    = miqPh.getCounterInfo('disk', 'read',      'average',    'rate')
+    write   = miqPh.getCounterInfo('disk', 'write',     'average',    'rate')
+
+    metricId =  [
+      { :counterId => numberRead['key'],  :instance => "*" },
+      # { :counterId => numberWrite['key'], :instance => "*" },
+      # { :counterId => read['key'],    :instance => "*" },
+      # { :counterId => write['key'],   :instance => "*" }
+    ]
+    ea = [ { :entity => vmMor,  :intervalId => psum['refreshRate'], :metricId => metricId } ]
+  
+    pcm = miqPh.queryPerfMulti(ea)
+    vim.dumpObj(pcm)
+
+    exit
+
+    vma = vim.virtualMachinesByFilter("summary.runtime.hostName" => host2)
+    
+    metricId = [ { :counterId => numberRead['key'], :instance => "*" } ]
+    ea = []
+    
+    puts "VMs on: #{host2}"
+    vma.each do |vmo|
+        puts "\t#{vmo['config']['name']}"
+        ea << { :entity => vmo['MOR'],  :intervalId => psum['refreshRate'], :metricId => metricId }
+    end
+    puts
+    
+    pcm = miqPh.queryPerfMulti(ea)
+    vim.dumpObj(pcm)
+
+    tsHash = Hash.new { |h, k| h[k] = [] }
+    pcm.each do |pem|
+      sInfo = pem['sampleInfo']
+      va = pem['value']['value']
+      sInfo.each_index do |si|
+        ts = sInfo[si]['timestamp'].to_s
+        tsHash[ts] << va[si]
+      end
+    end
+    puts
+  
+    puts "*** Average VM CPU ready time by time-slice:"
+    tsHash.keys.sort.each do |ts|
+      va = tsHash[ts]
+      sum = 0
+      va.each { |v| sum += v.to_i }
+      avg = sum/va.length
+      print ":\t#{ts}: [NV = #{va.length}, AVG = #{avg}]"
+      va.each { |v| print ", #{v}" }
+      puts
+    end
+  
+# puts "**** queryPerfMulti start"
+# vim.dumpObj(pcm)
+# puts "**** queryPerfMulti end"
+    
+rescue => err
+    puts err.to_s
+    puts err.backtrace.join("\n")
+ensure
+    puts
+    puts "Exiting..."
+    miqPh.release if miqPh
+    vim.disconnect if vim
+end

data/lib/VMwareWebService/test/emsRefreshTest.rb

@@ -0,0 +1,78 @@
+USE_BROKER = true
+
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVimBroker'
+require 'VMwareWebService/MiqVim'
+require 'util/extensions/miq-hash'
+require 'util/vmdb-logger'
+
+trap("INT") { exit }
+
+VC_ACCESSORS = [
+  [:dataStoresByMor, :storage],
+  [:hostSystemsByMor, :host],
+  [:virtualMachinesByMor, :vm],
+  [:datacentersByMor, :dc],
+  [:foldersByMor, :folder],
+  [:clusterComputeResourcesByMor, :cluster],
+  [:computeResourcesByMor, :host_res],
+  [:resourcePoolsByMor, :rp],
+]
+
+$vim_log = VMDBLogger.new("./ems_refresh_test.log") unless USE_BROKER
+
+begin
+  loop do
+    vc_data = Hash.new { |h, k| h[k] = {} }
+
+    begin
+
+      if USE_BROKER
+        puts "Connecting with broker."
+        broker = MiqVimBroker.new(:client)
+        vim = broker.getMiqVim(SERVER, USERNAME, PASSWORD)
+      else
+        puts "Connecting without broker."
+        vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+      end
+
+      puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+      puts "API version: #{vim.apiVersion}"
+      puts
+
+      puts "Retrieving inventory..."
+      VC_ACCESSORS.each do |acc, type|
+        puts "  Retrieving #{type}"
+        vc_data[type] = vim.send(acc)
+      end
+
+      unless vc_data[:host].nil?
+        vc_data[:host].each_key do |mor|
+          puts "  Retrieving host scsi data for host mor [#{mor}]"
+          begin
+            vim_host = vim.getVimHostByMor(mor)
+            sd = vim_host.storageDevice
+            vc_data.store_path(mor, 'config', 'storageDevice', sd.fetch_path('config', 'storageDevice')) unless sd.nil?
+          ensure
+            vim_host.release if vim_host rescue nil
+          end
+        end
+      end
+      puts "Retrieving inventory...Complete"
+
+    ensure
+      puts "Disconnecting"
+      vim.disconnect if vim rescue nil
+      vim = nil
+    end
+
+    puts "Pretending to do work with the data"
+    puts
+    sleep 0.5
+  end
+
+rescue => err
+  puts err
+  puts err.class.to_s
+  puts err.backtrace.join("\n")
+end

data/lib/VMwareWebService/test/enterMaintenanceMode.rb

@@ -0,0 +1,56 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+# $miq_wiredump = true
+TARGET_HOST   = raise "please define"
+HOST_USERNAME = ""
+HOST_PASSWORD = ""
+CLUSTER_NAME  = ""
+
+miqCluster  = nil
+miqHost   = nil
+
+vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+
+begin
+
+  puts "vim.class: #{vim.class}"
+  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+  puts "API version: #{vim.apiVersion}"
+
+  puts
+  miqHost = vim.getVimHost(TARGET_HOST)
+  puts "Got object for host: #{miqHost.name}"
+
+  unless miqHost.maintenanceModeSupported?
+    puts "Host does not support maintenance mode"
+    exit
+  end
+
+  if miqHost.inMaintenanceMode?
+    puts "New host is in Maintenance Mode"
+    puts "\texiting Maintenance Mode..."
+    miqHost.exitMaintenanceMode
+    puts "\tdone."
+    puts "inMaintenanceMode? = #{miqHost.inMaintenanceMode?}"
+  end
+
+  puts
+  puts "Putting host in Maintenance Mode..."
+  miqHost.enterMaintenanceMode
+  puts "done."
+  puts
+  puts "inMaintenanceMode? = #{miqHost.inMaintenanceMode?}"
+# vim.dumpObj(miqHost.hh)
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  miqCluster.release if miqCluster
+  vim.disconnect
+end

data/lib/VMwareWebService/test/eventHistoryTest.rb

@@ -0,0 +1,139 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+# $miq_wiredump = true
+
+vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+
+miqHost = nil
+
+begin
+  puts "vim.class: #{vim.class}"
+  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+  puts "API version: #{vim.apiVersion}"
+
+  #
+  # Don't read events that occur after this time.
+  #
+  endTime = vim.currentServerTime.to_s
+
+  ##
+  # Dump all of available events in the event history.
+  # This can take a very long time.
+  ##
+  # eventSpec = VimHash.new("EventFilterSpec") do |efs|
+  #   efs.time = VimHash.new("EventFilterSpecByTime") do |eft|
+  #     eft.endTime = endTime
+  #   end
+  #   efs.disableFullMessage = 'true'
+  # end
+  # miqEh = vim.getVimEventHistory(eventSpec)
+  #
+  # p = 0
+  # while (events = miqEh.readNext) do
+  #   puts "Events - Page #{p}:"
+  #   vim.dumpObj(events)
+  #   p += 1
+  # end
+
+  ##
+  # Dump all the available events of type 'VmCreatedEvent' or 'VmRemovedEvent'
+  ##
+  eventSpec = VimHash.new("EventFilterSpec") do |efs|
+    efs.time = VimHash.new("EventFilterSpecByTime") do |eft|
+      eft.endTime = endTime
+    end
+    efs.disableFullMessage = 'false'
+    efs['type'] = ['VmCreatedEvent']
+  end
+
+  miqEh = vim.getVimEventHistory(eventSpec)
+
+  #
+  # Read events from newest to oldest.
+  #
+  miqEh.reset
+  #
+  # It looks like the reset method doesn't position us at the first page.
+  # readPrevious returns the second page and readNext returns the first.
+  # This readNext is just to position us at the first page. It will return
+  # the first page of data and so will the first readPrevious, so we ignore
+  # the data returned by readNext.
+  #
+  events = miqEh.readNext
+
+  p = 0
+  nevent = 0
+  while (events = miqEh.readPrevious)
+    puts "Events - Page #{p}:"
+    events.each do |event|
+      puts "*** Event: #{event.xsiType}"
+      puts "****** #{event.vm.name}"
+      #
+      # Check to see if the VM is still in the inventory.
+      #
+      # Match by MOR and VM name, just in case the MOR was reused.
+      # This may not be 100% accurate, we may need to add additional checks to ensure we associate
+      # the proper VM with the event.
+      #
+      vm = vim.virtualMachinesByFilter('summary.vm' => event.vm.vm, 'config.name' => event.vm.name).first
+      if !vm
+        puts "****** VM no longer exists"
+      else
+        puts "****** VM path: #{vm.summary.config.vmPathName}"
+      end
+      puts event.createdTime
+      nevent += 1
+      # vim.dumpObj(event)
+      puts
+    end
+    p += 1
+  end
+  puts "*** Total events: #{nevent}"
+  puts
+
+  #
+  # Read events from oldest to newest.
+  #
+  miqEh.rewind
+
+  p = 0
+  nevent = 0
+  while (events = miqEh.readNext)
+    puts "Events - Page #{p}:"
+    events.each do |event|
+      puts "*** Event: #{event.xsiType}"
+      puts "****** #{event.vm.name}"
+      #
+      # Check to see if the VM is still in the inventory.
+      #
+      # Match by MOR and VM name, just in case the MOR was reused.
+      # This may not be 100% accurate, we may need to add additional checks to ensure we associate
+      # the proper VM with the event.
+      #
+      vm = vim.virtualMachinesByFilter('summary.vm' => event.vm.vm, 'config.name' => event.vm.name).first
+      if !vm
+        puts "****** VM no longer exists"
+      else
+        puts "****** VM path: #{vm.summary.config.vmPathName}"
+      end
+      puts event.createdTime
+      nevent += 1
+      # vim.dumpObj(event)
+      puts
+    end
+    p += 1
+  end
+  puts "*** Total events: #{nevent}"
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  miqEh.release if miqEh
+  vim.disconnect
+end

data/lib/VMwareWebService/test/hostAdvancedOptionTest.rb

@@ -0,0 +1,45 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+# $DEBUG = true
+
+TARGET_HOST = raise "please define"
+hMor = nil
+
+broker = MiqVimBroker.new(:client)
+vim = broker.getMiqVim(CLIENT, USERNAME, PASSWORD)
+
+miqHost = nil
+
+begin
+    puts "vim.class: #{vim.class}"
+    puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+    puts "API version: #{vim.apiVersion}"
+
+    miqHost = vim.getVimHost(TARGET_HOST)
+
+    raise "Host has no advanced option manager" if !(aom = miqHost.advancedOptionManager)
+  
+    puts
+    puts "*** Advanced option supportedOption:"
+    vim.dumpObj(aom.supportedOption)
+  
+    puts
+    puts "*** Advanced option setting:"
+    vim.dumpObj(aom.setting)
+  
+    puts
+    puts "*** Advanced option setting for 'Mem:"
+    vim.dumpObj(aom.queryOptions('Mem.'))
+  
+rescue => err
+    puts err.to_s
+    puts err.backtrace.join("\n")
+ensure
+  miqHost.release if miqHost
+  vim.disconnect
+end

data/lib/VMwareWebService/test/hostConfigSpecTest.rb

@@ -0,0 +1,51 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+# $miq_wiredump = true
+
+TARGET_HOST = raise "please define"
+hMor = nil
+
+vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+
+miqHost = nil
+
+begin
+    puts "vim.class: #{vim.class}"
+    puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+    puts "API version: #{vim.apiVersion}"
+
+    puts "Host name: #{TARGET_HOST}"
+    puts
+    
+    # puts "**** Host services:"
+    # vim.dumpObj(vim.hostSystems[TARGET_HOST]['config']['service'])
+    # puts "****************************************************************"
+    # puts
+  
+    miqHost = vim.getVimHost(TARGET_HOST)
+
+    # vim.dumpObj(vim.getMoProp(miqHost.hMor))
+    # exit
+
+    puts "Host name: #{miqHost.name}"
+    puts
+    vim.dumpObj(miqHost.configManager)
+    exit
+
+    puts "**** hostConfigSpec:"
+    vim.dumpObj(miqHost.hostConfigSpec)
+    puts "****************************************************************"
+    puts
+  
+rescue => err
+    puts err.to_s
+    puts err.backtrace.join("\n")
+ensure
+  miqHost.release if miqHost
+  vim.disconnect
+end

data/lib/VMwareWebService/test/hostDatastoreTest.rb

@@ -0,0 +1,51 @@
+require 'manageiq-gems-pending'
+require 'VMwareWebService/MiqVim'
+require 'VMwareWebService/MiqVimBroker'
+
+$vim_log = Logger.new(STDOUT)
+$vim_log.level = Logger::WARN
+
+$stdout.sync = true
+# $miq_wiredump = true
+
+TARGET_HOST = raise "please define"
+
+begin
+  vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+
+  puts "vim.class: #{vim.class}"
+  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
+  puts "API version: #{vim.apiVersion}"
+  puts
+
+  hh = vim.hostSystems[TARGET_HOST]
+  dataStores = vim.dataStoresByMor
+
+  puts "**** Host datastores:"
+  # vim.dumpObj(hh['datastore'])
+  # exit
+
+  hh['datastore'].each do |dsMor|
+    puts "**** #{dataStores[dsMor]['summary']['name']} -> #{dsMor}"
+    vim.dumpObj(dataStores[dsMor])
+    info = vim.getMoProp(dsMor, 'info')
+    puts "  *********** INFO:"
+    vim.dumpObj(info, 1)
+    puts
+  end
+
+  scsiLun = vim.getMoProp(hh['MOR'], "config.storageDevice.scsiLun")['config']['storageDevice']['scsiLun']
+  puts
+  puts "*********** scsiLun:"
+  vim.dumpObj(scsiLun)
+
+  scsiTopology = vim.getMoProp(hh['MOR'], "config.storageDevice.scsiTopology")['config']['storageDevice']['scsiTopology']
+  puts
+  puts "*********** scsiTopology:"
+  vim.dumpObj(scsiTopology)
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  vim.disconnect
+end