manageiq-smartstate 0.1.0

data/lib/fs/ReiserFS/superblock.rb

@@ -0,0 +1,140 @@
+require 'binary_struct'
+require 'stringio'
+
+require 'fs/ReiserFS/block'
+require 'fs/ReiserFS/utils'
+
+require 'rufus/lru'
+
+module ReiserFS
+  SUPERBLOCK = BinaryStruct.new([
+    'V',  'num_blocks',         # The number of blocks in the partition
+    'V',  'num_free_blocks',    # The number of free blocks in the partition
+    'V',  'root_block',         # The block number of the block containing the root node
+    'V',  'journal_block',      # The block number of the block containing the first journal node
+    'V',  'journal_device',     # Journal device number
+    'V',  'journal_original_size',  # Original journal size
+    'V',  'journal_trans_max',  # The maximum number of blocks in a transaction
+    'V',  'journal_magic',      # Journal magic number
+    'V',  'journal_max_batch',  # The maximum number of blocks in a transaction
+    'V',  'journal_max_commit_age',  # Time in seconds of how old an asynchronous commit can be
+    'V',  'journal_max_trans_age',   # Time in seconds of how old a transaction can be
+    'v',  'block_size',         # Block size
+    'v',  'oid_max_size',       # The maximum size of the object id array
+    'v',  'oid_current_size',   # The current size of the object id array
+    'v',  'state',              # State of the partition: valid (1) or error (2)
+    'a12', 'magic',              # Magic String
+    'V',  'hash_code',          # The hash function that is being used to sort names in a directory
+    'v',  'tree_height',        # The current height of the disk tree
+    'v',  'bitmap_number',      # The amount of bitmap blocks needed to address each block of the file system
+    'v',  'version',            # The reiserfs version number
+    'a2', 'reserved',           #
+    'V',  'inode_generation',   # Number of the current inode generation
+  ])
+  SUPERBLOCK_SIZE   = SUPERBLOCK.size
+  SUPERBLOCK_OFFSET = 64 * 1024
+
+  class Superblock
+    # Default cache sizes.
+    DEF_LEAF_NODE_CACHE_SIZE = 50
+
+    attr_reader :rootBlock, :blockSize, :treeHeight, :bitmapNumber, :nblocksInBitmap
+
+    def initialize(stream)
+      raise "Nil stream" if stream.nil?
+      @stream = stream
+
+      # Seek, read & decode the superblock structure
+      @stream.seek(SUPERBLOCK_OFFSET)
+      @sb = SUPERBLOCK.decode(@stream.read(SUPERBLOCK_SIZE))
+
+      # Grab some quick facts & make sure there's nothing wrong. Tight qualification.
+      raise "Invalid Magic String: #{@sb['magic']}" unless isMagic?(@sb['magic'])
+
+      @totalBlocks  = @sb['num_blocks']
+      @freeBlocks   = @sb['num_free_blocks']
+      @rootBlock    = @sb['root_block']
+      @treeHeight   = @sb['tree_height']
+      @bitmapNumber = @sb['bitmap_number']
+      @version      = @sb['version']
+      @state        = @sb['state']
+      @blockSize    = @sb['block_size']
+      @nblocksInBitmap = 8 * @blockSize
+      @oidMaxSize     = @sb['oid_max_size']
+      @oidCurrentSize = @sb['oid_current_size']
+      @superBlock   = SUPERBLOCK_OFFSET / @blockSize
+
+      @leaf_nodes   = LruHash.new(DEF_LEAF_NODE_CACHE_SIZE)
+    end
+
+    def getBitmapBlock(bitmapNum)
+      if bitmapNum == 0
+        blockNum = @superBlock + 1
+      else
+        blockNum = bitmapNum * @nblocksInBitmap
+      end
+
+      readBlockRaw(blockNum)
+    end
+
+    def blockUsed?(blockNum)
+      bitmapNum = blockNum / @nblocksInBitmap
+      raise "Block out of Range" if bitmapNum >= @bitmapNumber
+
+      bitmapBlock      = getBitmapBlock(bitmapNum)
+      bitmapOffset     = blockNum % @nblocksInBitmap
+      bitmapByte       = bitmapOffset / 8
+      bitmapByteOffset = bitmapOffset % 8
+      bits = bitmapBlock[bitmapByte, 1].unpack('B8')[0]
+
+      (bits[bitmapByteOffset, 1] == "1")
+    end
+
+    def readBlockRaw(blockNum)
+      raise "ReiserFS::SuperBlock >> blockNum is nil" if blockNum.nil?
+
+      @stream.seek(blockNum * @blockSize)
+      @stream.read(@blockSize)
+    end
+
+    def readBlock(blockNum)
+      #     return nil if !blockUsed?(blockNum)
+      data = readBlockRaw(blockNum)
+      Block.new(data, blockNum)
+    end
+
+    def getLeafNodes(key)
+      key_s = Utils.dumpKey(key)
+      return @leaf_nodes[key_s] if @leaf_nodes.key?(key_s)
+
+      blocks = []
+      leaves = []
+      blocks << readBlock(@rootBlock)
+      blocks.each do |block|
+        next if block.nil?
+
+        if block.isLeaf?
+          leaves << block
+          next
+        end
+
+        block.findPointers(key).each do |pointer|
+          blocks << readBlock(pointer['block_number'])
+        end
+      end
+
+      @leaf_nodes[key_s] = leaves
+    end
+
+    # Returns free space on file system in bytes.
+    def freeBytes
+      @freeBlocks * @blockSize
+    end
+
+    private
+
+    def isMagic?(magic)
+      ["ReIsErFs", "ReIsEr2Fs", "ReIsEr3Fs"].include?(magic.strip)
+    end
+  end
+end

data/lib/fs/ReiserFS/utils.rb

@@ -0,0 +1,95 @@
+module ReiserFS
+  class Utils
+    def self.dumpKey(key, label = nil)
+      "#{label}:\t\{#{key['directory_id']},#{key['object_id']},#{key['offset']},#{key['type']}\}"
+    end
+
+    def self.typeIsStat?(t)
+      t == 0
+    end
+
+    def self.typeIsDirectory?(t)
+      return true if t == 500
+      return true if t == 3
+      false
+    end
+
+    def self.typeIsDirect?(t)
+      return true if t == -1
+      false
+    end
+
+    def self.typeIsIndirect?(t)
+      return true if t == -2
+      false
+    end
+
+    def self.type2text(t)
+      case t
+      when -1
+        return 'direct'
+      when -2
+        return 'indirect'
+      when 0
+        return 'stat'
+      when 500
+        return 'directory'
+      when 555
+        return 'any'
+      else
+        raise "Unrecognized Type #{t}"
+      end
+    end
+
+    def self.type2integer(t)
+      case t
+      when 0x20000000, 0xFFFFFFFF
+        return -1
+
+      when 0x10000000, 0xFFFFFFFE
+        return -2
+
+      end
+
+      t
+    end
+
+    def self.getKeyDirectoryID(k)
+      k['directory_id']
+    end
+
+    def self.getKeyObjectID(k)
+      k['object_id']
+    end
+
+    def self.getKeyOffset(k)
+      k['offset']
+    end
+
+    def self.getKeyType(k)
+      k['type']
+    end
+
+    def self.compareKeys(a, b, fuzzy = true)
+      # Compare directory IDs
+      return (-1) if a['directory_id'] < b['directory_id']
+      return (+1) if a['directory_id'] > b['directory_id']
+
+      # Compare Object IDs
+      return (-1) if a['object_id'] < b['object_id']
+      return (+1) if a['object_id'] > b['object_id']
+
+      if fuzzy == false
+        # Compare Offsets
+        return (-1) if a['offset'] < b['offset']
+        return (+1) if a['offset'] > b['offset']
+
+        # Compare Types
+        return (-1) if a['type'] < b['type']
+        return (+1) if a['type'] > b['type']
+      end
+
+      0
+    end
+  end
+end

data/lib/fs/VimDatastoreFS/VimDatastoreFS.rb

@@ -0,0 +1,192 @@
+module VimDatastoreFS
+  def fs_init
+    # raise "Object dobj (#{dobj.class.to_s}) is not a MiqVimDataStore object" if !@dobj.kind_of? MiqVimDataStore
+
+    @fsType = "VimDatastoreFS"
+    @fsId = @dobj.name
+    @volName = @dobj.name
+
+    @rootStr = "[#{@dobj.name}]"
+    @dsHash = nil
+  end
+
+  def fs_dirEntries(p)
+    raise "Directory: #{p} does not exist" unless (fi = getFileInfo(p))
+    raise "#{p} is not a directory" unless fi["fileType"] =~ /.*FolderFileInfo/
+    (fi["dirEntries"])
+  end
+
+  def fs_fileExists?(p)
+    (getFileInfo(p).nil?)
+  end
+
+  def fs_fileFile?(p)
+    return false unless (fi = getFileInfo(p))
+    (fi["fileType"] != "FolderFileInfo")
+  end
+
+  def fs_fileDirectory?(p)
+    return false unless (fi = getFileInfo(p))
+    (fi["fileType"] =~ /.*FolderFileInfo/)
+  end
+
+  def fs_fileSize(p)
+    raise "File: #{p} does not exist" unless (fi = getFileInfo(p))
+    (fi["fileSize"])
+  end
+
+  # def fs_fileAtime(p)
+  #     File.atime(p)
+  # end
+  #
+  # def fs_fileCtime(p)
+  #     File.ctime(p)
+  # end
+
+  def fs_fileMtime(p)
+    raise "File: #{p} does not exist" unless (fi = getFileInfo(p))
+    (fi["modification"])
+  end
+
+  # def fs_fileSize_obj(fobj)
+  #     fs_fileSize(fobj.filePath)
+  # end
+  #
+  # def fs_fileAtime_obj(fobj)
+  #     fobj.atime
+  # end
+  #
+  # def fs_fileCtime_obj(fobj)
+  #     fobj.ctime
+  # end
+  #
+  # def fs_fileMtime_obj(fobj)
+  #     fobj.mtime
+  # end
+
+  # def fs_fileOpen(p, mode="r")
+  #     fread = fwrite = fcreate = ftruncate = fappend = false
+  #     mode.delete!("b")
+  #
+  #     case mode[0,1]
+  #     when "r"
+  #         fread     = true
+  #         fwrite    = true if mode[-1,1] == "+"
+  #     when "w"
+  #         fwrite    = true
+  #         fcreate   = true
+  #         ftruncate = true
+  #         fread     = true if mode[-1,1] == "+"
+  #     when "a"
+  #         fwrite    = true
+  #         fcreate   = true
+  #         fappend   = true
+  #         fread     = true if mode[-1,1] == "+"
+  #     else
+  #         raise "Unrecognized open mode: #{mode}"
+  #     end
+  #
+  #     fileRow = nil
+  #     fi = getFileIndex(p)
+  #
+  #     if fi < 0
+  #         #
+  #         # Should we create the file? If not, fail.
+  #         #
+  #         raise "#{p}: No such file" if !fcreate
+  #
+  #         #
+  #         # Create the file if it doesn't exist.
+  #         #
+  #         fileRow = create(p, TYPE_FILE)
+  #     else
+  #         fileRow = @vFentry[fi]
+  #     end
+  #
+  #     fpos = 0
+  #     fsize = @pSize.get(fileRow)
+  #     if ftruncate && fsize != 0
+  #         @pSize.set fileRow, 0
+  #         @pData.set fileRow, Metakit::Bytes.new("", 0)
+  #     elsif fappend
+  #         fpos = fsize
+  #     end
+  #
+  #     return(MkFile.new(p, fileRow, fpos, fread, fwrite))
+  # end # def fs_fileOpen
+
+  # def fs_fileSeek(fobj, offset, whence)
+  #     seekPos = 0
+  #     case whence
+  #         when IO::SEEK_CUR
+  #             seekPos = filePos + amt
+  #         when IO::SEEK_END
+  #             seekPos = fs_fileSize_obj(fobj) + amt
+  #         when IO::SEEK_SET
+  #             seekPos = amt
+  #         else
+  #             raise "Invalid whence value: #{whence}"
+  #     end
+  #     raise "Invalid seek position: #{seekPos}" if seekPos < 0 || seekPos > fs_fileSize_obj(fobj)
+  #
+  #     fobj.filePos = seekPos
+  # end
+
+  # def fs_fileRead(fobj, len)
+  #     dataRef = @pData.ref(fobj.fileRow)
+  #     rb = dataRef.access(fobj.filePos, len)
+  #     fobj.filePos += rb.size
+  #     return(rb.contents)
+  # end
+
+  # def fs_fileClose(fobj)
+  #   return
+  # end
+
+  def dsPath(p)
+    return(p) if p[0, 1] == "["
+    (path2key(normalizePath(p)))
+  end
+
+  def fileInfo(p)
+    (dsHash[dsPath(p)])
+  end
+
+  def reset
+    @dsHash = nil
+  end
+
+  private
+
+  def path2key(p)
+    return(@rootStr) if p == "/"
+    (@rootStr + " " + p[1..-1])
+  end
+
+  def dsHash
+    return(@dsHash) if @dsHash
+    @dsHash = @dobj.dsHash(true)
+    (@dsHash)
+  end
+
+  def method_missing(methodId)
+    raise "#{self.class}: #{methodId.id2name} is not supported"
+  end
+
+  def getFileInfo(p)
+    k = path2key(p)
+    (dsHash[k])
+  end
+
+  # class DsFile
+  #     attr_accessor :filePath, :fileRow, :filePos, :fileRead, :fileWrite
+  #
+  #     def initialize(path, fileRow, fpos, fread, fwrite)
+  #         @filePath  = path
+  #         @fileRow   = fileRow
+  #         @filePos   = fpos
+  #         @fileRead  = fread
+  #         @fileWrite = fwrite
+  #     end
+  # end # class MkFile
+end # module VimDatastoreFS

data/lib/fs/ext3/alloc_bitmap.rb

@@ -0,0 +1,38 @@
+module Ext3
+  class AllocBitmap
+    def initialize(data)
+      raise "Ext3::AllocBitmap.initialize: Nil data" if data.nil?
+      @data = data
+    end
+
+    def isAllocated?(number)
+      getStatus(number)
+    end
+
+    def [](number)
+      getStatus(number)
+    end
+
+    def dump
+      @data.hex_dump
+    end
+
+    private
+
+    def getStatus(number)
+      byte, mask = index(number)
+      @data[byte] & mask == mask
+    end
+
+    def index(number)
+      byte, bit = number.divmod(8)
+      if byte > @data.size - 1
+        msg = "AllocBitmap#index: "
+        msg += "byte index #{byte} is out of range for data[0:#{@data.size - 1}]"
+        raise msg
+      end
+      mask = 128 >> bit
+      return byte, mask
+    end
+  end # class
+end # module

data/lib/fs/ext3/block_pointers_path.rb

@@ -0,0 +1,130 @@
+module Ext3
+  class BlockPointersPath
+    DIRECT_SIZE           = 12
+    SINGLE_INDIRECT_INDEX = 12
+    DOUBLE_INDIRECT_INDEX = 13
+    TRIPLE_INDIRECT_INDEX = 14
+
+    INDEX_TYPES = [:direct, :single_indirect, :double_indirect, :triple_indirect]
+
+    attr_reader :num_indirects, :path, :path_index, :block
+
+    def initialize(num_indirects, block = 0)
+      @num_indirects = num_indirects
+      @single_indirect_size = @num_indirects
+      @double_indirect_size = @num_indirects**2
+      @triple_indirect_size = @num_indirects**3
+
+      @single_indirect_base_size = DIRECT_SIZE
+      @double_indirect_base_size = DIRECT_SIZE + @single_indirect_size
+      @triple_indirect_base_size = DIRECT_SIZE + @single_indirect_size + @double_indirect_size
+
+      self.block = block
+    end
+
+    def direct_index;          @path[0]; end
+
+    def single_indirect_index; @path[1]; end
+
+    def double_indirect_index; @path[2]; end
+
+    def triple_indirect_index; @path[3]; end
+
+    def index_type; INDEX_TYPES[@path_index]; end
+
+    def direct?;          @path_index == 0; end
+
+    def single_indirect?; @path_index == 1; end
+
+    def double_indirect?; @path_index == 2; end
+
+    def triple_indirect?; @path_index == 3; end
+
+    def block=(value)
+      block_to_path(value)
+      @block = value
+    end
+
+    def succ!
+      succ_index(@path_index)
+      @block += 1
+      self
+    end
+
+    def to_s
+      @path.inspect
+    end
+
+    def to_a
+      @path.dup
+    end
+
+    protected
+
+    def succ_index(index)
+      val = (@path[index] += 1)
+      if index == 0
+        raise RangeError if val > TRIPLE_INDIRECT_INDEX
+
+        if val >= SINGLE_INDIRECT_INDEX
+          @path_index += 1
+          @path[@path_index] = 0
+        end
+      elsif val == @num_indirects
+        @path[index] = 0
+        succ_index(index - 1)
+      end
+    end
+
+    def block_to_path(block)
+      raise ArgumentError, "block must be greater than or equal to 0" if block < 0
+      @path = [nil, nil, nil, nil]
+
+      if block < DIRECT_SIZE
+        @path[0] = block
+        @path_index = 0
+        return
+      end
+      block -= DIRECT_SIZE
+
+      if block < @single_indirect_size
+        @path[0] = SINGLE_INDIRECT_INDEX
+        @path[1] = block
+        @path_index = 1
+        return
+      end
+      block -= @single_indirect_size
+
+      if block < @double_indirect_size
+        @path[0] = DOUBLE_INDIRECT_INDEX
+        @path[1], @path[2] = block.divmod(@single_indirect_size)
+        @path_index = 2
+        return
+      end
+      block -= @double_indirect_size
+
+      if block < @triple_indirect_size
+        @path[0] = TRIPLE_INDIRECT_INDEX
+        @path[1], block = block.divmod(@double_indirect_size)
+        @path[2], @path[3] = block.divmod(@single_indirect_size)
+        @path_index = 3
+        return
+      end
+
+      raise ArgumentError, "block outside valid range"
+    end
+
+    def path_to_block
+      case @path_index
+      when 0
+        direct_index
+      when 1
+        @single_indirect_base_size + single_indirect_index
+      when 2
+        @double_indirect_base_size + (single_indirect_index * @single_indirect_size) + double_indirect_index
+      when 3
+        @triple_indirect_base_size + (single_indirect_index * @double_indirect_size) + (double_indirect_index * @single_indirect_size) + triple_indirect_index
+      end
+    end
+  end
+end

data/lib/fs/ext3/directory.rb

@@ -0,0 +1,51 @@
+require 'fs/ext3/file_data'
+require 'fs/ext3/directory_entry'
+
+module Ext3
+  class Directory
+    ROOT_DIRECTORY = 2
+
+    def initialize(sb, inodeNum = ROOT_DIRECTORY)
+      raise "Ext3::Directory.initialize: Nil superblock"   if sb.nil?
+      raise "Ext3::Directory.initialize: Nil inode number" if inodeNum.nil?
+      @sb = sb; @inodeNum = inodeNum
+      @inodeObj = sb.getInode(inodeNum)
+      @data = FileData.new(@inodeObj, @sb).read
+    end
+
+    def globNames
+      @ent_names ||= globEntries.keys.compact.sort
+    end
+
+    def findEntry(name, type = nil)
+      return nil unless globEntries.key?(name)
+
+      newEnt = @sb.isNewDirEnt?
+      globEntries[name].each do |ent|
+        ent.fileType = @sb.getInode(ent.inode).fileModeToFileType unless newEnt
+        return ent if ent.fileType == type || type.nil?
+      end
+      nil
+    end
+
+    private
+
+    def globEntries
+      return @ents_by_name unless @ents_by_name.nil?
+
+      @ents_by_name = {}; p = 0
+      return @ents_by_name if @data.nil?
+      newEnt = @sb.isNewDirEnt?
+      loop do
+        break if p > @data.length - 4
+        break if @data[p, 4].nil?
+        de = DirectoryEntry.new(@data[p..-1], newEnt)
+        raise "Ext3::Directory.globEntries: DirectoryEntry length cannot be 0" if de.len == 0
+        @ents_by_name[de.name] ||= []
+        @ents_by_name[de.name] << de
+        p += de.len
+      end
+      @ents_by_name
+    end
+  end # class
+end # module

data/lib/fs/ext3/directory_entry.rb

@@ -0,0 +1,67 @@
+require 'binary_struct'
+
+module Ext3
+  # ////////////////////////////////////////////////////////////////////////////
+  # // Data definitions.
+
+  DIR_ENTRY_ORIGINAL = BinaryStruct.new([
+    'L',  'inode_val',  # Inode address of metadata.
+    'S',  'entry_len',  # Length of entry.
+    'S',  'name_len',   # Length of name.
+  ])
+  # Here follows the name in ASCII.
+  SIZEOF_DIR_ENTRY_ORIGINAL = DIR_ENTRY_ORIGINAL.size
+
+  DIR_ENTRY_NEW = BinaryStruct.new([
+    'L',  'inode_val',  # Inode address of metadata.
+    'S',  'entry_len',  # Length of entry.
+    'C',  'name_len',   # Length of name.
+    'C',  'file_type',  # Type of file (see FT_ below).
+  ])
+  # Here follows the name in ASCII.
+  SIZEOF_DIR_ENTRY_NEW = DIR_ENTRY_NEW.size
+
+  class DirectoryEntry
+    FT_UNKNOWN    = 0
+    FT_FILE       = 1
+    FT_DIRECTORY  = 2
+    FT_CHAR       = 3
+    FT_BLOCK      = 4
+    FT_FIFO       = 5
+    FT_SOCKET     = 6
+    FT_SYM_LNK    = 7
+
+    attr_reader :inode, :len, :name
+    attr_accessor :fileType
+
+    def initialize(data, new_entry = true)
+      raise "Ext3::DirectoryEntry.initialize: Nil directory entry data" if data.nil?
+      @isNew = new_entry
+      # Both entries are same size.
+      siz = SIZEOF_DIR_ENTRY_NEW
+      @de = @isNew ? DIR_ENTRY_NEW.decode(data[0..siz]) : DIR_ENTRY_ORIGINAL.decode(data[0..siz])
+      # If there's a name get it.
+      @name = data[siz, @de['name_len']] if @de['name_len'] != 0
+      @inode = @de['inode_val']
+      @len = @de['entry_len']
+      @fileType = @de['file_type'] if @isNew
+    end
+
+    def isDir?
+      @fileType == FT_DIRECTORY
+    end
+
+    def isSymLink?
+      @fileType == FT_SYM_LNK
+    end
+
+    def dump
+      out = "\#<#{self.class}:0x#{'%08x' % object_id}>\n"
+      out += "Inode   : #{inode}\n"
+      out += "Len     : #{len}\n"
+      out += "Name len: 0x#{'%04x' % @de['name_len']}\n"
+      out += "Type    : #{fileType}\n" if @isNew
+      out += "Name    : #{name}\n"
+    end
+  end # class
+end # module