manageiq-smartstate 0.1.0

data/lib/disk/modules/VixDiskMod.rb

@@ -0,0 +1,54 @@
+require 'VMwareWebService/VixDiskLib/VixDiskLib'
+
+module VixDiskMod
+  def d_init
+    self.diskType = "VixDisk"
+    @vdi = dInfo.vixDiskInfo
+    @connection = @vdi[:connection]
+
+    if dInfo.mountMode.nil? || dInfo.mountMode == "r"
+      dInfo.mountMode = "r"
+      fileMode = VixDiskLib::VIXDISKLIB_FLAG_OPEN_READ_ONLY
+    elsif dInfo.mountMode == "rw"
+      fileMode = 0
+    else
+      raise "Unrecognized mountMode: #{dInfo.mountMode}"
+    end
+
+    dInfo.fileName = @vdi[:fileName]
+    unless (@diskObj = dInfo.vixDiskObj)
+      @diskObj = @connection.getDisk(@vdi[:fileName], fileMode)
+      dInfo.vixDiskObj = @diskObj
+    end
+    self.blockSize = @diskObj.sectorSize
+  end
+
+  def getBase
+    self
+  end
+
+  def d_read(pos, len)
+    pos += @dInfo.offset if @dInfo.offset
+    @diskObj.read(pos, len)
+  end
+
+  def d_write(pos, buf, len)
+    pos += @dInfo.offset if @dInfo.offset
+    @diskObj.write(pos, buf, len)
+  end
+
+  def d_close
+    if @partNum == 0
+      $log.debug "VixDiskMod: closing disk #{@dInfo.fileName}" if $log
+      $log.debug "VixDiskMod: closing base VdlDisk <#{@diskObj.ssId}>" if $log
+      @diskObj.close
+    else
+      $log.debug "VixDiskMod: not base disk, not closing base VdlDisk" if $log
+    end
+  end
+
+  # Disk size in sectors.
+  def d_size
+    @diskObj.info[:capacity]
+  end
+end

data/lib/disk/modules/VixDiskProbe.rb

@@ -0,0 +1,6 @@
+module VixDiskProbe
+  def self.probe(ostruct)
+    return("VixDiskMod") if ostruct.vixDiskInfo
+    (nil)
+  end
+end

data/lib/disk/modules/miq_disk_cache.rb

@@ -0,0 +1,135 @@
+require 'rufus/lru'
+require_relative "../MiqDisk"
+require 'ostruct'
+
+module MiqDiskCache
+  MIN_SECTORS_PER_ENTRY = 32
+  DEF_LRU_HASH_ENTRIES = 100
+  DEBUG_CACHE_STATS    = false
+
+  attr_reader :d_size, :blockSize, :lru_hash_entries, :min_sectors_per_entry, :cache_hits, :cache_misses
+
+  def self.new(up_stream, lru_hash_entries = DEF_LRU_HASH_ENTRIES, min_sectors_per_entry = MIN_SECTORS_PER_ENTRY)
+    raise "MiqDiskCache: Downstream Disk Module is nil" if up_stream.nil?
+    @dInfo                       = OpenStruct.new
+    @dInfo.lru_hash_entries      = lru_hash_entries
+    @dInfo.min_sectors_per_entry = min_sectors_per_entry
+    @dInfo.block_size            = up_stream.blockSize
+    @dInfo.up_stream             = up_stream
+
+    MiqDisk.new(self, @dInfo, 0)
+  end
+
+  def d_init
+    @block_cache           = LruHash.new(@dInfo.lru_hash_entries)
+    @cache_hits            = Hash.new(0)
+    @cache_misses          = Hash.new(0)
+    @blockSize             = @dInfo.block_size
+    @up_stream             = @dInfo.up_stream
+    @min_sectors_per_entry = @dInfo.min_sectors_per_entry
+  end
+
+  def d_size
+    @d_size ||= @up_stream.d_size
+  end
+
+  def dInfo
+    @up_stream.dInfo
+  end
+
+  def d_read(pos, len)
+    $log.debug "MiqDiskCache.d_read(#{pos}, #{len})"
+    return nil if pos >= @endByteAddr
+    len = @endByteAddr - pos if (pos + len) > @endByteAddr
+    start_sector, start_offset = pos.divmod(@blockSize)
+    end_sector                 = (pos + len - 1) / @blockSize
+    number_sectors             = end_sector - start_sector + 1
+    d_read_cached(start_sector, number_sectors)[start_offset, len]
+  end
+
+  def d_read_cached(start_sector, number_sectors)
+    $log.debug "MiqDiskCache.d_read_cached(#{start_sector}, #{number_sectors})"
+    @block_cache.keys.each do |block_range|
+      sector_offset = start_sector - block_range.first
+      buffer_offset = sector_offset * @blockSize
+      if block_range.include?(start_sector) && block_range.include?(start_sector + number_sectors - 1)
+        length = number_sectors * @blockSize
+        @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 reqd, but more data is required at the end of the request
+        sectors_in_range = block_range.last - start_sector
+        length           = sectors_in_range * @blockSize
+        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] + d_read_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 * @blockSize
+        remaining_blocks = number_sectors - sectors_in_range
+        @cache_hits[start_sector] += 1
+        # The "<<" operator is valid and more efficient here
+        return d_read_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 d_read_cached(start_sector, sectors_pre_range) <<
+               @block_cache[block_range] +
+               d_read_cached(block_range.last + 1, sectors_post_range)
+      end
+    end
+    block_range               = entry_range(start_sector, number_sectors)
+    range_length              = (block_range.last - block_range.first + 1) * @blockSize
+    @block_cache[block_range] = @up_stream.d_read(block_range.first * @blockSize, range_length)
+    @cache_misses[start_sector] += 1
+
+    sector_offset = start_sector - block_range.first
+    buffer_offset = sector_offset * @blockSize
+    length        = number_sectors * @blockSize
+
+    @block_cache[block_range][buffer_offset, length]
+  end
+
+  def d_close
+    hit_or_miss if DEBUG_CACHE_STATS
+    @up_stream.d_close
+  end
+
+  def method_missing(m, *args)
+    @up_stream.send(m, *args)
+  end
+
+  def respond_to_missing(_method_name, _include_private = false)
+    true
+  end
+
+  private
+
+  def hit_or_miss
+    hits   = @cache_hits.values.reduce(:+)
+    misses = @cache_misses.values.reduce(:+)
+    $log.debug "MiqDiskCache cache hits: #{hits}"
+    $log.debug "MiqDiskCache cache misses: #{misses}"
+  end
+
+  def entry_range(start_sector, number_sectors)
+    # Cache entries are *multiples* of @min_sectors_per_entry * @blocksize  in length,
+    # aligned to @min_sectors_per_entry * @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_per_entry
+    real_end_block      = (start_sector + number_sectors) / @min_sectors_per_entry
+    number_cache_blocks = real_end_block - real_start_block + 1
+    sectors_to_read     = number_cache_blocks * @min_sectors_per_entry
+    real_start_sector   = real_start_block * @min_sectors_per_entry
+    end_sector          = real_start_sector + sectors_to_read - 1
+    Range.new(real_start_sector, end_sector)
+  end
+end

data/lib/disk/modules/miq_dummy_disk.rb

@@ -0,0 +1,41 @@
+require 'memory_buffer'
+require_relative "../MiqDisk"
+require 'ostruct'
+
+module MiqDummyDisk
+  DEF_BLOCK_SIZE = 512
+  DEF_DISK_SIZE  = 1024
+
+  attr_reader :d_size, :blockSize, :dInfo
+
+  def self.new(d_info = nil)
+    @dInfo          = d_info || OpenStruct.new
+    @dInfo.fileName = "dummy disk"
+    @dInfo.d_size     ||= DEF_DISK_SIZE
+    @dInfo.block_size ||= DEF_BLOCK_SIZE
+    MiqDisk.new(self, @dInfo, 0)
+  end
+
+  def d_init
+    @blockSize = @dInfo.block_size
+    @diskType  = "dummy-disk"
+  end
+
+  def d_size
+    @d_size ||= @dInfo.d_size
+  end
+
+  def d_write(_pos, _buf, len)
+    len
+  end
+
+  def d_read(pos, len)
+    return nil if pos >= @endByteAddr
+    len = @endByteAddr - pos if (pos + len) > @endByteAddr
+    buffer = MemoryBuffer.create(len)
+    buffer
+  end
+
+  def d_close
+  end
+end

data/lib/disk/modules/vhdx_bat_entry.rb

@@ -0,0 +1,10 @@
+# encoding: US-ASCII
+
+class VhdxBatEntry
+  attr_reader :block, :state, :offset
+  def initialize(block, state, offset)
+    @block  = block - 1
+    @state  = state
+    @offset = offset
+  end
+end

data/lib/disk/test.rb

@@ -0,0 +1,66 @@
+begin
+  require 'log4r'
+  require 'ostruct'
+  require 'disk/MiqDisk'
+
+  #
+  # 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'
+
+  diskInfo = OpenStruct.new
+  diskInfo.rawDisk = true
+  # diskInfo.fileName = File.join(File. dirname(__FILE__), "dos_mbr.img")
+  # diskInfo.fileName = "/Users/rpo/vmware/Win2K3-EE/Windows Server 2003 Enterprise Edition-flat.vmdk"
+  # diskInfo.fileName = "/Users/rpo/vmware/knoppixDVM/knoppixDVM.vmdk"
+  # diskInfo.fileName = "/volumes/SCRATCH/VMs/VirtualPC/VHDFixedFAT32TwoPart/VHDFixedFAT32.vhd"
+
+  diskInfo.fileName = "/dev/xvdf"
+  # diskInfo.fileName = "./Win2k3R2EE.vhd"
+  # diskInfo.fileName = "./Windows XP Pro 2.vhd"
+
+  disk = MiqDisk.getDisk(diskInfo)
+
+  unless disk
+    puts "Failed to open disk"
+    exit(1)
+  end
+
+  puts "Disk type: #{disk.diskType}"
+  puts "Disk partition type: #{disk.partType}"
+  puts "Disk block size: #{disk.blockSize}"
+  puts "Disk start LBA: #{disk.lbaStart}"
+  puts "Disk end LBA: #{disk.lbaEnd}"
+  puts "Disk start byte: #{disk.startByteAddr}"
+  puts "Disk end byte: #{disk.endByteAddr}"
+
+  parts = disk.getPartitions
+
+  exit(0) unless parts
+
+  i = 1
+  parts.each do |p|
+    puts "\nPartition #{i}:"
+    puts "\tDisk type: #{p.diskType}"
+    puts "\tPart partition type: #{p.partType}"
+    puts "\tPart block size: #{p.blockSize}"
+    puts "\tPart start LBA: #{p.lbaStart}"
+    puts "\tPart end LBA: #{p.lbaEnd}"
+    puts "\tPart start byte: #{p.startByteAddr}"
+    puts "\tPart end byte: #{p.endByteAddr}"
+    i += 1
+  end
+
+  disk.close
+rescue => err
+  puts err.to_s
+  puts err.backtrace.join("\n")
+end