vmware_web_service 0.1.1 → 0.1.2

data/lib/VMwareWebService/test/shutdownHostTest.rb

@@ -1,47 +0,0 @@
-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
-
-broker = MiqVimBroker.new(:client)
-vim = broker.getMiqVim(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.shutdownSupported?
-      puts "Host does not support shutdown"
-      exit
-    end
-  
-    puts
-    puts "Shutting down host..."
-    miqHost.shutdownHost
-    puts "done."
-  
-
-rescue => err
-    puts err.to_s
-    puts err.backtrace.join("\n")
-ensure
-  miqCluster.release if miqCluster
-  vim.disconnect
-end

data/lib/VMwareWebService/test/snapshotTest.rb

@@ -1,61 +0,0 @@
-require 'manageiq-gems-pending'
-require 'VMwareWebService/MiqVim'
-
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-$stdout.sync = true
-
-TARGET_VM = "AAA2206"
-vmMor = nil
-
-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
-
-  miqVm = vim.getVimVmByFilter("config.name" => TARGET_VM)
-
-  puts "Has EvmSnapshot: #{miqVm.hasSnapshot?('EvmSnapshot')}"
-  miqVm.removeAllSnapshots
-  exit
-
-  puts
-  puts "*** START Snapshot info from vim.virtualMachines"
-  vim.dumpObj(miqVm.vmh['snapshot'])
-  puts "*** END Snapshot info from vim.virtualMachines"
-  puts
-
-  ssInfo = miqVm.snapshotInfo
-
-  if ssInfo
-    # vim.dumpObj(ssInfo)
-    hasCh = miqVm.hasSnapshot?("Consolidate Helper", true)
-    puts "Has Consolidate Helper = #{hasCh}"
-    # exit
-
-    ssHash = ssInfo['ssMorHash']
-    curSnapshot = ssHash[ssInfo['currentSnapshot'].to_s]['snapshot']
-    puts
-    puts "curSnapshot = #{curSnapshot}"
-    puts "curSnapshot name = #{ssHash[ssInfo['currentSnapshot'].to_s]['name']}"
-    puts "++++++++++++++ snapshot props from tree +++++++++++++++++++++++++++"
-    vim.dumpObj(ssInfo)
-    puts "+++++++++++++++ end snapshot props from tree ++++++++++++++++++++++++++"
-  else
-    puts "No snapshots found"
-  end
-
-  snMor = miqVm.createSnapshot("rpoTest", "test snapshot", false, "false")
-  puts "snMor = #{snMor}"
-
-  miqVm.removeSnapshot(snMor)
-# miqVm.removeSnapshot(String.new(snMor.to_s))
-rescue => err
-  puts err.to_s
-  puts err.backtrace.join("\n")
-ensure
-  vim.disconnect
-end

data/lib/VMwareWebService/test/templateTest.rb

@@ -1,67 +0,0 @@
-require 'manageiq-gems-pending'
-require 'VMwareWebService/MiqVim'
-
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-TARGET_VM = "rpo-template-test"
-vmMor = nil
-miqVm = nil
-
-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
-
-  miqVm = vim.getVimVmByFilter("config.name" => TARGET_VM)
-
-  puts "VM: #{miqVm.name}"
-  puts
-
-  isTemplate = miqVm.template?
-
-  puts "Template: #{isTemplate}"
-  unless isTemplate
-    puts "Marking VM as Template."
-    miqVm.markAsTemplate
-    puts "Template: #{miqVm.template?}"
-    exit
-  end
-
-  targetHostObj = vim.hostSystems.values.first
-  raise "No suitable target host system found" unless targetHostObj
-
-  targetRp = nil
-  vim.resourcePoolsByMor.each_value do |rp|
-    owner = rp['owner']
-    next unless (cr = vim.computeResourcesByMor[owner])
-    hosts = cr['host']['ManagedObjectReference']
-    hosts = [hosts] unless hosts.kind_of?(Array)
-    hosts.each do |hmor|
-      if hmor == targetHostObj['MOR']
-        targetRp = rp
-        break
-      end
-    end
-    break if targetRp
-  end
-  puts
-
-  raise "No suitable target resource pool found" unless targetRp
-
-  puts "Marking VM as Virtual Machine."
-  puts
-  miqVm.markAsVm(targetRp, targetHostObj)
-  puts "Template: #{miqVm.template?}"
-rescue => err
-  puts err.to_s
-  puts err.backtrace.join("\n")
-ensure
-  puts
-  puts "Exiting..."
-  miqVm.release if miqVm
-  vim.disconnect if vim
-end

data/lib/VMwareWebService/test/thinProvisioned.rb

@@ -1,87 +0,0 @@
-require 'manageiq-gems-pending'
-require 'VMwareWebService/MiqVim'
-require 'VMwareWebService/MiqVimBroker'
-
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-TARGET_VM = raise "please define"
-miqVm = nil
-
-begin
-  vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
-
-  # vim.logger = $stdout
-
-  puts "vim.class: #{vim.class}"
-  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
-  puts "API version: #{vim.apiVersion}"
-  puts
-
-  miqVm = vim.getVimVmByFilter("config.name" => TARGET_VM)
-
-  # puts miqVm.acquireMksTicket
-
-  puts
-  puts "Connection State: #{miqVm.connectionState}"
-  puts "Power State:      #{miqVm.powerState}"
-  puts
-
-  thinDevs = miqVm.devicesByFilter("backing.thinProvisioned" => "true")
-
-  if thinDevs.empty?
-    puts "#{TARGET_VM} has no thin provisioned disks."
-    exit
-  end
-
-  vimDs = nil
-  puts "Thin provisioned disks for #{TARGET_VM}:"
-  thinDevs.each do |d|
-    path = d['backing']['fileName']
-    dsrPath = vim.dsRelativePath(path)
-    dir, file = File.split(dsrPath)
-
-    #
-    # Just in case all the files aren't on the same datastore.
-    #
-    if vimDs
-      if vimDs.dsMor != d['backing']['datastore']
-        vimDs.release
-        vimDs = vim.getVimDataStoreByMor(d['backing']['datastore'])
-      end
-    else
-      vimDs = vim.getVimDataStoreByMor(d['backing']['datastore'])
-      puts
-      puts "\t(Datastore capacity:           #{vimDs.capacityBytes} bytes)"
-      puts "\t(Datastore free space:         #{vimDs.freeBytes} bytes)"
-      if vimDs.uncommitted
-        deltaCommit = vimDs.freeBytes - vimDs.uncommitted
-        puts "\t(Datastore uncommitted space:  #{vimDs.uncommitted} bytes)"
-        if deltaCommit >= 0
-          puts "\t(Datastore under committed by: #{deltaCommit} bytes)"
-        else
-          puts "\t(Datastore over committed by: #{-deltaCommit} bytes)"
-        end
-      end
-      puts
-    end
-
-    fo = vimDs.dsVmDiskFileSearch(file, dir, false, false).first
-
-    puts "\tPath: #{path}"
-    puts "\t\tFile: #{file}"
-    puts "\t\tCapacity:  #{d['capacityInKB']} KB"
-    puts "\t\tFile size: #{fo.fileSize.to_i / 1024} KB" if fo
-    puts
-  end
-
-rescue => err
-  puts err.to_s
-  puts err.backtrace.join("\n")
-ensure
-  puts
-  puts "Exiting..."
-  vimDs.release if vimDs
-  miqVm.release if miqVm
-  vim.disconnect if vim
-end

data/lib/VMwareWebService/test/vdlBrowserTest.rb

@@ -1,113 +0,0 @@
-require 'manageiq-gems-pending'
-require 'enumerator'
-
-require 'VMwareWebService/MiqVimBroker'
-require 'VMwareWebService/VixDiskLib/VixDiskLib'
-
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-$stderr.sync = true
-$stdout.sync = true
-
-# $DEBUG = true
-# MiqVimClientBase.wiredump_file = "clone.txt"
-
-SRC_VM      = "rpo-test2"
-
-readRanges = [
-  0,  256,
-  0,  512,
-  256,  512,
-  512,  256,
-  512,  512,
-  256, 1024,
-  1280,  256,
-  1280,  512,
-  1280, 1024
-]
-
-vDisk = nil
-vdlc  = nil
-
-begin
-  broker = MiqVimBroker.new(:client)
-  unless broker.serverAlive?
-    puts "Broker server isn't running"
-    exit
-  end
-
-  t0 = Time.now
-
-  vim = broker.getMiqVim.new(SERVER, USERNAME, PASSWORD)
-
-  puts "vim.class: #{vim.class}"
-  puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
-  puts "API version: #{vim.apiVersion}"
-  puts
-
-  svm = vim.virtualMachinesByFilter("config.name" => SRC_VM)
-  if svm.empty?
-    puts "VM: #{SRC_VM} not found"
-    exit
-  end
-
-  puts "#{SRC_VM} vmPathName:      #{svm[0]['summary']['config']['vmPathName']}"
-  puts "#{SRC_VM} vmLocalPathName: #{svm[0]['summary']['config']['vmLocalPathName']}"
-
-  sVmMor = svm[0]['MOR']
-  miqVm = vim.getVimVmByMor(sVmMor)
-
-  puts "VM: #{miqVm.name}, HOST: #{miqVm.hostSystem}"
-  puts
-
-  diskFile = miqVm.getCfg['scsi0:0.filename']
-  ldiskFile = vim.localVmPath(diskFile)
-  puts "diskFile: #{diskFile}"
-  puts "ldiskFile: #{ldiskFile}"
-  puts
-
-  if vim.isVirtualCenter?
-    puts "Calling: miqVm.vdlVcConnection"
-    vdlc = miqVm.vdlVcConnection
-    vDisk = vdlc.getDisk(diskFile, VixDiskLib_raw::VIXDISKLIB_FLAG_OPEN_READ_ONLY)
-  else
-    vdlc = vim.vdlConnection
-    vDisk = vdlc.getDisk(ldiskFile, VixDiskLib_raw::VIXDISKLIB_FLAG_OPEN_READ_ONLY)
-  end
-
-  dinfo = vDisk.info
-  puts
-  puts "Disk info:"
-  dinfo.each { |k, v| puts "\t#{k} => #{v}" }
-  puts
-
-  readRanges.each_slice(2) do |start, len|
-    puts "Read test: start = #{start}, len = #{len} (bytes)"
-    startSector, startOffset = start.divmod(vDisk.sectorSize)
-    endSector = (start + len - 1) / vDisk.sectorSize
-    numSector = endSector - startSector + 1
-    puts "\tstartSector = #{startSector}, numSector = #{numSector}, startOffset = #{startOffset}"
-
-    rBData = vDisk.bread(startSector, numSector)
-    puts "\tBlock read #{rBData.length} bytes of data."
-
-    rCData = vDisk.read(start, len)
-    puts "\tByte read #{rCData.length} bytes of data."
-
-    if rCData != rBData[startOffset, len]
-      puts "\t\t*** Block and byte data don't match"
-    else
-      puts "\t\tData check passed"
-    end
-    puts
-  end
-
-rescue => err
-  puts err
-  puts err.class.to_s
-  puts err.backtrace.join("\n")
-ensure
-  vDisk.close if vDisk
-  vdlc.disconnect if vdlc
-end

data/lib/VMwareWebService/test/vimCoreUpdater.rb

@@ -1,25 +0,0 @@
-require 'manageiq-gems-pending'
-require 'VMwareWebService/MiqVimCoreUpdater'
-
-SERVER   = raise "please define SERVER"
-USERNAME = raise "please define USERNAME"
-PASSWORD = raise "please define PASSWORD"
-
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-vimEm = MiqVimCoreUpdater.new(SERVER, USERNAME, PASSWORD)
-
-Signal.trap("INT") { vimEm.stop }
-
-begin
-  thread = Thread.new do
-    vimEm.monitorUpdates do |mor, ph|
-      puts "Object: #{mor} (#{mor.vimType})"
-      ph.each { |k, v| puts "\t#{k}:\t#{v}" } unless ph.nil?
-    end
-  end
-  thread.join
-rescue => err
-  puts err.to_s
-end

data/lib/VMwareWebService/test/vimEventMonitory.rb

@@ -1,26 +0,0 @@
-require 'manageiq-gems-pending'
-require 'VMwareWebService/MiqVimEventMonitor'
-
-SERVER   = raise "please define SERVER"
-USERNAME = raise "please define USERNAME"
-PASSWORD = raise "please define PASSWORD"
-
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-vimEm = MiqVimEventMonitor.new(SERVER, USERNAME, PASSWORD)
-
-Signal.trap("INT") { vimEm.stop }
-
-puts "vimEm.class: #{vimEm.class}"
-puts "#{vimEm.server} is #{(vimEm.isVirtualCenter? ? 'VC' : 'ESX')}"
-puts "API version: #{vimEm.apiVersion}"
-
-begin
-  thread = Thread.new { vimEm.monitorEventsToStdout }
-  thread.join
-rescue => err
-  puts err.to_s
-end
-
-puts "done"

data/lib/VMwareWebService/test/vimInventory.rb

@@ -1,24 +0,0 @@
-require 'manageiq-gems-pending'
-require 'VMwareWebService/MiqVimInventory'
-
-SERVER   = raise "please define SERVER"
-USERNAME = raise "please define USERNAME"
-PASSWORD = raise "please define PASSWORD"
-
-$stderr.sync = true
-$vim_log = Logger.new(STDOUT)
-$vim_log.level = Logger::WARN
-
-# $miq_wiredump       = true
-vim = MiqVimInventory.new(SERVER, USERNAME, PASSWORD)
-
-puts
-puts "#{vim.server} is #{(vim.isVirtualCenter? ? 'VC' : 'ESX')}"
-puts "API version: #{vim.apiVersion}"
-puts
-
-puts "folders.length:              #{vim.folders.length}"
-puts "virtualMachines.length:      #{vim.virtualMachines.length}"
-puts "virtualMachinesByMor.length: #{vim.virtualMachinesByMor.length}"
-
-vim.disconnect