manageiq-smartstate 0.1.0

data/lib/disk/modules/VMWareDescriptor.rb

@@ -0,0 +1,214 @@
+require 'pathname'
+
+module VMWareDescriptor
+  def d_init
+    # Check to see if a descriptor was not embedded.
+    descriptor = dInfo.Descriptor
+    if descriptor.nil?
+      f = File.open(dInfo.fileName, "rb")
+      descriptor = f.read; f.close
+    end
+
+    # Make sure this is a descriptor.
+    desc, defs = parseDescriptor(descriptor, dInfo.fileName)
+    raise "No disk definitions" if defs.size == 0
+    # Make sure each disk is there.
+    defs.each do|diskDef|
+      raise "No disk file: #{diskDef['filename']}" unless File.exist?(diskDef['filename'])
+    end
+
+    # Init needed stff.
+    self.diskType = "VMWare Descriptor"
+    self.blockSize = 512
+    @desc     = desc  # This disk descriptor.
+    @defs     = defs  # Disk extent definitions.
+    @ostructs = []    # Component OpenStructs for disk objects.
+    @disks    = []    # Component MiqDisk objects (one for each disk).
+
+    # If there's a parent parse it first (all subordinate disks need a ref to parent).
+    if desc.key?('parentFileNameHint')
+      @parentOstruct = OpenStruct.new
+
+      # Get the parentFileNameHint and be sure it is relative to the descriptor file's directory
+      parentFileName = Pathname.new(desc['parentFileNameHint'])
+      if parentFileName.absolute?
+        parentFileName = parentFileName.relative_path_from(Pathname.new(dInfo.fileName).dirname)
+        $log.debug "VMWareDescriptor: Parent disk file is absolute. Using relative path [#{parentFileName}]" if $log
+      end
+      parentFileName = File.dirname(dInfo.fileName) + "/" + parentFileName.to_s.tr("\\", "/")
+      $log.debug "VMWareDescriptor: Getting parent disk file [#{parentFileName}]" if $log
+
+      @parentOstruct.fileName = parentFileName
+      @parentOstruct.mountMode = dInfo.mountMode
+      @parentOstruct.hardwareId = dInfo.hardwareId if dInfo.baseOnly
+      d = MiqDisk.getDisk(@parentOstruct)
+      raise "MiqDisk#getDisk returned nil for parent disk #{@parentOstruct.fileName}" if d.nil?
+      @parent = d
+      return if dInfo.baseOnly
+    end
+
+    # Instance MiqDisks for each disk definition.
+    defs.each do |diskDef|
+      thisO = OpenStruct.new
+      thisO.Descriptor = dInfo.Descriptor if dInfo.Descriptor
+      thisO.parent = @parent
+      thisO.fileName = diskDef['filename']
+      thisO.offset = diskDef['offset']
+      thisO.rawDisk = true if diskDef['type'].strip == 'FLAT'
+      thisO.rawDisk = true if diskDef['type'].strip == 'VMFS'
+      thisO.mountMode = dInfo.mountMode
+      @ostructs << thisO
+      d = MiqDisk.getDisk(thisO)
+      raise "MiqDisk#getDisk returned nil for component disk #{thisO.fileName}" if d.nil?
+      @disks << d
+    end
+  end
+
+  def getBase
+    @parent || self
+  end
+
+  def d_read(pos, len)
+    # $log.debug "VMWareDescriptor.d_read << pos #{pos} len #{len}" if $log && $log.debug?
+    # Get start and end extents.
+    dStart = getTargetDiskIndex((pos / @blockSize).ceil)
+    dEnd   = getTargetDiskIndex(((pos + len) / @blockSize).ceil)
+
+    if dStart == dEnd
+      # Case: single extent.
+      retBytes = @disks[dStart].d_read(pos, len, getDiskByteOffset(dStart))
+    else
+      # Case: span extents.
+      retBytes = ""; bytesRead = 0
+      dStart.upto(dEnd) do |diskIdx|
+        readLen = @disks[diskIdx].d_size
+
+        # Adjust length for start and end extents.
+        readLen -= pos if diskIdx == dStart
+        readLen -= (len - bytesRead) if diskIdx == dEnd
+
+        # Read.
+        retBytes << @disks[diskIdx].d_read(pos + bytesRead, readLen, getDiskByteOffset(diskIdx))
+        bytesRead += readLen
+      end
+    end
+    # $log.debug "VMWareDescriptor.d_read >> retBytes.length #{retBytes.length}" if $log && $log.debug?
+    retBytes
+  end
+
+  def d_write(pos, buf, len)
+    dStart = getTargetDiskIndex((pos / @blockSize).ceil)
+    dEnd   = getTargetDiskIndex(((pos + len) / @blockSize).ceil)
+
+    # Case: single extent.
+    return @disks[dStart].d_write(pos, buf, len, getDiskByteOffset(dStart)) if dStart == dEnd
+
+    # Case: span extents.
+    bytesWritten = 0
+    dStart.upto(dEnd) do |diskIdx|
+      writeLen = @disks[diskIdx].d_size
+
+      # Adjust length for start and end extents.
+      writeLen -= pos if diskIdx == dStart
+      writeLen -= (len - bytesWritten) if diskIdx == dEnd
+
+      # Write.
+      bytesWritten += @disks[diskIdx].d_write(pos + bytesWritten, writeLen, getDiskByteOffset(diskIdx))
+    end
+    bytesWritten
+  end
+
+  # Close all disks.
+  def d_close
+    @parent.close unless @parent.nil?
+    @disks.each(&:close)
+  end
+
+  # Return size in sectors.
+  def d_size
+    total = 0
+    @defs.each { |diskDef| total += diskDef['size'].to_i }
+    total
+  end
+
+  # Get target disk index based on sector number.
+  def getTargetDiskIndex(sector)
+    dIdx = -1; total = 0
+    0.upto(@defs.size - 1) do|idx|
+      total += @defs[idx]['size'].to_i
+      if total >= sector
+        dIdx = idx
+        break
+      end
+    end
+    raise "Sector is past end of disk: #{sector}" if dIdx == -1
+    raise "Disk object is nil for #{sector}" if @disks[dIdx].nil?
+    dIdx
+  end
+
+  # Get beginning byte offset of target disk.
+  def getDiskByteOffset(target)
+    total = 0
+    0.upto(@defs.size - 1) do|idx|
+      break if idx == target
+      total += @defs[idx]['size'].to_i
+    end
+    total * @blockSize
+  end
+
+  # This is all from metadata/vmdk.rb
+  def parseDescriptor(descriptor, fname)
+    defs  = []
+    dict  = {}
+
+    descriptor.each_line do |line|
+      line.chomp!; line.strip!
+      next if line.length == 0 || line[0, 1] == "\#"
+      eqSign = line.index("=")
+      if eqSign.nil?
+        defs << parseDiskDescription(line, File.dirname(fname))
+      else
+        dict[line[0, eqSign].strip] = unquote(line[eqSign + 1..line.length - 1].strip)
+      end
+    end
+    return dict, defs
+  end
+
+  def splitSpecial(line)
+    two = line.split('"')
+    out = two[0].split(' ')
+    out << two[1]
+    out
+  end
+
+  def parseDiskDescription(line, dirname)
+    elems = splitSpecial(line)
+    nelems = elems.size
+    raise "Not Enough Disk Parameters: #{line}" if nelems < 4
+    raise "Too Many Disk Parameters: #{line}"   if nelems > 5
+
+    disk = Hash["access", elems[0], "size", elems[1], "type", elems[2], "filename", elems[3], "offset", elems[4]]
+    disk["filename"] = File.join(dirname, fixBrokenExtension(unquote(disk["filename"])))
+    disk["offset"]   = 0 if (nelems == 4)
+    disk
+  end
+
+  def unquote(str)
+    str.delete!("\"")
+    str.strip! unless str.nil?
+    str
+  end
+
+  # Descriptors that pass through FAT file systems may have 8.3 names.
+  # File.exist?("c:/window~1.vmd") will match "c:/window~1.vmdk", but
+  # CreateFile will fail, so fix the extension.
+  def fixBrokenExtension(fn)
+    if fn[-4, 4] == ".vmd" then fn += "k" end
+    if fn =~ /\.vmd[^k]/
+      fn.gsub!(/\.vmd/, ".vmdk")
+    end
+    fn
+  end
+
+  private :parseDescriptor, :parseDiskDescription, :splitSpecial, :unquote, :fixBrokenExtension
+end # module VMWareDescriptor

data/lib/disk/modules/VMWareDiskProbe.rb

@@ -0,0 +1,74 @@
+# encoding: US-ASCII
+
+module VMWareDiskProbe
+  SPARSE_MAGIC = "KDMV"
+  SPARSE_MOD   = "VMWareSparseDisk"
+  COWD_MAGIC   = "COWD"
+  COWD_MOD     = "VMWareCowdDisk"
+  DESC_MOD     = "VMWareDescriptor"
+
+  def self.probe(ostruct)
+    return nil unless ostruct.fileName
+    # If not .vmdk then not VMWare.
+    # Allow .miq also.
+    ext = File.extname(ostruct.fileName).downcase
+    return nil if ext != ".vmdk" && ext != ".miq"
+
+    size  = File.size(ostruct.fileName)
+    f     = File.new(ostruct.fileName, "rb")
+    magic = f.read(4)
+
+    if magic == SPARSE_MAGIC
+      # get descriptor offset & size.
+      f.seek(24, IO::SEEK_CUR)
+      ofs = f.read(8).unpack("Q")[0]
+      siz = f.read(8).unpack("Q")[0]
+    end
+
+    binary = false
+    if (magic != SPARSE_MAGIC) && (magic != COWD_MAGIC)
+      f.rewind
+      loop do
+        data   = f.read(4096)
+        break if data.nil?
+        binary = binary_data?(data)
+        break if binary
+      end
+    end
+
+    f.close
+
+    return COWD_MOD if magic == COWD_MAGIC
+
+    if magic == SPARSE_MAGIC
+      # If this ostruct already has a descriptor don't bother checking.
+      # NOTE: If it does have a descriptor, we're coming from VMWareDescriptor.rb
+      #       trying to open a disk - so don't regress infinitely.
+      if ostruct.Descriptor.nil? && ofs > 0
+        getDescriptor(ofs, siz, ostruct) if ofs > 0
+        return DESC_MOD
+      end
+
+      return SPARSE_MOD
+    end
+
+    return false if binary
+    DESC_MOD
+  end
+
+  def self.getDescriptor(ofs, siz, ostruct)
+    f = File.open(ostruct.fileName, "rb")
+    f.seek(ofs * 512, IO::SEEK_SET)
+    desc = f.read(siz * 512)
+    f.close
+
+    pos  = desc.index("\000")
+    desc = desc[0...pos] unless pos.nil?
+    ostruct.Descriptor = desc
+  end
+
+  def self.binary_data?(str)
+    return false if str.nil? || str.empty?
+    return (str.count("^ -~", "^\r\n") / str.size > 0.3 || str.count("\x00") > 0) unless str.empty?
+  end
+end # module VMWareDiskProbe

data/lib/disk/modules/VMWareSparseDisk.rb

@@ -0,0 +1,189 @@
+require 'disk/modules/MiqLargeFile'
+require 'binary_struct'
+require 'memory_buffer'
+
+module VMWareSparseDisk
+  SPARSE_EXTENT_HEADER = BinaryStruct.new([
+    'L', 'magicNumber',
+    'L', 'version',
+    'L', 'flags',
+    'Q', 'capacity',
+    'Q', 'grainSize',
+    'Q', 'descriptorOffset',
+    'Q', 'descriptorSize',
+    'L', 'numGTEsPerGT',
+    'Q', 'rgdOffset',
+    'Q', 'gdOffset',
+    'Q', 'overHead',
+    'C', 'uncleanShutdown'
+  ])
+  SIZEOF_SPARSE_EXTENT_HEADER = SPARSE_EXTENT_HEADER.size
+  GTE_SIZE = 4
+  GDE_SIZE = 4
+
+  def d_init
+    self.diskType = "VMWare Sparse"
+    self.blockSize = 512
+    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
+    @vmwareSparseDisk_file = MiqLargeFile.open(dInfo.fileName, fileMode)
+    buf = @vmwareSparseDisk_file.read(SIZEOF_SPARSE_EXTENT_HEADER)
+    @sparseHeader = OpenStruct.new(SPARSE_EXTENT_HEADER.decode(buf))
+    @grainSize = @sparseHeader.grainSize
+    @grainBytes = @grainSize * blockSize
+    @capacity = @sparseHeader.capacity * blockSize
+
+    #
+    # Seek to start of the grain directory.
+    #
+    @vmwareSparseDisk_file.seek(@sparseHeader.gdOffset * blockSize, IO::SEEK_SET)
+
+    #
+    # Read the first grain directory entry to get the offset to the start of
+    # the grain tables.
+    #
+    buf = @vmwareSparseDisk_file.read(GDE_SIZE)
+    @grainTableBase = buf.unpack('L')[0] * blockSize
+    # dumpGT
+  end
+
+  def getBase
+    self
+  end
+
+  def d_read(pos, len, offset = 0)
+    gnStart, goStart = grainPos(pos - offset)
+    gnEnd, goEnd = grainPos(pos + len - offset)
+
+    if gnStart == gnEnd
+      grainPos = getGTE(gnStart)
+      # Mods for parent link.
+      if grainPos == 0
+        return MemoryBuffer.create(len) if @dInfo.parent.nil?
+        return @dInfo.parent.d_read(pos, len)
+      else
+        @vmwareSparseDisk_file.seek(grainPos + goStart, IO::SEEK_SET)
+        return @vmwareSparseDisk_file.read(len)
+      end
+    end
+
+    bytesRead = 0
+    rv = ''
+    (gnStart..gnEnd).each do |gn|
+      so = 0
+      l = @grainBytes
+
+      if gn == gnStart
+        so = goStart
+        l -= so
+      end
+      l -= (@grainBytes - goEnd) if gn == gnEnd
+
+      gp = getGTE(gn)
+      # Mods for parent link.
+      if gp == 0
+        if @dInfo.parent.nil?
+          rv << MemoryBuffer.create(l)
+        else
+          rv << @dInfo.parent.d_read(pos + bytesRead, l)
+        end
+      else
+        @vmwareSparseDisk_file.seek(gp + so, IO::SEEK_SET)
+        rv << @vmwareSparseDisk_file.read(l)
+      end
+      bytesRead += l
+    end
+    rv
+  end
+
+  def d_write(pos, buf, len, offset = 0)
+    gnStart, goStart = grainPos(pos - offset)
+    gnEnd, goEnd = grainPos(pos + len - offset)
+
+    if gnStart == gnEnd
+      grainPos = getGTE(gnStart)
+      grainPos = allocGrain(gnStart) if grainPos == 0
+      @vmwareSparseDisk_file.seek(grainPos + goStart, IO::SEEK_SET)
+      return @vmwareSparseDisk_file.write(buf, len)
+    end
+
+    bytesWritten = 0
+    (gnStart..gnEnd).each do |gn|
+      so = 0
+      l = @grainBytes
+
+      if gn == gnStart
+        so = goStart
+        l -= so
+      end
+      if gn == gnEnd
+        l -= (@grainBytes - goEnd)
+      end
+
+      gp = getGTE(gn)
+      gp = allocGrain(gn) if gp == 0
+      @vmwareSparseDisk_file.seek(gp + so, IO::SEEK_SET)
+      bytesWritten += @vmwareSparseDisk_file.write(buf[bytesWritten, l], l)
+    end
+    bytesWritten
+  end
+
+  def d_close
+    @vmwareSparseDisk_file.close
+  end
+
+  # Disk size in sectors.
+  def d_size
+    @capacity / @blockSize
+  end
+
+  private
+
+  def grainPos(pos)
+    gn = pos / @grainBytes
+    go = pos - (gn * @grainBytes)
+    return gn, go
+  end
+
+  def getGTE(gn)
+    seekGTE(gn)
+    gte = @vmwareSparseDisk_file.read(GTE_SIZE).unpack('L')[0]
+    gte * blockSize
+  end
+
+  def allocGrain(gn)
+    sector = findFreeSector; byte = gn * @grainBytes
+    buf = @dInfo.parent.nil? ? MemoryBuffer.create(@grainBytes) : @dInfo.parent.d_read(byte, @grainBytes)
+    seekGTE(gn)
+    @vmwareSparseDisk_file.write([sector].pack('L'), GTE_SIZE)
+    @vmwareSparseDisk_file.seek(sector * blockSize, IO::SEEK_SET)
+    @vmwareSparseDisk_file.write(buf, @grainBytes)
+    sector * blockSize
+  end
+
+  def seekGTE(gn)
+    gteOffset = @grainTableBase + (gn * GTE_SIZE)
+    @vmwareSparseDisk_file.seek(gteOffset, IO::SEEK_SET)
+  end
+
+  def findFreeSector
+    if @freeSector.nil?
+      numGrains = @sparseHeader.capacity / @grainSize
+      @vmwareSparseDisk_file.seek(@grainTableBase, IO::SEEK_SET)
+      @freeSector = 0
+      numGrains.times do |_i|
+        last = @vmwareSparseDisk_file.read(GTE_SIZE).unpack('L')[0]
+        @freeSector = last if last > @freeSector
+      end
+    end
+    @freeSector += @grainSize
+    raise "Disk full." if @freeSector * blockSize > @capacity
+    @freeSector
+  end
+end