manageiq-smartstate 0.1.0

data/lib/MiqVm/MiqVm.rb

@@ -0,0 +1,355 @@
+require 'ostruct'
+require 'metadata/VmConfig/VmConfig'
+require 'disk/MiqDisk'
+require 'VolumeManager/MiqVolumeManager'
+require 'fs/MiqMountManager'
+require 'metadata/MIQExtract/MIQExtract'
+
+class MiqVm
+  attr_reader :vmConfig, :vmConfigFile, :vim, :vimVm, :rhevm, :rhevmVm, :diskInitErrors, :wholeDisks
+
+  def initialize(vmCfg, ost = nil)
+    @ost = ost || OpenStruct.new
+    $log.debug "MiqVm::initialize: @ost = nil" if $log && !@ost
+    @vmDisks = nil
+    @wholeDisks = []
+    @rootTrees = nil
+    @volumeManager = nil
+    @applianceVolumeManager = nil
+    @vmConfigFile = ""
+    @diskInitErrors = {}
+    unless vmCfg.kind_of?(Hash)
+      @vmConfigFile = vmCfg
+      @vmDir = File.dirname(vmCfg)
+    end
+
+    $log.debug "MiqVm::initialize: @ost.openParent = #{@ost.openParent}" if $log
+
+    #
+    # If we're passed an MiqVim object, then use VIM to obtain the Vm's
+    # configuration through the instantiated server.
+    # If we're passed a snapshot ID, then obtain the configration of the
+    # VM when the snapshot was taken.
+    #
+    # TODO: move to MiqVmwareVm
+    if (@vim = @ost.miqVim)
+      $log.debug "MiqVm::initialize: accessing VM through server: #{@vim.server}" if $log.debug?
+      @vimVm = @vim.getVimVm(vmCfg)
+      $log.debug "MiqVm::initialize: setting @ost.miqVimVm = #{@vimVm.class}" if $log.debug?
+      @ost.miqVimVm = @vimVm
+      @vmConfig = VmConfig.new(@vimVm.getCfg(@ost.snapId))
+    # TODO: move this to MiqRhevmVm.
+    elsif (@rhevm = @ost.miqRhevm)
+      $log.debug "MiqVm::initialize: accessing VM through RHEVM server" if $log.debug?
+      $log.debug "MiqVm::initialize: vmCfg = #{vmCfg}"
+      @rhevmVm = @rhevm.get_vm(vmCfg)
+      $log.debug "MiqVm::initialize: setting @ost.miqRhevmVm = #{@rhevmVm.class}" if $log.debug?
+      @ost.miqRhevmVm = @rhevmVm
+      @vmConfig = VmConfig.new(getCfg(@ost.snapId))
+      $log.debug "MiqVm::initialize: @vmConfig.getHash = #{@vmConfig.getHash.inspect}"
+      $log.debug "MiqVm::initialize: @vmConfig.getDiskFileHash = #{@vmConfig.getDiskFileHash.inspect}"
+    # TODO: move this to miq_scvmm_vm
+    elsif (@scvmm = @ost.miq_scvmm)
+      $log.debug "MiqVm::initialize: accessing VM through HyperV server" if $log.debug?
+      @vmConfig = VmConfig.new(getCfg(@ost.snapId))
+      $log.debug "MiqVm::initialize: setting @ost.miq_scvmm_vm = #{@scvmm_vm.class}" if $log.debug?
+    else
+      @vimVm = nil
+      @vmConfig = VmConfig.new(vmCfg)
+    end
+  end # def initialize
+
+  def vmDisks
+    @vmDisks ||= begin
+      @volMgrPS = VolMgrPlatformSupport.new(@vmConfig.configFile, @ost)
+      @volMgrPS.preMount
+
+      openDisks(@vmConfig.getDiskFileHash)
+    end
+  end
+
+  def openDisks(diskFiles)
+    pVolumes = []
+
+    $log.debug "openDisks: no disk files supplied." unless diskFiles
+
+    #
+    # Build a list of the VM's physical volumes.
+    #
+    diskFiles.each do |dtag, df|
+      $log.debug "openDisks: processing disk file (#{dtag}): #{df}"
+      dInfo = OpenStruct.new
+
+      if @ost.miqVim
+        dInfo.vixDiskInfo            = {}
+        dInfo.vixDiskInfo[:fileName] = @ost.miqVim.datastorePath(df)
+        if @ost.miqVimVm
+          @vdlConnection = @ost.miqVimVm.vdlVcConnection unless @vdlConnection
+        else
+          @vdlConnection = @ost.miqVim.vdlConnection unless @vdlConnection
+        end
+        $log.debug "openDisks: using disk file path: #{dInfo.vixDiskInfo[:fileName]}"
+        dInfo.vixDiskInfo[:connection]  = @vdlConnection
+      elsif @ost.miq_hyperv
+        init_disk_info(dInfo, df)
+      else
+        dInfo.fileName = df
+        disk_format = @vmConfig.getHash["#{dtag}.format"]  # Set by rhevm for iscsi and fcp disks
+        dInfo.format = disk_format unless disk_format.blank?
+      end
+
+      mode = @vmConfig.getHash["#{dtag}.mode"]
+
+      dInfo.hardwareId = dtag
+      dInfo.baseOnly = @ost.openParent unless mode && mode["independent"]
+      dInfo.rawDisk = @ost.rawDisk
+      $log.debug "MiqVm::openDisks: dInfo.baseOnly = #{dInfo.baseOnly}"
+
+      begin
+        d = applianceVolumeManager && applianceVolumeManager.lvHash[dInfo.fileName] if @rhevm
+        if d
+          $log.debug "MiqVm::openDisks: using applianceVolumeManager for #{dInfo.fileName}" if $log.debug?
+          d.dInfo.fileName = dInfo.fileName
+          d.dInfo.hardwareId = dInfo.hardwareId
+          d.dInfo.baseOnly = dInfo.baseOnly
+          d.dInfo.format = dInfo.format if dInfo.format
+          d.dInfo.applianceVolumeManager = applianceVolumeManager
+          #
+          # Here, we need to probe the disk to determine its data format,
+          # QCOW for example. If the disk format is not flat, push a disk
+          # supporting the format on top of this disk. Then set d to point
+          # to the new top disk.
+          #
+          d = d.pushFormatSupport
+        else
+          d = MiqDisk.getDisk(dInfo)
+          # I am not sure if getting a nil handle back should throw an error or not.
+          # For now I am just skipping to the next disk.  (GMM)
+          next if d.nil?
+        end
+      rescue => err
+        $log.error "Couldn't open disk file: #{df}"
+        $log.error err.to_s
+        $log.debug err.backtrace.join("\n")
+        @diskInitErrors[df] = err.to_s
+        next
+      end
+
+      @wholeDisks << d
+      p = d.getPartitions
+      if p.empty?
+        #
+        # If the disk has no partitions, the whole disk can be a single volume.
+        #
+        pVolumes << d
+      else
+        #
+        # If the disk is partitioned, the partitions are physical volumes,
+        # but not the whild disk.
+        #
+        pVolumes.concat(p)
+      end
+    end
+
+    pVolumes
+  end # def openDisks
+
+  def rootTrees
+    return @rootTrees if @rootTrees
+    @rootTrees = MiqMountManager.mountVolumes(volumeManager, @vmConfig, @ost)
+    volumeManager.rootTrees = @rootTrees
+    @rootTrees
+  end
+
+  def volumeManager
+    @volumeManager ||= MiqVolumeManager.new(vmDisks)
+  end
+
+  def applianceVolumeManager
+    return nil if @ost.nfs_storage_mounted
+    @applianceVolumeManager ||= MiqVolumeManager.fromNativePvs
+  end
+
+  def snapshots(refresh = false)
+    return nil unless @vimVm
+    return @vimVm.snapshotInfo(refresh) if @vimVm
+  end
+
+  def unmount
+    $log.info "MiqVm.unmount called."
+    @wholeDisks.each(&:close)
+    @wholeDisks.clear
+    if @volumeManager
+      @volumeManager.close
+      @volumeManager = nil
+    end
+    @applianceVolumeManager.closeAll if @applianceVolumeManager
+    @applianceVolumeManager = nil
+    @ost.miqVim.closeVdlConnection(@vdlConnection) if @vdlConnection
+    if @volMgrPS
+      @volMgrPS.postMount
+      @volMgrPS = nil
+    end
+    @vimVm.release if @vimVm
+    @rootTrees = nil
+    @vmDisks = nil
+  end
+
+  def miq_extract
+    @miq_extract ||= MIQExtract.new(self, @ost)
+  end
+
+  def extract(c)
+    xml = miq_extract.extract(c)
+    raise "Could not extract \"#{c}\" from VM" unless xml
+    (xml)
+  end
+end # class MiqVm
+
+if __FILE__ == $0
+  require 'log4r'
+  require 'metadata/util/win32/boot_info_win'
+
+  # vmDir = File.join(ENV.fetch("HOME", '.'), 'VMs')
+  vmDir = "/volumes/WDpassport/Virtual Machines"
+  puts "vmDir = #{vmDir}"
+
+  targetLv = "rpolv2"
+  rootLv = "LogVol00"
+
+  class ConsoleFormatter < Log4r::Formatter
+    def format(event)
+      (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+    end
+  end
+
+  toplog = Log4r::Logger.new 'toplog'
+  Log4r::StderrOutputter.new('err_console', :level => Log4r::DEBUG, :formatter => ConsoleFormatter)
+  toplog.add 'err_console'
+  $log = toplog if $log.nil?
+
+  #
+  # *** Test start
+  #
+
+  # vmCfg = File.join(vmDir, "cacheguard/cacheguard.vmx")
+  # vmCfg = File.join(vmDir, "Red Hat Linux.vmwarevm/Red Hat Linux.vmx")
+  # vmCfg = File.join(vmDir, "MIQ Server Appliance - Ubuntu MD - small/MIQ Server Appliance - Ubuntu.vmx")
+  # vmCfg = File.join(vmDir, "winxpDev.vmwarevm/winxpDev.vmx")
+  vmCfg = File.join(vmDir, "Win2K_persistent/Windows 2000 Professional.vmx")
+  # vmCfg = File.join(vmDir, "Win2K_non_persistent/Windows 2000 Professional.vmx")
+  puts "VM config file: #{vmCfg}"
+
+  ost = OpenStruct.new
+  ost.openParent = true
+
+  vm = MiqVm.new(vmCfg, ost)
+
+  puts "\n*** Disk Files:"
+  vm.vmConfig.getDiskFileHash.each do |k, v|
+    puts "\t#{k}\t#{v}"
+  end
+
+  puts "\n*** configHash:"
+  vm.vmConfig.getHash.each do |k, v|
+    puts "\t#{k} => #{v}"
+  end
+
+  tlv = nil
+  rlv = nil
+  puts "\n*** Visible Volumes:"
+  vm.volumeManager.visibleVolumes.each do |vv|
+    puts "\tDisk type: #{vv.diskType}"
+    puts "\tDisk sig: #{vv.diskSig}"
+    puts "\tStart LBA: #{vv.lbaStart}"
+    if vv.respond_to?(:logicalVolume)
+      puts "\t\tLV name: #{vv.logicalVolume.lvName}"
+      puts "\t\tLV UUID: #{vv.logicalVolume.lvId}"
+      tlv = vv if vv.logicalVolume.lvName == targetLv
+      rlv = vv if vv.logicalVolume.lvName == rootLv
+    end
+  end
+
+  # raise "#{targetLv} not found" if !tlv
+  #
+  # tlv.seek(0, IO::SEEK_SET)
+  # rs = tlv.read(2040)
+  # puts "\n***** START *****"
+  # puts rs
+  # puts "****** END ******"
+  #
+  # tlv.seek(2048*512*5119, IO::SEEK_SET)
+  # rs = tlv.read(2040)
+  # puts "\n***** START *****"
+  # puts rs
+  # puts "****** END ******"
+  #
+  # raise "#{rootLv} not found" if !rlv
+  #
+  # puts "\n*** Mounting #{rootLv}"
+  # rfs = MiqFS.getFS(rlv)
+  # puts "\tFS Type: #{rfs.fsType}"
+  # puts "\t*** Root-level files and directories:"
+  # rfs.dirForeach("/") { |de| puts "\t\t#{de}" }
+
+  puts "\n***** Detected Guest OSs:"
+  raise "No OSs detected" if vm.rootTrees.length == 0
+  vm.rootTrees.each do |rt|
+    puts "\t#{rt.guestOS}"
+    if rt.guestOS == "Linux"
+      puts "\n\t\t*** /etc/fstab contents:"
+      rt.fileOpen("/etc/fstab", &:read).each_line do |fstl|
+        next if fstl =~ /^#.*$/
+        puts "\t\t\t#{fstl}"
+      end
+    end
+  end
+
+  vm.rootTrees.each do |rt|
+    if rt.guestOS == "Linux"
+      # tdirArr = [ "/", "/boot", "/var/www/miq", "/var/www/miq/vmdb/log", "/var/lib/mysql" ]
+      tdirArr = ["/", "/boot", "/etc/init.d", "/etc/rc.d/init.d", "/etc/rc.d/rc0.d"]
+
+      tdirArr.each do |tdir|
+        begin
+          puts "\n*** Listing #{tdir} directory (1):"
+          rt.dirForeach(tdir) { |de| puts "\t\t#{de}" }
+          puts "*** end"
+
+          puts "\n*** Listing #{tdir} directory (2):"
+          rt.chdir(tdir)
+          rt.dirForeach { |de| puts "\t\t#{de}" }
+          puts "*** end"
+        rescue => err
+          puts "*** #{err}"
+        end
+      end
+
+      # lf = rt.fileOpen("/etc/rc0.d/S01halt")
+      # puts "\n*** Contents of /etc/rc0.d/S01halt:"
+      # puts lf.read
+      # puts "*** END"
+      # lf.close
+      #
+      # lfn = "/etc/rc0.d/S01halt"
+      # puts "Is #{lfn} a symbolic link? #{rt.fileSymLink?(lfn)}"
+      # puts "#{lfn} => #{rt.getLinkPath(lfn)}"
+    else  # Windows
+      tdirArr = ["c:/", "e:/", "e:/testE2", "f:/"]
+
+      tdirArr.each do |tdir|
+        puts "\n*** Listing #{tdir} directory (1):"
+        rt.dirForeach(tdir) { |de| puts "\t\t#{de}" }
+        puts "*** end"
+
+        puts "\n*** Listing #{tdir} directory (2):"
+        rt.chdir(tdir)
+        rt.dirForeach { |de| puts "\t\t#{de}" }
+        puts "*** end"
+      end
+    end
+  end
+
+  vm.unmount
+  puts "...done"
+end

data/lib/MiqVm/miq_azure_vm.rb

@@ -0,0 +1,96 @@
+require 'MiqVm/MiqVm'
+require 'disk/modules/AzureBlobDisk'
+require 'disk/modules/miq_disk_cache'
+
+class MiqAzureVm < MiqVm
+  def initialize(azure_handle, args)
+    @azure_handle = azure_handle
+    @uri          = nil
+
+    raise ArgumentError, "MiqAzureVm: missing required arg :name" unless (@name = args[:name])
+
+    if args[:image_uri]
+      @uri = args[:image_uri]
+    elsif args[:resource_group] && args[:name]
+      vm_obj = vm_svc.get(@name, args[:resource_group])
+      @uri = vm_obj.properties.storage_profile.os_disk.vhd.uri
+    else
+      raise ArgumentError, "MiqAzureVm: missing required args: :image_uri or :resource_group"
+    end
+
+    super(getCfg)
+  end
+
+  def getCfg
+    cfg_hash = {}
+    cfg_hash['displayname'] = @name
+
+    $log.debug "MiqAzureVm#getCfg: disk = #{@uri}"
+
+    tag = "scsi0:0"
+    cfg_hash["#{tag}.present"]    = "true"
+    cfg_hash["#{tag}.devicetype"] = "disk"
+    cfg_hash["#{tag}.filename"]   = @uri
+
+    cfg_hash
+  end
+
+  def openDisks(diskFiles)
+    p_volumes = []
+
+    $log.debug "openDisks: no disk files supplied." unless diskFiles
+
+    #
+    # Build a list of the VM's physical volumes.
+    #
+    diskFiles.each do |dtag, df|
+      $log.debug "openDisks: processing disk file (#{dtag}): #{df}"
+      dInfo = OpenStruct.new
+
+      dInfo.fileName   = df
+      dInfo.hardwareId = dtag
+      disk_format = @vmConfig.getHash["#{dtag}.format"]
+      dInfo.format = disk_format unless disk_format.blank?
+
+      mode = @vmConfig.getHash["#{dtag}.mode"]
+
+      dInfo.hardwareId = dtag
+      dInfo.rawDisk = true
+
+      begin
+        d = MiqDiskCache.new(AzureBlobDisk.new(sa_svc, @uri, dInfo), 100, 128)
+      rescue => err
+        $log.error "Couldn't open disk file: #{df}"
+        $log.error err.to_s
+        $log.debug err.backtrace.join("\n")
+        @diskInitErrors[df] = err.to_s
+        next
+      end
+
+      @wholeDisks << d
+      p = d.getPartitions
+      if p.empty?
+        #
+        # If the disk has no partitions, the whole disk can be a single volume.
+        #
+        p_volumes << d
+      else
+        #
+        # If the disk is partitioned, the partitions are physical volumes,
+        # but not the whild disk.
+        #
+        p_volumes.concat(p)
+      end
+    end
+
+    p_volumes
+  end # def openDisks
+
+  def vm_svc
+    @vm_svc ||= Azure::Armrest::VirtualMachineService.new(@azure_handle)
+  end
+
+  def sa_svc
+    @sa_svc ||= Azure::Armrest::StorageAccountService.new(@azure_handle)
+  end
+end

data/lib/MiqVm/miq_scvmm_vm.rb

@@ -0,0 +1,38 @@
+require 'MiqVm/MiqVm'
+require 'Scvmm/miq_scvmm_vm_ssa_info'
+
+class MiqScvmmVm < MiqVm
+  def getCfg(_snap = nil)
+    cfg_hash = {}
+    # Collect disk information
+    vhds = @scvmm.vm_all_harddisks(@ost.miq_vm)
+    raise "Unable to get Hard Disk Info from VM #{@ost.miq_vm}." unless vhds.any?
+    vhds.each do |vhd_attributes|
+      vhd      = vhd_attributes["Path"]
+      type     = vhd_attributes["ControllerType"].downcase
+      number   = vhd_attributes["ControllerNumber"]
+      index = vhd_attributes["ControllerLocation"]
+      tag = "#{type}#{number}:#{index}"
+      cfg_hash["#{tag}.present"]    = "true"
+      cfg_hash["#{tag}.devicetype"] = "disk"
+      cfg_hash["#{tag}.filename"]   = vhd
+    end
+    cfg_hash
+  end
+
+  private
+
+  def init_disk_info(disk_info, disk_file)
+    disk_info.hyperv_connection        = {}
+    disk_info.fileName                 = disk_file
+    disk_info.driveType                = @scvmm.get_drivetype(disk_file)
+    disk_info.hyperv_connection[:host] = @ost.miq_hyperv[:host]
+    disk_info.hyperv_connection[:port] = @ost.miq_hyperv[:port]
+    if @ost.miq_hyperv[:domain].nil?
+      disk_info.hyperv_connection[:user] = @ost.miq_hyperv[:user]
+    else
+      disk_info.hyperv_connection[:user] = @ost.miq_hyperv[:domain] + "\\" + @ost.miq_hyperv[:user]
+    end
+    disk_info.hyperv_connection[:password] = @ost.miq_hyperv[:password]
+  end
+end

data/lib/MiqVm/test/camcorder_fleece_test.rb

@@ -0,0 +1,60 @@
+require 'manageiq-gems-pending'
+require 'openssl' # Required for 'Digest' in camcorder (< Ruby 2.1)
+require 'camcorder'
+require 'log4r'
+require 'MiqVm/MiqVm'
+
+class ConsoleFormatter < Log4r::Formatter
+  def format(event)
+    (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+  end
+end
+
+toplog = Log4r::Logger.new 'toplog'
+Log4r::StderrOutputter.new('err_console', :level => Log4r::DEBUG, :formatter => ConsoleFormatter)
+toplog.add 'err_console'
+$log = toplog if $log.nil?
+
+#
+# Path to RAW disk image.
+#
+VIRTUAL_DISK_FILE = "path to raw disk image file"
+
+commit = true
+
+begin
+  recorder = Camcorder::Recorder.new("#{File.dirname(__FILE__)}/foo.yml")
+  Camcorder.default_recorder = recorder
+  Camcorder.intercept_constructor(MiqLargeFile::MiqLargeFileOther) do
+    methods_with_side_effects :seek, :read, :write
+  end
+  Camcorder.intercept_constructor(MiqLargeFile::MiqLargeFileStat)
+
+  recorder.start
+
+  hardware  = "scsi0:0.present = \"TRUE\"\n"
+  hardware += "scsi0:0.filename = \"#{VIRTUAL_DISK_FILE}\"\n"
+
+  ost = OpenStruct.new
+  ost.rawDisk = true
+
+  miqVm = MiqVm.new(hardware, ost)
+
+  %w(accounts services software system).each do |cat|
+    xml = miqVm.extract(cat)
+    xml.write($stdout, 4)
+  end
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+  commit = false # don't commit recording on error
+ensure
+  miqVm.unmount if miqVm
+  puts "...done"
+  if recorder && commit
+    puts
+    puts "camcorder: committing recording..."
+    recorder.commit
+    puts "done."
+  end
+end

data/lib/MiqVm/test/localVm.rb

@@ -0,0 +1,45 @@
+require 'manageiq-gems-pending'
+require 'ostruct'
+require 'log4r'
+require 'MiqVm/MiqVm'
+
+class ConsoleFormatter < Log4r::Formatter
+  def format(event)
+    (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+  end
+end
+
+$log = Log4r::Logger.new 'toplog'
+Log4r::StderrOutputter.new('err_console', :level => Log4r::DEBUG, :formatter => ConsoleFormatter)
+$log.add 'err_console'
+
+VHD = raise "Please define VHD"
+diskid    = "ide0:0"
+hardware  = "#{diskid}.present = \"TRUE\"\n"
+hardware += "#{diskid}.filename = \"#{VHD}\"\n"
+
+begin
+  ost = OpenStruct.new
+  ost.fileName = VHD
+  vm = MiqVm.new(hardware, ost)
+
+  vm.rootTrees.each do |fs|
+    puts "*** Found root tree for #{fs.guestOS}"
+    puts "Listing files in #{fs.pwd} directory:"
+    fs.dirEntries.each { |de| puts "\t#{de}" }
+    puts
+  end
+
+  CATEGORIES	= %w(accounts services software system)
+  CATEGORIES.each do |cat|
+    puts "Extracting: #{cat}:"
+    xml = vm.extract(cat)
+    xml.write($stdout, 4)
+    puts
+  end
+
+  vm.unmount
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/lib/MiqVm/test/partitionAlignmentCheck.rb

@@ -0,0 +1,76 @@
+require 'manageiq-gems-pending'
+require 'ostruct'
+require 'log4r'
+require 'MiqVm/MiqVm'
+require 'VmwareWebService/MiqVim'
+
+class ConsoleFormatter < Log4r::Formatter
+  def format(event)
+    (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+  end
+end
+
+toplog = Log4r::Logger.new 'toplog'
+Log4r::StderrOutputter.new('err_console', :level => Log4r::INFO, :formatter => ConsoleFormatter)
+toplog.add 'err_console'
+$vim_log = $log = toplog if $log.nil?
+
+SERVER        = raise "please define SERVER"
+USERNAME      = raise "please define USERNAME"
+PASSWORD      = raise "please define PASSWORD"
+vim = MiqVim.new(SERVER, USERNAME, PASSWORD)
+
+vimVm = nil
+vm    = nil
+
+alignment = 64 * 1024 # Check for alignment on a 64kB boundary
+
+begin
+
+  vim.virtualMachinesByMor.values.each do |vmo|
+    begin
+      vimVm = vim.getVimVmByMor(vmo['MOR'])
+
+      vmx = vimVm.dsPath
+      puts "VM: #{vimVm.name}, VMX = #{vmx}"
+
+      if vimVm.poweredOn?
+        puts "\tSkipping running VM"
+        puts
+        next
+      end
+
+      ost = OpenStruct.new
+      ost.miqVim = vim
+
+      #
+      # Given an MiqVm object, we check to see if its partitions are aligned on a given boundary.
+      # This boundary is usually based on the logical block size of the underlying storage array;
+      # in this example, 64kB.
+      #
+      vm = MiqVm.new(vmx, ost)
+
+      #
+      # We check all of physical volumes of the VM. This Includes visible and hidden volumes, but excludes logical volumes.
+      # The alignment of hidden volumes affects the performance of the logical volumes that are based on them.
+      #
+      vm.volumeManager.allPhysicalVolumes.each do |pv|
+        vmdk = pv.dInfo.filename || pv.dInfo.vixDiskInfo[:fileName]
+        aligned = pv.startByteAddr % alignment == 0 ? "Yes" : "No"
+        puts "\t#{vmdk}, Partition: #{pv.partNum}, Partition type: #{pv.partType}, LBA: #{pv.lbaStart}, offset: #{pv.startByteAddr}, aligned: #{aligned}"
+      end
+
+      puts
+    ensure
+      vimVm.release if vimVm
+      vm.unmount    if vm
+      vimVm = vm = nil
+    end
+  end
+
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  vim.disconnect  if vim
+end