manageiq-smartstate 0.1.0

data/lib/fs/MiqFS/modules/Fat32.rb

@@ -0,0 +1,318 @@
+require 'rufus/lru'
+
+# Fat32 stuff.
+require 'fs/fat32/boot_sect'
+require 'fs/fat32/directory'
+require 'fs/fat32/directory_entry'
+require 'fs/fat32/file_data'
+
+# Fat32 file system interface to MiqFS.
+module Fat32
+  # Default directory cache size.
+  DEF_CACHE_SIZE = 50
+
+  # Members (these become members of an MiqFS instance).
+  attr_accessor :boot_sector, :drive_root, :dir_cache, :cache_hits
+  attr_accessor :rootDirEnt
+
+  # Top level file object.
+  class FileObject
+    include Fat32
+    attr_reader :path, :de, :data, :miqfs, :dirty, :parentDirCluster
+    # NOTE: miqfs will always be an MiqFS instance.
+
+    # fs_fileOpen passes 'self' into .. er, 'this'.
+    def initialize(path, miqfs)
+      @path = path
+      @miqfs = miqfs
+      @dirty = false
+    end
+
+    def open(mode = "r")
+      # Fat32 module methods use miqfs instance accessors to touch @boot_sector.
+      @mode = mode.downcase
+      @de = ifs_getFile(@path, @miqfs)
+      unless @de.nil?
+        raise "File is directory: '#{@path}'" if @de.isDir?
+      end
+      if mode.include?("r")
+        raise "File not found: '#{@path}'" if @de.nil?
+        @data = FileData.new(@de, @miqfs.boot_sector)
+      end
+      if mode.include?("w")
+        @de.delete(@miqfs.boot_sector) unless @de.nil?
+        @de, @parentDirCluster = ifs_putFile(@path, @miqfs)
+        @data = FileData.new(@de, @miqfs.boot_sector)
+      end
+      if mode.include?("a")
+        @de, @parentDirCluster = ifs_putFile(@path, @miqfs) if @de.nil?
+        @data = FileData.new(@de, @miqfs.boot_sector) if @data.nil?
+        @data.read
+      end
+    end
+  end
+
+  # File system interface.
+  def fs_init
+    # puts "Fat32::fs_init(#{@dobj.dInfo.fileName})"
+    self.fsType = "FAT32"
+
+    # Initialize bs & read root dir.
+    @dobj.seek(0, IO::SEEK_SET)
+    self.boot_sector = BootSect.new(@dobj)
+    self.drive_root = Directory.new(@boot_sector)
+    self.dir_cache = LruHash.new(DEF_CACHE_SIZE)
+    self.cache_hits = 0
+
+    # Volume info: Note that fsId is a long in this case (not a UUID)
+    # and volName could be modified by a file in the root with the label attrib set.
+    self.fsId = boot_sector.fsId
+    self.volName = boot_sector.volName
+
+    # Spoof root dir ent - Fat32 has no "." in root.
+    self.rootDirEnt = DirectoryEntry.new
+    rootDirEnt.setAttribute(DirectoryEntry::FA_DIRECTORY)
+    rootDirEnt.firstCluster = 0
+    rootDirEnt.zeroTime
+  end
+
+  # Returns free space on file system in bytes.
+  def fs_freeBytes
+    @boot_sector.freeClusters * @boot_sector.bytesPerCluster
+  end
+
+  #
+  # Directory instance methods.
+  #
+
+  # Returns String array of all names, sans path.
+  def fs_dirEntries(p)
+    # Get path directory.
+    dir = ifs_getDir(p)
+    return nil if dir.nil?
+    dir.globNames
+  end
+
+  # Make a directory. Parent must exist.
+  def fs_dirMkdir(p)
+    de = ifs_getFile(p)
+    raise "Name already exists: #{p}" unless de.nil?
+    parent, name = File.split(p)
+    parent = ifs_getDir(parent)
+    raise "Parent directory must exist: #{p}" if parent.nil?
+    parent.mkdir(name)
+  end
+
+  # Remove a directory.
+  def fs_dirRmdir(p)
+    raise "Directory [#{p}] is not empty" if ifs_getDir(p).globNames.size > 2
+    fs_fileDelete(p)
+  end
+
+  #
+  # File instance methods.
+  #
+
+  # Returns true if name exists, false if not.
+  def fs_fileExists?(p)
+    return true if p == "/" || p == "\\"
+    de = ifs_getFile(p)
+    return false if de.nil?
+    true
+  end
+
+  # Returns true if name is a regular file.
+  # NOTE: If a name isn't a directory, it's always a file - so far...
+  # (FAT32 supports .lnk files at this level, so this should also).
+  def fs_fileFile?(p)
+    de = ifs_getFile(p)
+    return false if de.nil?
+    return false if de.isDir?
+    true
+  end
+
+  # Returns true if name is a directory.
+  def fs_fileDirectory?(p)
+    de = ifs_getFile(p)
+    return false if de.nil?
+    de.isDir?
+  end
+
+  # FAT file systems don't do symbolic links.
+  def fs_isSymLink?(_p)
+    false
+  end
+
+  # Returns size in bytes.
+  def fs_fileSize(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.length
+  end
+
+  # Delete file.
+  def fs_fileDelete(p)
+    de = ifs_getFile(p)
+    return if de.nil?
+    de.delete(@boot_sector)
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileAtime(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.aTime
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileCtime(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.cTime
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileMtime(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.mTime
+  end
+
+  # In these, fobj is a FileObject.
+
+  def fs_fileSize_obj(fobj)
+    fobj.de.length
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileAtime_obj(fobj)
+    fobj.de.aTime
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileCtime_obj(fobj)
+    fobj.de.cTime
+  end
+
+  # Returns a Ruby Time obect.
+  def fs_fileMtime_obj(fobj)
+    fobj.de.mTime
+  end
+
+  # New FileObject instance.
+  # NOTE: FileObject must have access to Fat32 members.
+  # This is kind of like a 'skip this' thing. Fat32 methods
+  # use stuff owned by MiqFS, so this is necessary.
+  def fs_fileOpen(p, mode = "r")
+    fobj = FileObject.new(p, self)
+    fobj.open(mode)
+    fobj
+  end
+
+  # Returns current file position.
+  def fs_fileSeek(fobj, offset, whence)
+    fobj.data.seek(offset, whence)
+  end
+
+  # Returns a Ruby String object.
+  def fs_fileRead(fobj, len)
+    fobj.data.read(len)
+  end
+
+  def fs_fileWrite(fobj, buf, len)
+    fobj.data.write(buf, len)
+  end
+
+  # Write changes & destroy.
+  def fs_fileClose(fobj)
+    fobj.data.close
+    fobj = nil
+  end
+
+  # IFS members: internal file system.
+
+  # Return a DirectoryEntry for a given file or nil if not exist.
+  def ifs_getFile(p, miqfs = nil)
+    # If this is being called from a FileObject instance, then MiqFS owns contained instance members.
+    # If this is being called from an Fat32 module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # If root dir return spoof dir ent.
+    return rootDirEnt if p == "/" || p == "\\"
+
+    # Preprocess path.
+    p = unnormalizePath(p)
+    dir, fil = File.split(p)
+
+    # Look for file in dir, but don't barf if it doesn't exist.
+    # NOTE: if p is a directory that's ok, find it.
+    begin
+      dirObj = ifs_getDir(dir, miqfs)
+      return nil if dirObj.nil?
+      # Do NOT explicitly pass FE_FILE.
+      dirEnt = dirObj.findEntry(fil)
+      return nil if dirEnt.nil?
+    rescue RuntimeError
+      return nil
+    end
+    dirEnt
+  end
+
+  # Create a directory entry.
+  def ifs_putFile(p, miqfs = nil)
+    # If this is being called from a FileObject instance, then MiqFS owns contained instance members.
+    # If this is being called from an Fat32 module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # Preprocess path.
+    p = unnormalizePath(p)
+    dir, fil = File.split(p)
+
+    # Parent directory must exist.
+    dir = ifs_getDir(dir, miqfs)
+    return nil if dir.nil?
+    dir.createFile(fil)
+  end
+
+  # Return a Directory object for a path.
+  # Raise error if path doesn't exist.
+  def ifs_getDir(p, miqfs = nil)
+    # If this is being called from a FileObject instance, then MiqFS owns contained instance members.
+    # If this is being called from an NTFS module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # Wack leading drive.
+    p = unnormalizePath(p)
+
+    # Check for this path in the cache.
+    if miqfs.dir_cache.key?(p)
+      miqfs.cache_hits += 1
+      return Directory.new(miqfs.boot_sector, miqfs.dir_cache[p])
+    end
+
+    # Return root if lone separator.
+    return Directory.new(miqfs.boot_sector) if p == "/" || p == "\\"
+
+    # Get an array of directory names, kill off the first (it's always empty).
+    names = p.split(/[\\\/]/); names.shift
+
+    # Find first cluster of target dir.
+    cluster = miqfs.boot_sector.rootCluster
+    loop do
+      break if names.empty?
+      dir = Directory.new(miqfs.boot_sector, cluster)
+      de = dir.findEntry(names.shift, Directory::FE_DIR)
+      raise "Can't find directory: \'#{p}\'" if de.nil?
+      cluster = de.firstCluster
+    end
+
+    # Save cluster in the cache & return a Directory.
+    miqfs.dir_cache[p] = cluster
+    Directory.new(miqfs.boot_sector, cluster)
+  end
+
+  # Wack leading drive leter & colon.
+  def unnormalizePath(p)
+    p[1] == 58 ? p[2, p.size] : p
+  end
+end

data/lib/fs/MiqFS/modules/Fat32Probe.rb

@@ -0,0 +1,30 @@
+module Fat32Probe
+  def self.probe(dobj)
+    $log.debug("Fat32Probe >> dobj=#{dobj}") if $log
+    unless dobj.kind_of?(MiqDisk)
+      $log.debug "Fat32Probe << FALSE because Disk Object class is not MiqDisk, but is '#{dobj.class}'" if $log
+      return false
+    end
+
+    # Assume FAT32 - read boot sector.
+    dobj.seek(0)
+    bs = dobj.read(512)
+
+    # Check byte 66 for 0x29 (extended signature).
+    if bs[66] != 0x29
+      $log.debug("Fat32Probe << FALSE because there is no extended signature") if $log
+      return false
+    end
+
+    # Check file system label for 'FAT32   '
+    # NOTE: This works for MS tools but maybe not for others.
+    fslabel = bs[82, 8].unpack('a8')[0].strip
+    fat32 = fslabel == 'FAT32'
+    if $log
+      $log.debug("Fat32Probe << TRUE") if fat32
+      $log.debug("Fat32Probe << FALSE because FS label is NOT FAT32, but is '#{fslabel}'") unless fat32
+    end
+
+    fat32
+  end
+end

data/lib/fs/MiqFS/modules/HFSProbe.rb

@@ -0,0 +1,18 @@
+module HFSProbe
+  HFS_SUPER_OFFSET  = 0
+  HFS_MAGIC_OFFSET  = 0
+  HFS_MAGIC_SIZE    = 2
+  HFS_SUPER_MAGIC   = 0x4c4b
+
+  def self.probe(dobj)
+    return(false) unless dobj.kind_of?(MiqDisk)
+
+    # Check for HFS signature in first int.
+    dobj.seek(HFS_SUPER_OFFSET + HFS_MAGIC_OFFSET)
+    magic = dobj.read(HFS_MAGIC_SIZE).unpack('S')[0]
+    raise "HFS is Not Supported" if magic == HFS_SUPER_MAGIC
+
+    # No HFS.
+    false
+  end
+end

data/lib/fs/MiqFS/modules/Iso9660.rb

@@ -0,0 +1,293 @@
+require 'rufus/lru'
+
+# Iso9660 stuff.
+require 'fs/iso9660/boot_sector'
+require 'fs/iso9660/directory_entry'
+require 'fs/iso9660/directory'
+require 'fs/iso9660/file_data'
+
+module Iso9660
+  # Default cache size.
+  DEF_CACHE_SIZE = 50
+
+  PRIMARY_SECTOR  = 16
+  JOLIET_SECTOR   = 17
+  SECTOR_SIZE     = 2048
+
+  # Members (these become members of an MiqFS instance).
+  attr_accessor :boot_sector, :drive_root, :dir_cache, :cache_hits
+
+  # Top level file object.
+  class FileObject
+    include Iso9660
+    attr_reader :path, :de, :data, :miqfs
+    # NOTE: miqfs will always be an MiqFS instance.
+
+    # fs_fileOpen passes 'self' into .. er, 'this'.
+    def initialize(path, miqfs)
+      @path = path
+      @miqfs = miqfs
+    end
+
+    def open(mode = "r")
+      # Iso9660 module methods use miqfs instance accessors to touch @boot_sector.
+      @mode = mode.downcase
+      @de = ifs_getFile(@path, @miqfs)
+      unless @de.nil?
+        raise "File is directory: '#{@path}'" if @de.isDir?
+      end
+      if mode.include?("r")
+        raise "File not found: '#{@path}'" if @de.nil?
+        @data = FileData.new(@de, @miqfs.boot_sector)
+      end
+    end
+  end
+
+  def fs_init
+    self.fsType = "ISO9660"
+
+    # Start by looking for a Joliet volume descriptor after the primary descriptor.
+    found_joliet = false
+    @dobj.seek(JOLIET_SECTOR * SECTOR_SIZE)
+    begin
+      @boot_sector = BootSector.new(@dobj, true)
+      found_joliet = true
+    rescue
+    end
+
+    # If Joliet wasn't found, look for a primary descriptor.
+    unless found_joliet
+      found_primary = false
+      @dobj.seek(PRIMARY_SECTOR * SECTOR_SIZE)
+      loop do
+        begin
+          @boot_sector = BootSector.new(@dobj)
+          found_primary = true
+          break
+        rescue
+        end
+      end
+      raise "Iso9660#fs_init couldn't find primary descriptor." unless found_primary
+    end
+
+    # Set volume id.
+    # @fsId = ... hmmm, how to get the serial number.
+    @volName = @boot_sector.volName
+
+    # Init cache & root.
+    self.dir_cache = LruHash.new(DEF_CACHE_SIZE)
+    self.cache_hits = 0
+    de = DirectoryEntry.new(@boot_sector.rootEntry, @boot_sector.suff)
+    self.drive_root = Directory.new(@boot_sector, de)
+  end
+
+  # Returns free space on file system in bytes.
+  def fs_freeBytes
+    0
+  end
+
+  #
+  # Directory instance methods.
+  #
+
+  # Returns String array of all names, sans path.
+  def fs_dirEntries(p)
+    # Get path directory.
+    dir = ifs_getDir(p)
+    return nil if dir.nil?
+    dir.globNames
+  end
+
+  # These two are not implemented.
+  def fs_dirMkdir(_p)
+    raise "Write functionality is not supported on Iso9660."
+  end
+
+  # Remove a directory.
+  def fs_dirRmdir(_p)
+    raise "Write functionality is not supported on Iso9660."
+  end
+
+  #
+  # File instance methods.
+  #
+
+  # Returns true if name exists, false if not.
+  def fs_fileExists?(p)
+    de = ifs_getFile(p)
+    return false if de.nil?
+    true
+  end
+
+  # Returns true if name is a regular file.
+  def fs_fileFile?(p)
+    de = ifs_getFile(p)
+    return false if de.nil?
+    de.isFile?
+  end
+
+  # Returns true if name is a directory.
+  def fs_fileDirectory?(p)
+    de = ifs_getFile(p)
+    return false if de.nil?
+    de.isDir?
+  end
+
+  # Returns size in bytes.
+  def fs_fileSize(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.fileSize
+  end
+
+  # Delete file.
+  def fs_fileDelete(_p)
+    raise "Write functionality is not supported on Iso9660."
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileAtime(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.date
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileCtime(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.date
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileMtime(p)
+    de = ifs_getFile(p)
+    return nil if de.nil?
+    de.date
+  end
+
+  # Return true if p is a path to a symbolic link.
+  def fs_isSymLink?(p)
+    de = ifs_getFile(p)
+    return false if de.nil?
+    de.isSymLink?
+  end
+
+  # In these, fobj is a FileObject.
+  def fs_fileSize_obj(fobj)
+    fobj.de.fileSize
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileAtime_obj(fobj)
+    fobj.de.date
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileCtime_obj(fobj)
+    fobj.de.date
+  end
+
+  # Returns a Ruby Time obect.
+  def fs_fileMtime_obj(fobj)
+    fobj.de.date
+  end
+
+  # New FileObject instance.
+  # NOTE: FileObject must have access to Iso9660 members.
+  # This is kind of like a 'skip this' thing. Ext3 methods
+  # use stuff owned by MiqFS, so this is necessary.
+  def fs_fileOpen(p, mode = "r")
+    fobj = FileObject.new(p, self)
+    fobj.open(mode)
+    fobj
+  end
+
+  # Returns current file position.
+  def fs_fileSeek(fobj, offset, whence)
+    fobj.data.seek(offset, whence)
+  end
+
+  # Returns a Ruby String object.
+  def fs_fileRead(fobj, len)
+    fobj.data.read(len)
+  end
+
+  def fs_fileWrite(_fobj, _buf, _len)
+    raise "Write functionality is not supported on Iso9660."
+  end
+
+  # Destroy file object.
+  def fs_fileClose(_fobj)
+    fobj = nil
+  end
+
+  # IFS members: internal file system.
+
+  # Return a DirectoryEntry for a given file or nil if not exist.
+  def ifs_getFile(p, miqfs = nil)
+    # If this is being called from a FileObject instance, then MiqFS owns contained instance members.
+    # If this is being called from an Ext3 module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # Preprocess path.
+    p = unnormalizePath(p)
+    dir, fil = File.split(p)
+    # Fix for FB#835: if fil == root then fil needs to be "."
+    fil = "." if fil == "/" || fil == "\\"
+
+    # Look for file in dir, but don't barf if it doesn't exist.
+    # NOTE: if p is a directory that's ok, find it.
+    begin
+      dirObj = ifs_getDir(dir, miqfs)
+      return nil if dirObj.nil?
+      dirEnt = dirObj.findEntry(fil)
+      return nil if dirEnt.nil?
+    rescue RuntimeError
+      return nil
+    end
+    dirEnt
+  end
+
+  # Return a Directory object for a path.
+  # Raise error if path doesn't exist.
+  def ifs_getDir(p, miqfs = nil)
+    # If this is being called from a FileObject instance, then MiqFS owns contained instance members.
+    # If this is being called from an Ext3 module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # Wack leading drive.
+    p = unnormalizePath(p)
+
+    # Check for this path in the cache.
+    if miqfs.dir_cache.key?(p)
+      miqfs.cache_hits += 1
+      return Directory.new(miqfs.boot_sector, DirectoryEntry.new(miqfs.dir_cache[p], miqfs.boot_sector.suff))
+    end
+
+    # Return root if lone separator.
+    return miqfs.drive_root if p == "/" || p == "\\"
+
+    # Get an array of directory names, kill off the first (it's always empty).
+    names = p.split(/[\\\/]/); names.shift
+
+    # Find target dir.
+    de = miqfs.drive_root.myEnt
+    loop do
+      break if names.empty?
+      dir = Directory.new(miqfs.boot_sector, de)
+      de = dir.findEntry(names.shift, Directory::FE_DIR)
+      raise "Can't find directory: \'#{p}\'" if de.nil?
+    end
+
+    # Save dir ent in the cache & return a Directory.
+    # NOTE: This stores only the directory entry data string - not the whole object.
+    miqfs.dir_cache[p] = de.myEnt
+    Directory.new(miqfs.boot_sector, de)
+  end
+
+  # Wack leading drive leter & colon.
+  def unnormalizePath(p)
+    p[1] == 58 ? p[2, p.size] : p
+  end
+end # module

data/lib/fs/MiqFS/modules/Iso9660Probe.rb

@@ -0,0 +1,18 @@
+module Iso9660Probe
+  ISO9660FS_SUPER_OFFSET  = 32768
+  ISO9660FS_MAGIC_OFFSET  = 1
+  ISO9660FS_MAGIC_SIZE    = 5
+  ISO9660FS_MAGIC         = "CD001"
+
+  def self.probe(dobj)
+    return false unless dobj.kind_of?(MiqDisk)
+
+    # Assume ISO9660 - read magic at offset.
+    dobj.seek(ISO9660FS_SUPER_OFFSET + ISO9660FS_MAGIC_OFFSET)
+    magic = dobj.read(ISO9660FS_MAGIC_SIZE)
+    return true if magic == ISO9660FS_MAGIC
+
+    # Not ISO9660.
+    false
+  end
+end