manageiq-smartstate 0.1.0

data/lib/disk/modules/AzureBlobDisk.rb

@@ -0,0 +1,101 @@
+require_relative "../MiqDisk"
+require 'ostruct'
+
+module AzureBlobDisk
+  # The maximum read length that supports MD5 return.
+  MAX_READ_LEN = 1024 * 1024 * 4
+
+  def self.new(svc, blob_uri, dInfo = nil)
+    d_info = dInfo || OpenStruct.new
+    d_info.storage_acct_svc = svc
+    d_info.blob_uri         = blob_uri
+    d_info.fileName         = blob_uri
+
+    MiqDisk.new(self, d_info, 0)
+  end
+
+  def d_init
+    @diskType         = "azure-blob"
+    @blockSize        = 512
+    @blob_uri         = @dInfo.blob_uri
+    @storage_acct_svc = @dInfo.storage_acct_svc
+
+    uri_info   = @storage_acct_svc.parse_uri(@blob_uri)
+    @container = uri_info[:container]
+    @blob      = uri_info[:blob]
+    @acct_name = uri_info[:account_name]
+    @snapshot  = uri_info[:snapshot]
+
+    @storage_acct = @storage_acct_svc.accounts_by_name[@acct_name]
+    raise "AzureBlob: Storage account #{@acct_name} not found." unless @storage_acct
+
+    $log.debug "AzureBlobDisk: open(#{@blob_uri})"
+    @t0 = Time.now.to_i
+    @reads = 0
+    @bytes = 0
+    @split_reads = 0
+  end
+
+  def d_close
+    return nil unless $log.debug?
+    t1 = Time.now.to_i
+    $log.debug "AzureBlobDisk: close(#{@blob_uri})"
+    $log.debug "AzureBlobDisk: (#{@blob_uri}) time:  #{t1 - @t0}"
+    $log.debug "AzureBlobDisk: (#{@blob_uri}) reads: #{@reads}, split_reads: #{@split_reads}"
+    $log.debug "AzureBlobDisk: (#{@blob_uri}) bytes: #{@bytes}"
+    nil
+  end
+
+  def d_read(pos, len)
+    $log.debug "AzureBlobDisk#d_read(#{pos}, #{len})"
+    return blob_read(pos, len) unless len > MAX_READ_LEN
+
+    @split_reads += 1
+    ret = ""
+    blocks, rem = len.divmod(MAX_READ_LEN)
+
+    blocks.times do
+      ret << blob_read(pos, MAX_READ_LEN)
+    end
+    ret << blob_read(pos, rem) if rem > 0
+
+    ret
+  end
+
+  def d_size
+    @d_size ||= blob_properties[:content_length].to_i
+  end
+
+  def d_write(_pos, _buf, _len)
+    raise "Write operation not supported."
+  end
+
+  private
+
+  def blob_read(start_byte, length)
+    $log.debug "AzureBlobDisk#blob_read(#{start_byte}, #{length})"
+    options = {
+      :start_byte => start_byte,
+      :length     => length
+    }
+    options[:date] = @snapshot if @snapshot
+
+    ret = @storage_acct.get_blob_raw(@container, @blob, key, options)
+
+    @reads += 1
+    @bytes += ret.body.length
+
+    ret.body
+  end
+
+  def blob_properties
+    @blob_properties ||= begin
+      options = @snapshot ? {:date => @snapshot} : {}
+      @storage_acct.blob_properties(@container, @blob, key, options)
+    end
+  end
+
+  def key
+    @key ||= @storage_acct_svc.list_account_keys(@storage_acct.name, @storage_acct.resource_group).fetch('key1')
+  end
+end

data/lib/disk/modules/LocalDevMod.rb

@@ -0,0 +1,47 @@
+require 'disk/modules/MiqLargeFile'
+
+module LocalDevMod
+  attr_reader :devFile
+  attr_accessor :mkfile
+
+  def d_init
+    self.diskType = "LocalDev"
+    self.blockSize  = 512
+    @mkfile     = nil
+    dev       = dInfo.localDev || dInfo.fileName
+    @devFile    = dev
+    @devFile += @partNum.to_s if @partNum != 0
+
+    #
+    # Set fileName after the disk probe has determined that this is a local device.
+    # fileName can then be used as a common reference for debugging, etc.
+    #
+    dInfo.fileName   = dev
+    dInfo.mountMode  = "r"
+
+    @rawDisk_file     = MiqLargeFile.open(dev, "r")
+  end
+
+  def getBase
+    self
+  end
+
+  def d_read(pos, len, offset       = 0)
+    pos += @dInfo.offset if @dInfo.offset
+    @rawDisk_file.seek(pos - offset, IO::SEEK_SET)
+    @rawDisk_file.read(len)
+  end
+
+  def d_write(_pos, _buf, _len, _offset = 0)
+    raise "LocalDevMod: write not supported"
+  end
+
+  def d_close
+    @rawDisk_file.close
+  end
+
+  # Disk size in sectors.
+  def d_size
+    @rawDisk_file.size / @blockSize
+  end
+end

data/lib/disk/modules/LocalDevProbe.rb

@@ -0,0 +1,6 @@
+module LocalDevProbe
+  def self.probe(ostruct)
+    return("LocalDevMod") if ostruct.localDev || File.blockdev?(ostruct.fileName)
+    (nil)
+  end
+end

data/lib/disk/modules/MSCommon.rb

@@ -0,0 +1,352 @@
+require 'disk/modules/MiqLargeFile'
+require 'util/miq-unicode'
+require 'binary_struct'
+require 'memory_buffer'
+require 'Scvmm/miq_hyperv_disk'
+
+module MSCommon
+  # NOTE: All values are stored in network byte order.
+
+  FOOTER = BinaryStruct.new([
+    'a8',   'cookie',           # Always 'conectix'.
+    'N',    'features',         # Should be 2 or 3 (bit 0 is temp disk).
+    'N',    'version',          # Major/Minor file format version.
+    'N',    'data_offset_hi',   # Offset from beginning of file to next data struct (dyn & diff only, 0xffffffff for fixed).
+    'N',    'data_offset_lo',
+    'N',    'time_stamp',       # Create time (sec since Jan 1 2000 12:00 AM in GMT).
+    'a4',   'creator_app',      # Virtual PC = 'vpc ', Virtual Server = 'vs  '.
+    'N',    'creator_ver',      # Major/Minor ver of creator app.
+    'N',    'creator_host',     # Creator host: Windows = 0x5769326b ('Wi2k'); Macintosh = 0x4d616320 ('Mac ').
+    'N',    'original_size_hi', # Original size of disk.
+    'N',    'original_size_lo',
+    'N',    'current_size_hi',  # Current size of the disk.
+    'N',    'current_size_lo',
+    'N',    'disk_geometry',    # CHS (byte sizes 2, 1, 1) values for disk.
+    'N',    'disk_type',        # Disk subtype (Fixed, Dynamic or Differencing).
+    'N',    'checksum',         # One's compliment of sum of struct minus this field.
+    'a16',  'unique_id',        # UUID.
+    'C',    'saved_state',      # If 1, system is in 'saved state'.
+  ])
+
+  HEADER = BinaryStruct.new([
+    'a8',   'cookie',           # Always 'cxsparse'.
+    'Q',    'data_offset',      # Unused, should be 0xffffffff.
+    'N',    'table_offset_hi',  # Byte offset to the Block Allocation Table.
+    'N',    'table_offset_lo',
+    'N',    'header_ver',       # Major/Minor header version.
+    'N',    'max_tbl_ent',      # Max entries in the BAT.
+    'N',    'block_size',       # Size of data section of a block, default 2M (0x00200000).
+    'N',    'checksum',         # One's compliment sum of all fields minus this one.
+    'a16',  'parent_uuid',      # Parent disk UUID (for differencing disk only).
+    'N',    'parent_tstamp',    # MTime of parent disk (sec since Jan 1 2000 12:00 AM in GMT).
+    'N',    'reserved1',        # reserved, should be 0.
+    'a512', 'parent_uname',     # Parent disk filename in UNICODE (UTF-16).
+    'a24',  'parent_loc1',      # Parent locator entries.
+    'a24',  'parent_loc2',
+    'a24',  'parent_loc3',
+    'a24',  'parent_loc4',
+    'a24',  'parent_loc5',
+    'a24',  'parent_loc6',
+    'a24',  'parent_loc7',
+    'a24',  'parent_loc8',
+  ])
+
+  PARENT_LOCATOR = BinaryStruct.new([
+    'a4', 'platform_code',  # Platform specific format used for locator.
+    'N',  'data_space',     # Number of sectors used to store locator.
+    'N',  'data_length',    # Byte length of locator.
+    'N',  'reserved1',      # Must be zero.
+    'N',  'data_offset_hi', # Absolute byte offset of locator.
+    'N',  'data_offset_lo',
+  ])
+
+  BAE_SIZE = 4
+  SECTOR_LENGTH = 512
+  FOOTER_LENGTH = 512
+  HEADER_LOCATION = 512
+  BLOCK_NOT_ALLOCATED = 0xffffffff
+  SUPPORTED_HEADER_VERSION = 0x00010000
+
+  def self.connect_to_hyperv(ostruct)
+    connection  = ostruct.hyperv_connection
+    @network    = ostruct.driveType == "Network"
+    hyperv_disk = MiqHyperVDisk.new(connection[:host],
+                                    connection[:user],
+                                    connection[:password],
+                                    connection[:port],
+                                    @network)
+    hyperv_disk.open(ostruct.fileName)
+    hyperv_disk
+  end
+
+  def self.d_init_common(dInfo, file)
+    @dInfo = dInfo
+    @blockSize = SECTOR_LENGTH
+    @file = file
+
+    # Get file,  footer & header, do footer verification.
+    @footer = getFooter(@file, true)
+    @header = getHeader(@footer, true)
+    verifyFooterCopy(@footer)
+
+    # Verify footer copy.
+
+    # Verify format version number (must be 0x00010000).
+    raise "Incompatible header version: 0x#{'%04x' % @header['header_ver']}" if @header['header_ver'] != SUPPORTED_HEADER_VERSION
+
+    # Calc sectors per block, bytes in block sector bitmap & BAT loc.
+    @secPerBlock = @header['block_size'] / @blockSize
+    @blockSectorBitmapByteCount = @secPerBlock / 8
+    if (bd = @blockSectorBitmapByteCount % 512) != 0
+      @blockSectorBitmapByteCount = @blockSectorBitmapByteCount + 512 - bd
+    end
+    @batBase = getHiLo(@header, "table_offset")
+    process_bae
+  end
+
+  def self.d_read_common(pos, len, parent = nil)
+    # Get starting & ending block, sector & byte offset of read.
+    blockStart, sectorStart, byteOffsetStart = blockPos(pos)
+    blockEnd,   sectorEnd,   byteOffsetEnd   = blockPos(pos + len - 1)
+
+    # Loop on blocks (2M entities of storage).
+    buf = ""
+    (blockStart..blockEnd).each do |blockNum|
+      # Loop on sectors (512 byte entities of storage).
+      secStart = (blockNum == blockStart) ? sectorStart : 0
+      secEnd   = (blockNum == blockEnd) ? sectorEnd : @secPerBlock - 1
+      (secStart..secEnd).each do |secNum|
+        # If STARTING, need to skip to where data is
+        if (blockStart == blockEnd) && (sectorStart == sectorEnd)
+          byteOffset = byteOffsetStart
+          thisLen    = len
+        elsif (blockNum == blockStart) && (secNum == sectorStart)
+          byteOffset = byteOffsetStart
+          thisLen    = @blockSize - byteOffset
+        # If ENDING, need to account for short read
+        elsif (blockNum == blockEnd) && (secNum == sectorEnd)
+          byteOffset = 0
+          thisLen    = len - buf.length
+          raise "Internal Error: Calculated read more than sector: #{thisLen}" if thisLen > @blockSize
+          # Read ENTIRE Sector in all other cases
+        else
+          byteOffset = 0
+          thisLen   = @blockSize
+        end
+
+        # If the allocation status of this sector is 0 return zeros.
+        allocStat = getAllocStatus(blockNum, secNum)
+        if allocStat == false
+          if parent.nil?
+            buf << MemoryBuffer.create(thisLen)
+          else
+            buf << parent.d_read(pos + buf.length, thisLen)
+          end
+        else
+          @file.seek(getAbsSectorLoc(blockNum, secNum) + byteOffset, IO::SEEK_SET)
+          buf << @file.read(thisLen)
+        end
+      end
+    end
+    buf
+  end
+
+  def self.d_write_common(pos, buf, len, parent = nil)
+    # Get starting & ending block, sector & byte offset of read.
+    blockStart, sectorStart, byteOffsetStart = blockPos(pos)
+    blockEnd,   sectorEnd,   byteOffsetEnd   = blockPos(pos + len - 1)
+
+    # Loop on blocks (2M entities of storage).
+    bytesWritten = 0
+    (blockStart..blockEnd).each do |blockNum|
+      # Loop on sectors (512 byte entities of storage).
+      secStart = (blockNum == blockStart) ? sectorStart : 0
+      secEnd   = (blockNum == blockEnd) ? sectorEnd : @secPerBlock - 1
+      (secStart..secEnd).each do |secNum|
+        # If STARTING, need to skip to where data is
+        if (blockStart == blockEnd) && (sectorStart == sectorEnd)
+          byteOffset = byteOffsetStart
+          thisLen    = len
+        elsif (blockNum == blockStart) && (secNum == sectorStart)
+          byteOffset = byteOffsetStart
+          thisLen    = @blockSize - byteOffset
+          # If ENDING, need to account for short read
+        elsif (blockNum == blockEnd) && (secNum == sectorEnd)
+          byteOffset = 0
+          thisLen    = len - bytesWritten
+          raise "Internal Error: Calculated read more than sector: #{thisLen}" if thisLen > @blockSize
+          # Read ENTIRE Sector in all other cases
+        else
+          byteOffset = 0
+          thisLen   = @blockSize
+        end
+
+        # If the allocation status of this sector is 0 then allocate it.
+        allocStat = getAllocStatus(blockNum, secNum)
+        allocSector(blockNum, secNum, pos + bytesWritten, parent) if allocStat == false
+        @file.seek(getAbsSectorLoc(blockNum, secNum) + byteOffset, IO::SEEK_SET)
+        bytesWritten += @file.write(buf[bytesWritten, thisLen], thisLen)
+      end
+    end
+    bytesWritten
+  end
+
+  # Disk size in sectors.
+  def self.d_size_common
+    getHiLo(@footer, "current_size") / @blockSize
+  end
+
+  def self.getHiLo(hash, member)
+    (hash["#{member}_hi"] << 32) + hash["#{member}_lo"]
+  end
+
+  # Needed by diff disk.
+  def self.header
+    @header
+  end
+
+  def self.getFooter(file, skip_check = false)
+    # NOTE: Spec says that if checksum fails use the copy in the header.
+    #       If that fails then the disk is corrupt.
+    file.seek(file.size - FOOTER_LENGTH, IO::SEEK_SET)
+    @footerBuf = file.read(FOOTER_LENGTH)
+    footer = FOOTER.decode(@footerBuf)
+    # TODO: Find out why this checksum test is failing.  For now don't call getFooter without skip_check set to "true"
+    unless skip_check
+      footerCsum = checksum(@footerBuf, 64)
+      raise "Footer checksum doesn't match: got 0x#{'%04x' % footerCsum}, s/b 0x#{'%04x' % @footer['checksum']}" if footerCsum != footer['checksum']
+    end
+    footer
+  end
+
+  private
+
+  def self.getHeader(footer, skip_check = false)
+    hdrLoc = getHiLo(footer, "data_offset")
+    hdrSiz = HEADER.size
+    puts "VHD Header is mislocated: 0x#{'%04x' % hdrLoc} (s/b 0x0200)" if hdrLoc != HEADER_LOCATION && !skip_check
+    @file.seek(hdrLoc, IO::SEEK_SET)
+    buf = @file.read(hdrSiz)
+    header = HEADER.decode(buf)
+    # TODO: Find out why this checksum test is failing.  For now don't call getHeader without skip_check set to "true"
+    unless skip_check
+      headerCsum = checksum(buf, 36)
+      raise "Header checksum doesn't match: got 0x#{'%04x' % headerCsum}, s/b 0x#{'%04x' % @header['checksum']}" if headerCsum != header['checksum']
+    end
+    header
+  end
+
+  def self.verifyFooterCopy(footer)
+    hdrLoc = getHiLo(footer, "data_offset")
+    @file.seek(hdrLoc - FOOTER_LENGTH, IO::SEEK_SET)
+    footer_copy = FOOTER.decode(@file.read(FOOTER_LENGTH))
+    puts "Footer copy does not match header." if footer_copy != @footer
+  end
+
+  def self.blockPos(pos)
+    rawSectorNumber, byteOffset = pos.divmod(@blockSize)
+    blockNumber, secInBlock = rawSectorNumber.divmod(@secPerBlock)
+    return blockNumber, secInBlock, byteOffset
+  end
+
+  def self.process_bae
+    @file.seek(@batBase, IO::SEEK_SET)
+    @bae = []
+    1.step(@header['max_tbl_ent'], 1) do |block_num|
+      @bae << @file.read(BAE_SIZE).unpack('N')[0]
+    end
+  end
+
+  def self.getBAE(blockNumber)
+    @bae[blockNumber]
+  end
+
+  def self.putBAE(blockNum, bae)
+    seekBAE(blockNum)
+    @file.write([bae].pack('N'), BAE_SIZE)
+  end
+
+  def self.seekBAE(blockNum)
+    batOffset = blockNum * BAE_SIZE + @batBase
+    @file.seek(batOffset, IO::SEEK_SET)
+  end
+
+  def self.getAllocStatus(blockNum, sectorNum)
+    sectorMask = seekAllocStatus(blockNum, sectorNum)
+    return false if sectorMask == BLOCK_NOT_ALLOCATED
+    sectorBitmap = @file.read(1).unpack('C')[0]
+    sectorBitmap & sectorMask == sectorMask
+  end
+
+  def self.setAllocStatus(blockNum, sectorNum)
+    sectorMask = seekAllocStatus(blockNum, sectorNum)
+    sectorBitmap = @file.read(1).unpack('C')[0]
+    sectorBitmap |= sectorMask
+    @file.seek(-1, IO::SEEK_CUR)
+    @file.write([sectorBitmap].pack('C'), 1)
+  end
+
+  def self.seekAllocStatus(blockNum, sectorNum)
+    sectorByte, bitOffset = sectorNum.divmod(8)
+    bae = getBAE(blockNum)
+    return bae if bae == BLOCK_NOT_ALLOCATED
+    @file.seek(bae * @blockSize + sectorByte, IO::SEEK_SET)
+    0x80 >> bitOffset
+  end
+
+  def self.getAbsSectorLoc(blockNum, sectorNum)
+    getBAE(blockNum) * @blockSize + sectorNum * @blockSize + @blockSectorBitmapByteCount
+  end
+
+  def self.allocSector(blockNum, sectorNum, pos, parent)
+    allocBlock(blockNum) if getBAE(blockNum) == BLOCK_NOT_ALLOCATED
+    if parent.nil?
+      buf = MemoryBuffer.create(@blockSize)
+    else
+      sector = pos.divmod(@blockSize)[0]
+      buf = parent.d_read(sector, @blockSize)
+    end
+    setAllocStatus(blockNum, sectorNum)
+    @file.seek(getAbsSectorLoc(blockNum, sectorNum), IO::SEEK_SET)
+    @file.write(buf, buf.size)
+  end
+
+  def self.allocBlock(blockNum)
+    # Alloc block.
+    pos = @file.size - FOOTER_LENGTH
+    sector = findFreeSector
+    putBAE(blockNum, sector)
+    # Write sector alloc bitmap.
+    bmp = MemoryBuffer.create(@blockSectorBitmapByteCount)
+    @file.seek(sector * @blockSize, IO::SEEK_SET)
+    @file.write(bmp, bmp.size)
+    # Footer has to move. Total size is 2048 + size of data blocks.
+    pos += @secPerBlock * @blockSize
+    @file.seek(pos, IO::SEEK_SET)
+    @file.write(@footerBuf, @footerBuf.size)
+  end
+
+  def self.findFreeSector
+    # Find a free disk sector with which to start a new block.
+    if @freeSector.nil?
+      seekBAE(0); ents = @header['max_tbl_ent']
+      baes = @file.read(ents * BAE_SIZE).unpack("N#{ents}")
+      baes.delete(BLOCK_NOT_ALLOCATED)
+      raise "Disk full." if baes.size == @header['max_tbl_ent']
+      @freeSector = baes.max
+    end
+    @freeSector += @secPerBlock
+    raise "Disk full." if @freeSector > d_size_common / @blockSize
+    @freeSector
+  end
+
+  def self.checksum(buf, skip_offset)
+    csum = 0
+    0.upto(buf.size - 1) do|i|
+      next if i >= skip_offset && i < skip_offset + 4
+      csum += buf[i].to_i
+    end
+    # GRRRRR - convert to actual 32-bits.
+    [~csum].pack('L').unpack('L')[0]
+  end
+end # module

data/lib/disk/modules/MSVSDiffDisk.rb

@@ -0,0 +1,91 @@
+# encoding: US-ASCII
+
+require 'disk/modules/MSCommon'
+
+module MSVSDiffDisk
+  def d_init
+    self.diskType = "MSVS Differencing"
+    self.blockSize = MSCommon::SECTOR_LENGTH
+    if dInfo.mountMode.nil? || dInfo.mountMode == "r"
+      dInfo.mountMode = "r"
+      fileMode = "r"
+    elsif dInfo.mountMode == "rw"
+      fileMode = "r+"
+    else
+      raise "Unrecognized mountMode: #{dInfo.mountMode}"
+    end
+    if dInfo.hyperv_connection
+      @hyperv_connection = dInfo.hyperv_connection
+      @ms_disk_file      = MSCommon.connect_to_hyperv(dInfo)
+    else
+      @hyperv_connection = nil
+      @ms_disk_file      = MiqLargeFile.open(dInfo.fileName, fileMode) unless dInfo.baseOnly
+    end
+    MSCommon.d_init_common(dInfo, @ms_disk_file) unless dInfo.baseOnly
+
+    # Get parent locators.
+    @locators = []
+    1.upto(8) do|idx|
+      @locators << MSCommon::PARENT_LOCATOR.decode(MSCommon.header["parent_loc#{idx}"])
+      next if @locators[idx - 1]['platform_code'] == "\000\000\000\000"
+      locator = @locators[idx - 1]
+      if locator['platform_code'] == "W2ku"
+        getParentPathWin(locator)
+        getParent(locator)
+      end
+    end
+    raise "No compatible parent locator found" if @parent == nil
+  end
+
+  def getBase
+    @parent || self
+  end
+
+  # /////////////////////////////////////////////////////////////////////////
+  # Implementation.
+
+  def d_read(pos, len)
+    MSCommon.d_read_common(pos, len, @parent)
+  end
+
+  def d_write(pos, buf, len)
+    MSCommon.d_write_common(pos, buf, len, @parent)
+  end
+
+  def d_close
+    @parent.close if @parent
+    @ms_disk_file.close
+  end
+
+  def d_size
+    total = 0
+    total = @parent.d_size if @parent
+    total += @ms_disk_file.size
+    total
+  end
+
+  # /////////////////////////////////////////////////////////////////////////
+  # // Helpers.
+
+  private
+
+  def getParent(locator)
+    if locator.key?('fileName')
+      @parent_ostruct                   = OpenStruct.new
+      @parent_ostruct.fileName          = locator['fileName']
+      @parent_ostruct.driveType         = dInfo.driveType
+      @parent_ostruct.hyperv_connection = @hyperv_connection unless @hyperv_connection.nil?
+      @parent                           = MiqDisk.getDisk(@parent_ostruct)
+    end
+  end
+
+  def getParentPathWin(locator)
+    buf = getPathData(locator)
+    locator['fileName'] = buf.UnicodeToUtf8!
+  end
+
+  def getPathData(locator)
+    @ms_disk_file.seek(MSCommon.getHiLo(locator, "data_offset"), IO::SEEK_SET)
+    @ms_disk_file.read(locator['data_length'])
+  end
+end

data/lib/disk/modules/MSVSDiskProbe.rb

@@ -0,0 +1,61 @@
+# encoding: US-ASCII
+
+require 'Scvmm/miq_hyperv_disk'
+require 'disk/modules/MiqLargeFile'
+require 'disk/modules/MSCommon'
+
+module MSVSDiskProbe
+  MS_MAGIC      = "conectix"
+
+  TYPE_FIXED    = 2
+  TYPE_DYNAMIC  = 3
+  TYPE_DIFF     = 4
+
+  MOD_FIXED     = "MSVSFixedDisk"
+  MOD_DYNAMIC   = "MSVSDynamicDisk"
+  MOD_DIFF      = "MSVSDiffDisk"
+
+  def self.probe(ostruct)
+    return nil unless ostruct.fileName
+    # If file not VHD then not Microsoft.
+    # Allow ".miq" also.
+    ext = File.extname(ostruct.fileName).downcase
+    return nil if ext != ".vhd" && ext != ".avhd" && ext != ".miq"
+
+    if ostruct.hyperv_connection
+      ms_disk_file = connect_to_hyperv(ostruct)
+    else
+      # Get (assumed) footer.
+      ms_disk_file = MiqLargeFile.open(ostruct.fileName, "rb")
+    end
+    footer = MSCommon.getFooter(ms_disk_file, true)
+    ms_disk_file.close
+
+    # Check for MS disk.
+    return nil if footer['cookie'] != MS_MAGIC
+
+    # Return module name to handle type.
+    case footer['disk_type']
+    when TYPE_FIXED
+      return MOD_FIXED
+    when TYPE_DYNAMIC
+      return MOD_DYNAMIC
+    when TYPE_DIFF
+      return MOD_DIFF
+    else
+      raise "Unsupported MS disk: #{footer['disk_type']}"
+    end
+  end
+
+  def self.connect_to_hyperv(ostruct)
+    connection  = ostruct.hyperv_connection
+    network     = ostruct.driveType == "Network"
+    hyperv_disk = MiqHyperVDisk.new(connection[:host],
+                                    connection[:user],
+                                    connection[:password],
+                                    connection[:port],
+                                    network)
+    hyperv_disk.open(ostruct.fileName)
+    hyperv_disk
+  end
+end