manageiq-smartstate 0.1.0

data/lib/Scvmm/miq_hyperv_disk.rb

@@ -0,0 +1,273 @@
+# encoding: US-ASCII
+
+require 'util/miq_winrm'
+require 'Scvmm/miq_scvmm_parse_powershell'
+require 'base64'
+require 'securerandom'
+require 'memory_buffer'
+
+require 'rufus/lru'
+
+class MiqHyperVDisk
+  MIN_SECTORS_TO_CACHE = 64
+  DEF_BLOCK_CACHE_SIZE = 1200
+  DEBUG_CACHE_STATS    = false
+  BREAD_RETRIES        = 3
+  OPEN_ERRORS          = %w( Exception\ calling At\ line: ).freeze
+
+  attr_reader :hostname, :virtual_disk, :file_offset, :file_size, :parser, :vm_name, :temp_snapshot_name
+
+  def initialize(hyperv_host, user, pass, port = nil, network = false)
+    @hostname  = hyperv_host
+    @winrm     = MiqWinRM.new
+    port ||= 5985
+    @winrm.connect(:port => port, :user => user, :password => pass, :hostname => @hostname)
+    @parser       = MiqScvmmParsePowershell.new
+    @block_size   = 4096
+    @file_size    = 0
+    @block_cache  = LruHash.new(DEF_BLOCK_CACHE_SIZE)
+    @cache_hits   = Hash.new(0)
+    @cache_misses = Hash.new(0)
+    @network      = network
+    @total_read_execution_time = @total_copy_from_remote_time = 0
+  end
+
+  def open(vm_disk)
+    @virtual_disk  = vm_disk
+    @file_offset   = 0
+
+    unless @network
+      open_script = <<-OPEN_EOL
+$file_stream   = [System.IO.File]::Open("#{@virtual_disk}", "Open", "Read", "Read")
+$file_stream.seek(0, 0)
+OPEN_EOL
+      @winrm.run_powershell_script(open_script)
+    end
+
+    stat_script = <<-STAT_EOL
+(Get-Item "#{@virtual_disk}").length
+STAT_EOL
+    file_size, stderr = @parser.parse_single_powershell_value(run_correct_powershell(stat_script))
+
+    if @network && stderr.include?("RegisterTaskDefinition")
+      raise "Unable to obtain virtual disk size for #{vm_disk}. Check Hyper-V Host Domain Credentials"
+    end
+    OPEN_ERRORS.each { |error| raise "Unable to obtain virtual disk size for #{vm_disk}" if stderr.include?(error) }
+    @file_size           = file_size.to_i
+    @end_byte_addr       = @file_size - 1
+    @size_in_blocks, rem = @file_size.divmod(@block_size)
+    @size_in_blocks += 1 if rem > 0
+    @lba_end = @size_in_blocks - 1
+  end
+
+  def size
+    @file_size
+  end
+
+  def close
+    hit_or_miss if DEBUG_CACHE_STATS
+    @file_offset = 0
+    unless @network
+      close_script = <<-CLOSE_EOL
+$file_stream.Close()
+CLOSE_EOL
+      run_correct_powershell(close_script)
+    end
+    @winrm.close
+    @winrm = nil
+  end
+
+  def hit_or_miss
+    $log.debug "\nmiq_hyperv_disk cache hits:"
+    @cache_hits.keys.sort.each do |block|
+      $log.debug "block #{block} - #{@cache_hits[block]}"
+    end
+    $log.debug "\nmiq_hyperv_disk cache misses:"
+    @cache_misses.keys.sort.each do |block|
+      $log.debug "block #{block} - #{@cache_misses[block]}"
+    end
+    $log.debug "Total time spent copying reads from remote system is #{@total_copy_from_remote_time}"
+    $log.debug "Total time spent transferring and decoding reads on local system is #{@total_read_execution_time - @total_copy_from_remote_time}"
+    $log.debug "Total time spent processing remote reads is #{@total_read_execution_time}"
+  end
+
+  def seek(offset, whence = IO::SEEK_SET)
+    $log.debug "miq_hyperv_disk.seek(#{offset})"
+    case whence
+    when IO::SEEK_CUR
+      @file_offset += offset
+    when IO::SEEK_END
+      @file_offset = @end_byte_addr + offset
+    when IO::SEEK_SET
+      @file_offset = offset
+    end
+    @file_offset
+  end
+
+  def read(size)
+    $log.debug "miq_hyperv_disk.read(#{size})"
+    return nil if @file_offset >= @file_size
+    size = @file_size - @file_offset if (@file_offset + size) > @file_size
+
+    start_sector, start_offset = @file_offset.divmod(@block_size)
+    end_sector                 = (@file_offset + size - 1) / @block_size
+    number_sectors             = end_sector - start_sector + 1
+
+    @file_offset += size
+    bread_cached(start_sector, number_sectors)[start_offset, size]
+  end
+
+  def bread_cached(start_sector, number_sectors)
+    $log.debug "miq_hyperv_disk.bread_cached(#{start_sector}, #{number_sectors})"
+    @block_cache.keys.each do |block_range|
+      sector_offset = start_sector - block_range.first
+      buffer_offset = sector_offset * @block_size
+      if block_range.include?(start_sector) && block_range.include?(start_sector + number_sectors - 1)
+        length = number_sectors * @block_size
+        @cache_hits[start_sector] += 1
+        return @block_cache[block_range][buffer_offset, length]
+      elsif block_range.include?(start_sector)
+        # This range overlaps the start of our requested read, but more data is required at the end of the request
+        sectors_in_range = block_range.last - start_sector
+        length           = sectors_in_range * @block_size
+        remaining_blocks = number_sectors - sectors_in_range
+        @cache_hits[start_sector] += 1
+        # The "+" operator is required rather than "<<" so as not to modify the @block_cache object.
+        return @block_cache[block_range][buffer_offset, length] + bread_cached(block_range.last + 1, remaining_blocks)
+      elsif block_range.include?(start_sector + number_sectors - 1)
+        # This range overlaps the end of our requested read, but more data is required at the start of the request
+        sectors_in_range = (start_sector + number_sectors) - block_range.first
+        length           = sectors_in_range * @block_size
+        remaining_blocks = number_sectors - sectors_in_range
+        @cache_hits[start_sector] += 1
+        # The  "<<" operator is valid and more efficient here
+        return bread_cached(start_sector, remaining_blocks) << @block_cache[block_range][0, length]
+      elsif block_range.first > start_sector && block_range.last < start_sector + number_sectors
+        # This range overlaps our requested read but more data is required both before and after the range
+        sectors_in_range   = block_range.last - block_range.first + 1
+        sectors_pre_range  = block_range.first - start_sector
+        sectors_post_range = number_sectors - sectors_in_range - sectors_pre_range
+        # Note the mixed use of operators below.
+        # The first "<<" operator is valid and more efficient while the second "+" operator 
+        # is required instead so as not to modify the in-place @block_cache object.
+        return bread_cached(start_sector, sectors_pre_range) <<
+               @block_cache[block_range] +
+               bread_cached(block_range.last + 1, sectors_post_range)
+      end
+    end
+    block_range               = entry_range(start_sector, number_sectors)
+    @block_cache[block_range] = bread(block_range.first, block_range.last - block_range.first + 1)
+    @cache_misses[start_sector] += 1
+
+    sector_offset             = start_sector - block_range.first
+    buffer_offset             = sector_offset * @block_size
+    length                    = number_sectors * @block_size
+
+    @block_cache[block_range][buffer_offset, length]
+  end
+
+  def bread(start_sector, number_sectors)
+    log_header = "MIQ(#{self.class.name}.#{__method__}:"
+    $log.debug "#{log_header} (#{start_sector}, #{number_sectors})"
+    return nil if start_sector > @lba_end
+    number_sectors = @size_in_blocks - start_sector if (start_sector + number_sectors) > @size_in_blocks
+    expected_bytes = number_sectors * @block_size
+    read_script    = if @network
+
+                       <<-READ_NETWORK_EOL
+$file_stream   = [System.IO.File]::Open("#{@virtual_disk}", "Open", "Read", "Read")
+$bufsize       = #{number_sectors * @block_size}
+$buffer        = New-Object System.Byte[] $bufsize
+$encodedbuflen = $bufsize * 4 / 3
+if (($encodedbuflen % 4) -ne 0)
+{
+$encodedbuflen += 4 - ($encodedbuflen % 4)
+}
+$encodedarray = New-Object Char[] $encodedbuflen
+$file_stream.seek(#{start_sector * @block_size}, 0)
+$file_stream.read($buffer, 0, #{expected_bytes})
+[System.Convert]::ToBase64CharArray($buffer, 0, $bufsize, $encodedarray, 0)
+[string]::join("", $encodedarray)
+$file_stream.Close()
+READ_NETWORK_EOL
+                     else
+
+                       <<-READ_EOL
+if ($bufsize -ne #{number_sectors * @block_size})
+{
+  $bufsize       = #{number_sectors * @block_size}
+  $buffer        = New-Object System.Byte[] $bufsize
+  $encodedbuflen = $bufsize * 4 / 3
+  if (($encodedbuflen % 4) -ne 0)
+  {
+    $encodedbuflen += 4 - ($encodedbuflen % 4)
+  }
+  $encodedarray = New-Object Char[] $encodedbuflen
+}
+$file_stream.seek(#{start_sector * @block_size}, 0)
+$file_stream.read($buffer, 0, #{expected_bytes})
+[System.Convert]::ToBase64CharArray($buffer, 0, $bufsize, $encodedarray, 0)
+[string]::join("", $encodedarray)
+READ_EOL
+                     end
+
+    i = 0
+    (0...BREAD_RETRIES).each do
+      t1           = Time.now.getlocal
+      encoded_data = @parser.output_to_attribute(run_correct_powershell(read_script))
+      if encoded_data.empty?
+        $log.debug "#{log_header} no encoded data returned on attempt #{i}"
+        i += 1
+        continue
+      end
+      t2           = Time.now.getlocal
+      decoded_data = Base64.decode64(encoded_data)
+      @total_copy_from_remote_time += t2 - t1
+      @total_read_execution_time += Time.now.getlocal - t1
+      decoded_size = decoded_data.size
+      return decoded_data if expected_bytes == decoded_size
+      $log.debug "#{log_header} expected #{expected_bytes} bytes - got #{decoded_size} on attempt #{i}"
+      i += 1
+    end
+    raise "#{log_header} expected #{expected_bytes} bytes - got #{decoded_size}"
+  end
+
+  def snap(vm_name)
+    @vm_name = vm_name
+    @temp_snapshot_name = vm_name + SecureRandom.hex
+    snap_script = <<-SNAP_EOL
+Checkpoint-VM -Name #{@vm_name} -SnapshotName #{@temp_snapshot_name}
+SNAP_EOL
+    @vm_name = vm_name
+    @temp_snapshot_name = vm_name + SecureRandom.hex
+    @winrm.run_powershell_script(snap_script)
+  end
+
+  def delete_snap
+    delete_snap_script = <<-DELETE_SNAP_EOL
+Remove-VMSnapShot -VMName #{@vm_name} -Name #{@temp_snapshot_name}
+DELETE_SNAP_EOL
+    @winrm.run_powershell_script(delete_snap_script)
+  end
+
+  private
+
+  def run_correct_powershell(script)
+    return @winrm.run_elevated_powershell_script(script) if @network
+    @winrm.run_powershell_script(script)
+  end
+
+  def entry_range(start_sector, number_sectors)
+    # Cache entries are *multiples* of MIN_SECTORS_TO_CACHE * @blocksize  in length,
+    # aligned to MIN_SECTORS_TO_CACHE * @blocksize byte boundaries.
+    # real_start_block is the aligned cache block based on the start_sector, and
+    # real_start_sector is the disk sector for that cache block.
+    real_start_block    = start_sector / MIN_SECTORS_TO_CACHE
+    real_end_block      = (start_sector + number_sectors) / MIN_SECTORS_TO_CACHE
+    number_cache_blocks = real_end_block - real_start_block + 1
+    sectors_to_read     = number_cache_blocks * MIN_SECTORS_TO_CACHE
+    real_start_sector   = real_start_block * MIN_SECTORS_TO_CACHE
+    end_sector          = real_start_sector + sectors_to_read - 1
+    Range.new(real_start_sector, end_sector)
+  end
+end

data/lib/Scvmm/miq_scvmm_parse_powershell.rb

@@ -0,0 +1,75 @@
+class MiqScvmmParsePowershell
+  def output_to_attribute(winrm_output)
+    attribute, stderr = stdout_stderr(winrm_output)
+    if stderr =~ /Exception/ || stderr =~ /At line:/
+      raise "Error running PowerShell command.\n #{stderr}"
+    end
+    $log.debug "MiqScvmmParsePowershell: STDERR is \"#{stderr}\"" unless stderr.nil? || $log.nil?
+    attribute.split("\r\n").last
+  end
+
+  #
+  # This method handles one or more lines of exactly one attribute.
+  #
+  def parse_single_attribute_values(output)
+    parse_attribute_values(output)
+  end
+
+  def parse_multiple_attribute_values(output)
+    parse_attribute_values(output, true)
+  end
+
+  #
+  # This method handles one or more lines of one or more attributes.
+  #
+  def parse_attribute_values(output, multiple = nil)
+    stdout, stderr  = parse_powershell_value(output)
+    lines           = stdout.split("\r\n")
+    dashes          = nil
+    attributes      = []
+    attribute_names = []
+    lines.each do |line|
+      next if line.nil? || line == ""
+      if line =~ /^-+/
+        dashes = true
+        next
+      end
+      if dashes.nil?
+        attribute_names = line.split(" ")
+        next
+      end
+      line_parts = multiple.nil? ? [line.rstrip] : line.split(" ")
+      raise "Incorrect number of PowerShell Output Attributes Found" if line_parts.size != attribute_names.size
+      i = 0
+      line_hash = {}
+      attribute_names.each do |attribute|
+        line_hash[attribute] = line_parts[i]
+        i += 1
+      end
+      attributes << line_hash
+    end
+    return attributes, stderr
+  end
+
+  def parse_single_powershell_value(output)
+    stdout, stderr = parse_powershell_value(output)
+    return stdout.split("\r\n").first, stderr
+  end
+
+  def parse_powershell_value(output)
+    stdout, stderr = stdout_stderr(output)
+    $log.debug "MiqScvmmParsePowershell: STDOUT is \"#{stdout}\"" unless stdout.nil? || $log.nil?
+    $log.debug "MiqScvmmParsePowershell: STDERR is \"#{stderr}\"" unless stderr.nil? || $log.nil?
+    return stdout, stderr
+  end
+
+  private
+
+  def stdout_stderr(output)
+    stdout = ""
+    stderr = ""
+    stdout << output.stdout unless output.stdout.nil?
+    stderr << output.stderr unless output.stderr.nil?
+    return stdout, stderr
+  end
+end

data/lib/Scvmm/miq_scvmm_vm_ssa_info.rb

@@ -0,0 +1,135 @@
+# encoding: US-ASCII
+
+require 'util/miq_winrm'
+require 'Scvmm/miq_scvmm_parse_powershell'
+
+class MiqScvmmVmSSAInfo
+  attr_reader :vhds, :hostname, :checkpoints, :vhd_type
+  def initialize(provider, user, pass, port = nil)
+    @checkpoints = []
+    @vhds        = []
+    @hostname    = nil
+    @vhd_type    = nil
+    @winrm       = MiqWinRM.new
+    winrmport    = port.nil? ? 5985 : port
+    options      = {:port => winrmport, :user => user, :password => pass, :hostname => provider}
+    @elevated    = nil
+
+    @winrm.connect(options)
+    @parser = MiqScvmmParsePowershell.new
+  end
+
+  def close
+    @winrm.close
+  end
+
+  # Note the following method returns *all* hard disks and some common attributes from the Hyper-V host
+  def vm_all_harddisks(vm_name, snapshot = nil, check_snapshot = TRUE)
+    vhds       = vm_get_disks(vm_name, snapshot, check_snapshot)
+    properties = vm_get_properties(vm_name)
+    raise "Error getting VHD(s) and Attributes for #{vm_name}" if vhds.size != properties.size
+    raise "No Virtual Hard Disk found for VM #{vm_name}" unless vhds.any?
+
+    i = 0
+    new_vhds = []
+    $log.debug "vm_all_harddisks: #{vhds.size} vhds found:\n"
+    vhds.each do |vhd|
+      vhd.merge!(properties[i])
+      new_vhds << vhd
+      i += 1
+    end
+    new_vhds
+  end
+
+  def vm_get_checkpoint(vm_name, snapshot)
+    get_checkpoint_script = <<-GETCHECKPOINT_EOL
+Get-VMSnapShot -ComputerName localhost -VMName "#{vm_name}" -Name "#{snapshot}"| \
+  Select-Object -ExpandProperty Name
+GETCHECKPOINT_EOL
+
+    checkpoint, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(get_checkpoint_script))
+    if stderr =~ /Unable to find a snapshot/
+      return nil
+    else
+      raise "Error finding Snapshot for #{vm_name}: #{stderr}" unless stderr.empty?
+    end
+    checkpoint
+  end
+
+  def vm_create_evm_checkpoint(vm_name, snapshot = nil)
+    snapshot = vm_name + "__EVM_SNAPSHOT" if snapshot.nil?
+    raise "Checkpoint for VM #{vm_name} Already Exists" unless vm_get_checkpoint(vm_name, snapshot).nil?
+
+    checkpoint_script = <<-CHECKPOINT_EOL
+Checkpoint-VM -ComputerName localhost -Name "#{vm_name}" -SnapshotName "#{snapshot}"
+CHECKPOINT_EOL
+
+    _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(checkpoint_script))
+    unless stderr.empty?
+      @elevated = true
+      _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_elevated_powershell_script(checkpoint_script))
+    end
+    raise "Unable to create Snapshot for #{vm_name}: #{stderr}" unless stderr.empty?
+    snapshot
+  end
+
+  def vm_remove_evm_checkpoint(vm_name, snapshot = nil)
+    snapshot = vm_name + "__EVM_SNAPSHOT" if snapshot.nil?
+    rm_checkpt_script = <<-RM_CHECKPOINT_EOL
+Remove-VMSnapshot -ComputerName localhost -VMName "#{vm_name}" -Name "#{snapshot}"
+RM_CHECKPOINT_EOL
+
+    if @elevated
+      _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_elevated_powershell_script(rm_checkpt_script))
+    else
+      _stdout, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(rm_checkpt_script))
+    end
+    raise "Unable to remove Snapshot for #{vm_name}: #{stderr}" unless stderr.empty?
+  end
+
+  def get_drivetype(vhd_path)
+    return "Network" if vhd_path[0, 2] == '\\\\'
+    raise "Invalid Drive Letter for Hard Drive #{vhd_path}" unless vhd_path[1, 1] == ":"
+    drive_letter = vhd_path[0, 1]
+
+    drivetype_script = <<-DRIVETYPE_EOL
+([System.IO.DriveInfo]("#{drive_letter}")).DriveType
+DRIVETYPE_EOL
+    drive_type, stderr = @parser.parse_single_powershell_value(@winrm.run_powershell_script(drivetype_script))
+    raise "Unable to get drive letter for disk #{vhd_path}: #{stderr}" unless stderr.empty? || drive_type.nil?
+    drive_type
+  end
+
+  private
+
+  def vm_get_properties(vm_name)
+    properties_script = <<-PROPERTIES_EOL
+Get-VMHardDiskDrive -VMName "#{vm_name}" | \
+  Format-Table -Property ControllerType,ControllerNumber,ControllerLocation -Autosize
+PROPERTIES_EOL
+
+    properties, stderr = @parser.parse_multiple_attribute_values(@winrm.run_powershell_script(properties_script))
+    raise "Error getting VHD(s) and Attributes for #{vm_name}: #{stderr}" unless stderr.empty?
+    properties
+  end
+
+  def vm_get_disks(vm_name, snapshot, check_snapshot)
+    if check_snapshot.nil?
+      vhd_script = <<-VHD_EOL
+Get-VMHardDiskDrive -VMName "#{vm_name}" | \
+  Format-Table -Property Path | out-string -Width 200
+VHD_EOL
+    else
+      snapshot = vm_name + "__EVM_SNAPSHOT" if snapshot.nil?
+      raise "Checkpoint #{snapshot} for VM #{vm_name} missing" if vm_get_checkpoint(vm_name, snapshot).nil?
+      vhd_script = <<-SNAP_EOL
+Get-VMSnapShot -VMName "#{vm_name}" -Name "#{snapshot}" |  Get-VMHardDiskDrive | \
+  Format-Table -Property Path | out-string -Width 200
+SNAP_EOL
+    end
+
+    vhds, stderr = @parser.parse_single_attribute_values(@winrm.run_powershell_script(vhd_script))
+    raise "Unable to obtain VHD Name(s) for #{vm_name}: #{stderr}" unless stderr.empty?
+    vhds
+  end
+end

data/lib/Scvmm/test/miq_hyperv_disk_test.rb

@@ -0,0 +1,33 @@
+require 'manageiq-gems-pending'
+require 'rubygems'
+require 'log4r'
+require 'Scvmm/miq_hyperv_disk'
+
+#
+# Formatter to output log messages to the console.
+#
+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'
+
+HOST = raise "Please define SERVERNAME"
+PORT = raise "Please define PORT"
+USER = raise "Please define USER"
+PASS = raise "Please define PASS"
+DISK = raise "Please define DISK"
+
+hyperv_disk = MiqHyperVDisk.new(HOST, USER, PASS, PORT)
+
+$log.debug "Reading 256 byte slices"
+hyperv_disk.open(DISK)
+hyperv_disk.seek(0)
+(1..8).each do |i|
+  buffer = hyperv_disk.read(256)
+  $log.debug "Buffer #{i}: \n#{buffer}\n"
+end

data/lib/Scvmm/test/miq_scvmm_vm_ssa_info_test.rb

@@ -0,0 +1,41 @@
+require 'manageiq-gems-pending'
+require 'rubygems'
+require 'log4r'
+require 'Scvmm/miq_scvmm_vm_ssa_info'
+
+#
+# Formatter to output log messages to the console.
+#
+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'
+
+HOST = raise "Please define SERVERNAME"
+PORT = raise "Please define PORT"
+USER = raise "Please define USER"
+PASS = raise "Please define PASS"
+VM   = raise "Please define VM"
+
+vm_info_handle = MiqScvmmVmSSAInfo.new(HOST, USER, PASS, PORT)
+$log.debug "Getting Hyper-V Host for VM #{VM}"
+hyperv_host = vm_info_handle.vm_host(VM)
+$log.debug "Hyper-V Host is #{hyperv_host}"
+$log.debug "Getting VHD Type for VM #{VM}"
+vhd_type = vm_info_handle.vm_vhdtype(VM)
+$log.debug "VHD Type is #{vhd_type}"
+vhd = vm_info_handle.vm_harddisks(VM)
+$log.debug "VHD is #{vhd}"
+vm_info_handle.vm_create_checkpoint(VM)
+checkpoint = vm_info_handle.vm_get_checkpoint(VM)
+$log.debug "Checkpoint for #{vhd} is #{checkpoint}"
+vm_info_handle.vm_remove_checkpoint(VM)
+vm_info_handle.vm_create_checkpoint(VM)
+checkpoint = vm_info_handle.vm_get_checkpoint(VM)
+$log.debug "Checkpoint for #{vhd} is #{checkpoint}"
+vm_info_handle.vm_remove_checkpoint(VM)

data/lib/VmLocalDiskAccess/test/localCfg.rb

@@ -0,0 +1,97 @@
+require 'log4r'
+require 'util/miq-xml'
+require 'util/runcmd'
+require 'metadata/VmConfig/VmConfig'
+require 'VolumeManager/MiqNativeVolumeManager'
+require 'fs/MiqMountManager'
+
+module MiqNativeMountManager
+  LSHW = "lshw"
+
+  def self.mountVolumes
+    lshwXml = MiqUtil.runcmd("#{LSHW} -xml")
+    nodeHash = Hash.new { |h, k| h[k] = [] }
+    doc = MiqXml.load(lshwXml)
+    doc.find_match("//node").each { |n| nodeHash[n.attributes["id"].split(':', 2)[0]] << n }
+
+    hardware = ""
+
+    nodeHash["disk"].each do |d|
+      diskid = d.find_first('businfo').get_text.to_s
+      next unless diskid
+      sn = d.find_first('size')
+      # If there's no size node, assume it's a removable drive.
+      next unless sn
+      busType, busAddr = diskid.split('@', 2)
+      if busType == "scsi"
+        f1, f2 = busAddr.split(':', 2)
+        f2 = f2.split('.')[1]
+        busAddr = "#{f1}:#{f2}"
+      else
+        busAddr['.'] = ':'
+      end
+      diskid = busType + busAddr
+      filename = d.find_first('logicalname').get_text.to_s
+      hardware += "#{diskid}.present = \"TRUE\"\n"
+      hardware += "#{diskid}.filename = \"#{filename}\"\n"
+    end
+
+    cfg = VmConfig.new(hardware)
+    volMgr = MiqNativeVolumeManager.new(cfg)
+
+    (MiqMountManager.mountVolumes(volMgr, cfg))
+  end
+end # module MiqNativeMountManager
+
+if __FILE__ == $0
+  #
+  # Formatter to output log messages to the console.
+  #
+  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'
+
+  puts "Log debug?: #{$log.debug?}"
+
+  rootTrees = MiqNativeMountManager.mountVolumes
+
+  if rootTrees.nil? || rootTrees.empty?
+    puts "No root filesystems detected"
+    exit
+  end
+
+  $miqOut = $stdout
+  rootTrees.each do |r|
+    r.toXml(nil)
+  end
+
+  rootTree = rootTrees[0]
+
+  if rootTree.guestOS == "Linux"
+    puts
+    puts "Files in /:"
+    rootTree.dirForeach("/") { |f| puts "\t#{f}" }
+
+    puts
+    puts "All files in /test_mount:"
+    rootTree.findEach("/test_mount") { |f| puts "\t#{f}" }
+  elsif rootTree.guestOS == "Windows"
+    puts
+    puts "Files in C:/"
+    rootTree.dirForeach("C:/") { |f| puts "\t#{f}" }
+
+    ["E:/", "F:/"].each do |drive|
+      puts
+      puts "All files in #{drive}"
+      rootTree.findEach(drive) { |f| puts "\t#{f}" }
+    end
+  else
+    puts "Unknown guest OS: #{rootTree.guestOS}"
+  end
+end