manageiq-smartstate 0.1.0

data/lib/VolumeManager/MiqNativeVolumeManager.rb

@@ -0,0 +1,150 @@
+require "ostruct"
+require "disk/MiqDisk"
+require 'binary_struct'
+require 'VolumeManager/MiqLvm'
+
+class MiqNativeVolumeManager
+  attr_accessor :rootTrees
+  attr_reader :logicalVolumes, :physicalVolumes, :visibleVolumes, :hiddenVolumes, :allPhysicalVolumes, :vgHash, :wholeDisks, :diskInitErrors
+
+  def initialize(vmCfg, _ost = nil)
+    @logicalVolumes     = []         # visible logical volumes
+    @physicalVolumes    = []         # visible physical volumes
+    @hiddenVolumes      = []         # hidded volumes (in volume groups)
+    @allPhysicalVolumes = []         # all physical volumes
+    @wholeDisks         = []         # a list of open base disks
+    @visibleVolumes   = nil       # logical and physical volumes that should eb checked for filesystems
+    @vgHash             = {}          # volume groups hashed by name
+    @lvHash             = {}
+    @rootTrees          = nil               # the MiqMountManager objects using this MiqVolumeManager object
+
+    @diskFileNames = vmCfg.getDiskFileHash
+
+    `vgdisplay -c 2> /dev/null`.each { |vgl| vg = getVg(vgl); @vgHash[vg.vgName] = vg }
+    `lvdisplay -c 2> /dev/null`.each { |lvl| lv = getLv(lvl); @lvHash[lv.lvPath] = lv }
+
+    vgNames     = @vgHash.keys
+    lvNames     = @lvHash.keys
+    hiddenDevNames  = `pvdisplay -c 2> /dev/null`.split("\n").collect! { |p| p.lstrip.split(":", 2)[0] }
+
+    if $log.debug?
+      $log.debug "\nVolume Groups: (#{vgNames.class}: #{vgNames.length})"
+      vgNames.each { |dn| $log.debug "\t#{dn}" }
+      $log.debug "\nLogical Volumes: (#{lvNames.class}: #{lvNames.length})"
+      lvNames.each { |dn| $log.debug "\t#{dn}" }
+      $log.debug "\nHidden devs: (#{hiddenDevNames.class}: #{hiddenDevNames.length})"
+    end
+
+    physVolumes = openPhysicalVolumes(@diskFileNames)
+
+    $log.debug "\nMiqNativeVolumeManager: physVolumes:" if $log.debug?
+    physVolumes.each do |pv|
+      if $log.debug?
+        $log.debug "\t#{pv.devFile} => #{pv.dInfo.hardwareId} (SIG: #{pv.dInfo.diskSig})"
+        $log.debug "\t\tPartition: #{pv.partNum}, Type: #{pv.partType}"
+      end
+      if hiddenDevNames.include?(pv.devFile)
+        $log.debug "\t\t\tHIDDEN VOLUME" if $log.debug?
+        hiddenVolumes << pv
+      else
+        @physicalVolumes << pv
+      end
+      @allPhysicalVolumes << pv
+    end
+
+    vgNames.each { |vgn| `vgchange -a y #{vgn}` }
+
+    @logicalVolumes = openLogicalVolumes(lvNames)
+    @visibleVolumes = @logicalVolumes + @physicalVolumes
+  end
+
+  def closeAll
+    @wholeDisks.each(&:close)
+    @logicalVolumes     = []
+    @physicalVolumes    = []
+    @hiddenVolumes      = []
+    @wholeDisks         = []
+    @vgHash             = nil
+    @ost.miqVim.closeVdlConnection(@vdlConnection) if @vdlConnection
+    @volMgrPS.postMount
+  end
+
+  def openLogicalVolumes(lvnames)
+    lvList = []
+    lvnames.each do |lvn|
+      #
+      # get MiqDisk object for each LV and add to lvList.
+      #
+      dInfo = OpenStruct.new
+      dInfo.localDev = lvn
+      dInfo.lvObj = @lvHash[lvn]
+      dInfo.hardwareId = ""
+      lvList << MiqDisk.getDisk(dInfo)
+    end
+    lvList
+  end # def openLogicalVolumes
+
+  def openPhysicalVolumes(diskFiles)
+    pVolumes = []
+
+    $log.debug "openPhysicalVolumes: no disk files supplied." unless diskFiles
+
+    #
+    # Build a list of the VM's physical volumes.
+    #
+    diskFiles.each do |dtag, df|
+      $log.debug "openPhysicalVolumes: processing disk file (#{dtag}): #{df}"
+      dInfo = OpenStruct.new
+      dInfo.localDev = df
+      dInfo.hardwareId = dtag
+
+      begin
+        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?
+      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 openPhysicalVolumes
+
+  def getVg(vgl)
+    vga = vgl.lstrip.split(":")
+    (VolumeGroup.new(vga[16], vga[0]))
+  end
+
+  def getLv(lvl)
+    lva = lvl.lstrip.split(":")
+    lvPath = lva[0]
+    vgName = lva[1]
+    lvId   = `lvdisplay -v #{lvPath} 2> /dev/null | grep "LV UUID"`.split(" ").last
+    lv  = LogicalVolume.new(lvId, File.basename(lvPath))
+
+    vg = @vgHash[vgName]
+    lv.vgObj  = vg
+    lv.lvPath = lvPath
+    vg.logicalVolumes[lv.lvName] = lv
+  end
+end # class MiqNativeVolumeManager

data/lib/VolumeManager/MiqVolumeManager.rb

@@ -0,0 +1,277 @@
+require 'ostruct'
+require 'sys-uname'
+require 'binary_struct'
+require 'VolumeManager/MiqLvm'
+require 'VolumeManager/MiqLdm'
+require 'VolumeManager/VolMgrPlatformSupport'
+require 'disk/modules/RawDisk'
+
+class MiqVolumeManager
+  attr_accessor :rootTrees
+  attr_reader :logicalVolumes, :physicalVolumes, :visibleVolumes, :hiddenVolumes, :allPhysicalVolumes, :vgHash, :lvHash, :diskFileNames
+
+  def self.fromNativePvs
+    return nil unless Sys::Platform::IMPL == :linux
+
+    msg_pfx = "MiqVolumeManager.fromNativePvs"
+
+    bdevs = `pvdisplay -c | cut -d: -f1`.tr(" \t", "").split("\n")
+    ldevs = `lvdisplay -c | cut -d: -f1`.tr(" \t", "").split("\n")
+    bdevs -= ldevs
+    bda = []
+
+    bdevs.each do |bd|
+      next if bd == "unknowndevice"
+      $log.debug "#{msg_pfx}: Opening PV = #{bd}"
+
+      diskInfo = OpenStruct.new
+      diskInfo.rawDisk = true
+      diskInfo.fileName = bd
+
+      begin
+        disk = MiqDisk.new(RawDisk, diskInfo, 0)
+      rescue StandardError, NoMemoryError, SignalException => err
+        $log.warn "#{msg_pfx}: Could not open PV: #{bd}"
+        $log.warn err.to_s
+        $log.debug err.backtrace.join("\n")
+        next
+      end
+
+      raise "#{msg_pfx}: Failed to open disk: #{diskInfo.fileName}" unless disk
+      bda << disk
+
+      if $log.debug?
+        $log.debug "#{msg_pfx}: Block device: #{bd}"
+        $log.debug "#{msg_pfx}: \tDisk type: #{disk.diskType}"
+        $log.debug "#{msg_pfx}: \tDisk partition type: #{disk.partType}"
+        $log.debug "#{msg_pfx}: \tDisk block size: #{disk.blockSize}"
+        $log.debug "#{msg_pfx}: \tDisk start LBA: #{disk.lbaStart}"
+        $log.debug "#{msg_pfx}: \tDisk end LBA: #{disk.lbaEnd}"
+        $log.debug "#{msg_pfx}: \tDisk start byte: #{disk.startByteAddr}"
+        $log.debug "#{msg_pfx}: \tDisk end byte: #{disk.endByteAddr}"
+      end
+    end
+
+    new(bda)
+  end
+
+  def initialize(pVols)
+    @logicalVolumes     = []         # visible logical volumes
+    @physicalVolumes    = []         # visible physical volumes
+    @hiddenVolumes      = []         # hidded volumes (in volume groups)
+    @allPhysicalVolumes = []         # all physical volumes
+    @vgHash             = nil               # volume groups hashed by name
+    @rootTrees          = nil               # the MiqMountManager objects using this MiqVolumeManager object
+    @vdlConnection      = nil               # connection for remote vmdk access.
+
+    lvmPvHdrHash = {}                 # physical volume header list, for lvm
+    pVols.each do |pv|
+      pvh = LdmScanner.scan(pv) || Lvm2Scanner.labelScan(pv)
+      if pvh
+        pvh.diskObj = pv                # add reference to the pv's open disk object to the pv header
+        lvmPvHdrHash[pvh.pv_uuid] = pvh # this physical volume in an LVM volume group
+        @hiddenVolumes << pv            # so it's a hidden volume
+        $log.info "MiqVolumeManager: #{pvh.lvm_type} metadata detected on PV: #{pv.dInfo.fileName}, partition: #{pv.partNum}"
+      else
+        @physicalVolumes << pv          # this physical volume is not in an LVM volume group
+        $log.debug "MiqVolumeManager: No LVM metadata detected on PV: #{pv.dInfo.fileName}, partition: #{pv.partNum}"
+      end
+      @allPhysicalVolumes << pv
+    end
+
+    @vgHash = {}
+    parseLvmMetadata(lvmPvHdrHash)
+    parseLvmThinMetadata
+    @vgHash.each_value { |vg| @logicalVolumes.concat(vg.getLvs) }
+
+    @lvHash = {}
+    @logicalVolumes.each do |lvdObj|
+      lv    = lvdObj.dInfo.lvObj
+      lvName  = lv.lvName
+      vgName  = lv.vgObj.vgName
+
+      @lvHash["/dev/#{vgName}/#{lvName}"] = lvdObj
+    end
+
+    @visibleVolumes = @logicalVolumes + @physicalVolumes
+  end
+
+  def close
+    $log.info "MiqVolumeManager.close called"
+    @logicalVolumes     = @logicalVolumes.clear
+    @physicalVolumes    = @physicalVolumes.clear
+    @hiddenVolumes      = @hiddenVolumes.clear
+    @vgHash             = nil
+  end
+
+  #
+  # Physical volumes are opened by the client, so the client should be responsible
+  # for closing them. These methods are provided as a convienience when the volume
+  # manager is instantiated through fromNativePvs().
+  #
+  def closePvols
+    @allPhysicalVolumes.each(&:close)
+    @allPhysicalVolumes.clear
+  end
+
+  def closeAll
+    $log.info "MiqVolumeManager.closeAll called"
+    closePvols
+    close
+  end
+
+  def parseLvmMetadata(pvHdrs)
+    pvHdrs.each_value do |pvh|
+      if pvh.lvm_type == "LVM2"
+        $log.debug "MiqVolumeManager.parseLvmMetadata: parsing LVM2 metadata"
+        pvh.mdList.each do |md|
+          Lvm2MdParser.dumpMetadata(md) if $log.debug?
+          parser = Lvm2MdParser.new(md, pvHdrs)
+          next if @vgHash[parser.vgName]
+          @vgHash[parser.vgName] = parser.parse
+          # @vgHash[parser.vgName].dump
+        end
+      elsif pvh.lvm_type == "LDM"
+        $log.debug "MiqVolumeManager.parseLvmMetadata: parsing LDM metadata"
+        parser = LdmMdParser.new(pvh, pvHdrs)
+        next if @vgHash[parser.vgName]
+        @vgHash[parser.vgName] = parser.parse
+      else
+        $log.debug "MiqVolumeManager.parseLvmMetadata: unknown metadata type #{pvh.lvm_type}"
+        next
+      end
+    end
+  end
+
+  def parseLvmThinMetadata
+    @vgHash.each do |vgname, vg|
+      $log.debug "MiqVolumeManager.parseLvmThinMetadata: setting LVM2 thin metadata"
+
+      vg.thin_volumes.each do |tv|
+        tv.thin_segments.each do |seg|
+          seg.set_thin_pool_volume vg.logicalVolumes.values
+        end
+      end
+
+      vg.thin_pool_volumes.each do |tpv|
+        tpv.thin_pool_segments.each do |seg|
+          seg.set_metadata_volume vg.logicalVolumes.values
+          seg.set_data_volume     vg.logicalVolumes.values
+        end
+      end
+    end
+  end
+
+  def toXml(doc = nil)
+    doc = MiqXml.createDoc(nil) unless doc
+
+    vi = doc.add_element 'volumes'
+    pvToXml(vi, false)
+    pvToXml(vi, true)
+    lvToXml(vi)
+    vgToXml(vi)
+    doc
+  end
+
+  def pvToXml(doc = nil, hidden = false)
+    doc = MiqXml.createDoc(nil) unless doc
+
+    if hidden
+      vols = @hiddenVolumes
+      volType = 'hidden'
+    else
+      vols = @physicalVolumes
+      volType = 'physical'
+    end
+
+    pvs = doc.add_element volType
+    vols.each do |dobj|
+      pv = pvs.add_element('volume',               "controller"        => dobj.hwId,
+                                                   "disk_type"         => dobj.diskType,
+                                                   "location"          => dobj.partNum,
+                                                   "partition_type"    => dobj.partType,
+                                                   "size"              => dobj.size,
+                                                   "virtual_disk_file" => dobj.dInfo.fileName,
+                                                   "start_address"     => dobj.startByteAddr,)
+      if @rootTrees && @rootTrees.length > 0
+        pv.add_attribute("name", @rootTrees[0].osNames[dobj.hwId].to_s) if @rootTrees[0].osNames
+
+        fs = @rootTrees[0].fileSystems.find { |f| f.fs.dobj.hwId == dobj.hwId }
+        unless fs.nil?
+          pv.add_attributes("filesystem" => fs.fs.fsType,
+                            "free_space" => fs.fs.freeBytes,
+                            "used_space" => dobj.size - fs.fs.freeBytes)
+        end
+      end
+
+      if dobj.pvObj
+        pv.add_attributes("volume_group" => dobj.pvObj.vgObj.vgName,
+                          "uid"          => dobj.pvObj.pvId)
+      end
+    end
+    doc
+  end
+
+  def lvToXml(doc = nil)
+    doc = MiqXml.createDoc(nil) unless doc
+
+    lvs = doc.add_element 'logical'
+    @logicalVolumes.each do |dobj|
+      lvObj = dobj.dInfo.lvObj
+      name = lvObj.driveHint.blank? ? lvObj.lvName : lvObj.driveHint
+      lv = lvs.add_element('volume',               "name"         => name,
+                                                   "type"         => dobj.diskType,
+                                                   "size"         => dobj.size,
+                                                   "uid"          => lvObj.lvId,
+                                                   "volume_group" => lvObj.vgObj.vgName,
+                                                   "drive_hint"   => lvObj.driveHint,
+                                                   "volume_name"  => lvObj.lvName,)
+
+      if @rootTrees && @rootTrees.length > 0
+        fs = @rootTrees[0].fileSystems.find { |f| f.fs.dobj.dInfo.lvObj && f.fs.dobj.dInfo.lvObj.lvName == lvObj.lvName }
+        unless fs.nil?
+          lv.add_attributes("filesystem" => fs.fs.fsType,
+                            "free_space" => fs.fs.freeBytes,
+                            "used_space" => dobj.size - fs.fs.freeBytes)
+        end
+      end
+    end
+    doc
+  end
+
+  def vgToXml(doc = nil)
+    doc = MiqXml.createDoc(nil) unless doc
+
+    vgs = doc.add_element 'volume_groups'
+    @vgHash.each do |vgn, vgo|
+      pext = 0
+      lext = 0
+
+      vg = vgs.add_element('volume_group', {"name" => vgn})
+
+      pvs = vg.add_element 'physical'
+      vgo.physicalVolumes.each do |pvn, pvo|
+        pvs.add_element('volume', "name"              => pvn,
+                                  "uid"               => pvo.pvId,
+                                  "controller"        => pvo.diskObj.hwId,
+                                  "os_name"           => pvo.device,
+                                  "physical_extents"  => pvo.peCount,
+                                  "virtual_disk_file" => pvo.diskObj.dInfo.fileName)
+        pext += pvo.peCount
+      end
+
+      lvs = vg.add_element 'logical'
+      vgo.logicalVolumes.each do |lvn, lvo|
+        lvs.add_element('volume', "name" => lvn,
+                                  "uid"  => lvo.lvId)
+        lvo.segments.each { |s| lext += s.extentCount }
+      end
+
+      vg.add_attributes("extent_size"      => vgo.extentSize,
+                        "physical_extents" => pext,
+                        "logical_extents"  => lext,
+                        "free_extents"     => pext - lext)
+    end if @vgHash
+    doc
+  end
+end # class MiqVolumeManager

data/lib/VolumeManager/VolMgrPlatformSupport.rb

@@ -0,0 +1,18 @@
+require 'sys-uname'
+
+class VolMgrPlatformSupport
+  def initialize(cfgFile, ost)
+    $log.debug "Initializing VolMgrPlatformSupport" if $log
+    @cfgFile = cfgFile
+    @ost = ost
+
+    if Sys::Platform::OS == :windows
+      require "VolumeManager/VolMgrPlatformSupportWin"
+      extend VolMgrPlatformSupportWin
+    else
+      require "VolumeManager/VolMgrPlatformSupportLinux"
+      extend VolMgrPlatformSupportLinux
+    end
+    init
+  end # def initialize
+end # class VolMgrPlatformSupport

data/lib/VolumeManager/VolMgrPlatformSupportLinux.rb

@@ -0,0 +1,77 @@
+require 'util/miq-password'
+require 'VMwareWebService/MiqVim'
+
+module VolMgrPlatformSupportLinux
+  def init
+    $log.debug "VolMgrPlatformSupportLinux.init: #{@cfgFile}"
+    @ems = nil
+    @snMor = nil
+    @vi = nil
+    @vimVm = nil
+
+    unless @ost.force
+      $log.info "VolMgrPlatformSupportLinux.init: force flag = false"
+      return
+    end
+
+    if @ost.miqVimVm
+      $log.debug "VolMgrPlatformSupportLinux.init: Have miqVimVm"
+      @vimVm = @ost.miqVimVm
+      return
+    end
+
+    $log.debug "VolMgrPlatformSupportLinux.init: miqVimVm not set - should be a non VMware VM"
+  end
+
+  def preMount
+    $log.debug "VolMgrPlatformSupportLinux.preMount Enter: force = #{@ost.force}"
+    return unless @ost.force
+
+    if @snMor
+      $log.error "VolMgrPlatformSupportLinux.preMount - #{@cfgFile} is already mounted"
+      return
+    end
+
+    unless @vimVm
+      $log.warn "VolMgrPlatformSupportLinux.preMount: cannot snapshot VM not registered to this host: #{@cfgFile}"
+      return
+    end
+
+    desc = @ost.snapshotDescription ? @ost.snapshotDescription : "EVM Snapshot"
+    st = Time.now
+    @snMor = @vimVm.createEvmSnapshot(desc, "false", true, @ost.snapshot_create_free_space)
+    $log.info "VolMgrPlatformSupportLinux.preMount: VM snapshot created in [#{Time.now - st}] seconds"
+    $log.debug "VolMgrPlatformSupportLinux.preMount: snMor = \"#{@snMor}\""
+  end
+
+  def postMount
+    $log.debug "VolMgrPlatformSupportLinux.postMount Enter: force = #{@ost.force}, @vimVm.nil? = #{@vimVm.nil?}"
+    return unless @ost.force
+    return unless @vimVm
+
+    if @ost.force
+      if !@snMor
+        $log.warn "VolMgrPlatformSupportLinux.postMount: VM not snapped: #{@cfgFile}"
+      else
+        $log.debug "VolMgrPlatformSupportLinux.postMount: removing snapshot snMor = \"#{@snMor}\""
+        begin
+          @vimVm.removeSnapshot(@snMor, "false", true, @ost.snapshot_remove_free_space)
+        rescue => err
+          $log.warn "VolMgrPlatformSupportLinux.postMount: failed to remove snapshot for VM: #{@cfgFile}"
+          $log.warn "VolMgrPlatformSupportLinux.postMount: #{err}"
+        end
+      end
+    end
+
+    #
+    # If we opened the vimVm (it wasn't passed into us)
+    # then release it.
+    #
+    @vimVm.release unless @ost.miqVimVm
+    @vimVm = nil
+
+    @vi.disconnect if @vi
+    @vi = nil
+    @snMor = nil
+  end
+end # module VolMgrPlatformSupportLinux

data/lib/VolumeManager/VolMgrPlatformSupportWin.rb

@@ -0,0 +1,17 @@
+module VolMgrPlatformSupportWin
+  def init
+    true
+  end
+
+  def setDiskFlags(_dInfo)
+    true
+  end
+
+  def preMount
+    true
+  end
+
+  def postMount
+    true
+  end
+end # module VolMgrPlatformSupportWin

data/lib/VolumeManager/test/blockDevTest.rb

@@ -0,0 +1,40 @@
+require 'manageiq-gems-pending'
+require 'ostruct'
+require 'log4r'
+
+require 'disk/MiqDisk'
+require 'VolumeManager/MiqVolumeManager'
+
+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'
+$vim_log = $log = toplog if $log.nil?
+
+begin
+
+  volMgr = MiqVolumeManager.fromNativePvs
+
+  puts
+  puts "Volume Groups:"
+  volMgr.vgHash.each do |vgName, vgObj|
+    puts "\t#{vgName}: seq# = #{vgObj.seqNo}"
+  end
+
+  puts
+  puts "Logical Volumes:"
+  volMgr.lvHash.each do |key, lv|
+    puts "\t#{key}\t#{lv.dInfo.lvObj.lvName}"
+  end
+
+  volMgr.closeAll
+
+rescue  => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end

data/lib/VolumeManager/test/ldm.rb

@@ -0,0 +1,97 @@
+require 'manageiq-gems-pending'
+require 'log4r'
+require 'ostruct'
+require 'more_core_extensions/core_ext/object/blank'
+require 'metadata/VmConfig/VmConfig'
+require "VolumeManager/MiqVolumeManager"
+require "fs/MiqFS/MiqFS"
+require "MiqVm/MiqVm"
+require 'VMwareWebService/MiqVimBroker'
+
+SRC_VM = raise "please define"
+vmCfg = "/Volumes/WDpassport/Virtual Machines/MIQAppliance-win2008x86/Win2008x86.vmx"
+
+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'
+$log.level = Log4r::DEBUG
+Log4r::StderrOutputter.new('err_console', :formatter => ConsoleFormatter)
+$log.add 'err_console'
+
+vm = nil
+vim = nil
+
+begin
+  # Uncomment following 2 lines for clienr/server connection.
+  # broker = MiqVimBroker.new(:client)
+  # vim = broker.getMiqVim(SERVER, USERNAME, PASSWORD)
+  # miqVm = vim.getVimVmByFilter("config.name" => SRC_VM)
+  #
+  # vmCfg = miqVm.vmh['summary']['config']['vmPathName']
+  puts "vmCfg: #{vmCfg}"
+
+  $miqOut = $stdout
+  ost = OpenStruct.new
+  # ost.miqVim = vim
+  vm = MiqVm.new(vmCfg, ost)
+
+  # puts "**** Volume information:"
+  # xml = vm.volumeManager.toXml
+  # xml.write($stdout, 4)
+  # puts
+
+  rta = vm.rootTrees
+  raise "No root filesystems detected for: #{vmCfg}" if rta.empty?
+  rt = rta.first
+  puts "**** Filesystem information:"
+  rt.toXml
+  puts
+
+  # exit
+
+  puts "**** First-level files:"
+  puts "C:"
+  rt.dirForeach("C:/") { |f| puts "\t#{f}" }
+  # puts "F:"
+  # rt.dirForeach("F:/") { |f| puts "\t#{f}" }
+
+  puts
+  puts "******************* SOFTWARE:"
+  xml = vm.extract("software")
+  xml.write($stdout, 4)
+  puts
+
+  exit
+
+  vmConfig = VmConfig.new(vmCfg)
+  volMgr = MiqVolumeManager.new(vmConfig)
+
+  volMgr.visibleVolumes.each do |vv|
+    puts "Disk type: #{vv.diskType}"
+    puts "Disk partition type: #{vv.partType}"
+    puts "Disk block size: #{vv.blockSize}"
+    puts "Disk start LBA: #{vv.lbaStart}"
+    puts "Disk end LBA: #{vv.lbaEnd}"
+    puts "Disk start byte: #{vv.startByteAddr}"
+    puts "Disk end byte: #{vv.endByteAddr}"
+    if (lvObj = vv.dInfo.lvObj)
+      puts "Drive Hint: #{lvObj.driveHint}"
+    end
+
+    if (fs = MiqFS.getFS(vv))
+      puts "\tFS type: #{fs.fsType}"
+      fs.dirForeach { |f| puts "\t\t#{f}" }
+    else
+      puts "\tNo FS detected on volume"
+    end
+    puts
+  end
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+ensure
+  vm.unmount if vm
+end