manageiq-smartstate 0.1.0

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

@@ -0,0 +1,105 @@
+module LocalFS
+  def fs_init
+    self.fsType = "LocalFS"
+
+    if @dobj && @dobj.root
+      @root = @dobj.root
+      raise "LocalFS: root directory does not exist, #{@root}" unless File.directory?(@root)
+    else
+      @root = nil
+    end
+
+    @cwd = Dir.pwd
+  end
+
+  def freeBytes
+    (0)
+  end
+
+  def fs_dirEntries(p)
+    Dir.entries(internalPath(p))
+  end
+
+  def fs_dirMkdir(p)
+    Dir.mkdir(internalPath(p))
+  end
+
+  def dirRmdir(p)
+    Dir.rmdir(internalPath(p))
+  end
+
+  def fs_fileDelete(p)
+    File.delete(internalPath(p))
+  end
+
+  def fs_fileExists?(p)
+    File.exist?(internalPath(p))
+  end
+
+  def fs_fileFile?(p)
+    File.file?(internalPath(p))
+  end
+
+  def fs_fileDirectory?(p)
+    File.directory? internalPath((p))
+  end
+
+  def fs_fileSize(p)
+    File.size(internalPath(p))
+  end
+
+  def fs_fileSize_obj(fobj)
+    fobj.stat.size
+  end
+
+  def fs_fileAtime(p)
+    File.atime(internalPath(p))
+  end
+
+  def fs_fileCtime(p)
+    File.ctime(internalPath(p))
+  end
+
+  def fs_fileMtime(p)
+    File.mtime(internalPath(p))
+  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")
+    File.new(internalPath(p), mode)
+  end
+
+  def fs_fileSeek(fobj, offset, whence)
+    fobj.seek(offset, whence)
+  end
+
+  def fs_fileRead(fobj, len)
+    fobj.read(len)
+  end
+
+  def fs_fileWrite(fobj, buf, len)
+    return(fobj.write(buf))     if buf.length == len
+    return(fobj.write(buf[0, len])) if buf.length > len
+    raise "LocalFS.fs_fileWrite: attempt to write passed the end of buffer"
+  end
+
+  def fs_fileClose(fobj)
+    fobj.close
+  end
+
+  def internalPath(p)
+    return(File.join(@root, p)) if @root
+    (p)
+  end
+end

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

@@ -0,0 +1,287 @@
+require 'rufus/lru'
+
+# NTFS stuff.
+require 'fs/ntfs/boot_sect'
+
+# NTFS file system interface to MiqFS.
+module NTFS
+  # Default index cache size
+  DEF_CACHE_SIZE = 50
+
+  # Members (these become members of an MiqFS instance).
+  attr_accessor :boot_sector, :drive_root, :index_cache, :cache_hits
+
+  # Top level file object.
+  class FileObject
+    include NTFS
+    attr_reader :path, :din, :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 = "rb")
+      # NTFS module methods use miqfs instance accessors to
+      # touch @boot_sector, @drive_root, @index_cache and @cache_hits
+      # (and any other NTFS members that may come later)
+      @din = ifs_getFile(@path, @miqfs)
+      raise "File not found: '#{@path}'"    if @din.nil?
+      mft_entry = @din.resolve(@miqfs.boot_sector)
+      raise "File is directory: '#{@path}'" if @din.isDir?
+      @data = mft_entry.attributeData || AttribData.new("", 0)
+    end
+
+    def seek(offset, method = IO::SEEK_SET)
+      @data.seek(offset, method)
+    end
+  end
+
+  # File system interface.
+  def fs_init
+    self.fsType = "NTFS"
+
+    # Initialize Boot Sector
+    @dobj.seek(0, IO::SEEK_SET)
+    self.boot_sector = BootSect.new(@dobj)
+    boot_sector.setup
+    self.drive_root  = boot_sector.rootDir
+
+    # Init cache.
+    self.index_cache = LruHash.new(DEF_CACHE_SIZE)
+    self.cache_hits  = 0
+
+    # Expose fsId & volName.
+    @fsId, @volName = getVolumeInfo
+  end
+
+  def getVolumeInfo
+    vi = boot_sector.volumeInfo
+    volName = vi["name"]
+    fsId    = vi["objectId"]
+    return fsId, volName
+  end
+
+  # Returns free space on file system in bytes.
+  def fs_freeBytes
+    boot_sector.freeBytes
+  end
+
+  # In these, p is a path.
+
+  # Returns String array of all names, sans path.
+  def fs_dirEntries(p)
+    # Get path index (directory).
+    index = ifs_getDir(p)
+    return nil if index.nil?
+    index.globNames
+  end
+
+  # Returns true if name exists, false if not.
+  def fs_fileExists?(p)
+    file = ifs_getFile(p)
+    return false if file.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...
+  # (it could be a reparse point [a.k.a. hard link], but that's for later).
+  def fs_fileFile?(p)
+    file = ifs_getFile(p)
+    return false if file.nil?
+    file.resolve(boot_sector)
+    return false if file.isDir?
+    true
+  end
+
+  # Returns true if name is a directory.
+  def fs_fileDirectory?(p)
+    file = ifs_getFile(p)
+    return false if file.nil?
+    file.resolve(boot_sector)
+    return true if file.isDir?
+    false
+  end
+
+  # Returns true if name is a symbolic link.
+  def fs_isSymLink?(_p)
+    false
+  end
+
+  # Returns size in bytes.
+  def fs_fileSize(p)
+    file = ifs_getFile(p)
+    return nil if file.nil?
+    file.afn.length
+  end
+
+  # Returns Ruby Time object.
+  # NOTE: I *did* find files with 0 time, but they should never appear in this context.
+  def fs_fileAtime(p)
+    file = ifs_getFile(p)
+    return nil if file.nil?
+    file.afn.aTime
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileCtime(p)
+    file = ifs_getFile(p)
+    return nil if file.nil?
+    file.afn.cTime
+  end
+
+  # Returns Ruby Time object.
+  def fs_fileMtime(p)
+    file = ifs_getFile(p)
+    return nil if file.nil?
+    file.afn.mTime
+  end
+
+  # In these, fobj is a FileObject, a DIN and AD.
+  # AD is not valid until opened. All afn members
+  # except permissions can be picked up from afn
+  # before resolving data (opening file).
+
+  # A FileObject is basically just :din, :data
+
+  # Returns a Ruby Time object.
+  def fs_fileAtime_obj(fobj)
+    fobj.din.afn.aTime
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileCtime_obj(fobj)
+    fobj.din.afn.cTime
+  end
+
+  # Returns a Ruby Time obect.
+  def fs_fileMtime_obj(fobj)
+    fobj.din.afn.mTime
+  end
+
+  # File size the faster way.
+  def fs_fileSize_obj(fobj)
+    fobj.din.afn.length
+  end
+
+  # New FileObject instance.
+  # NOTE: FileObject must have access to NTFS members.
+  # This is kind of like a 'skip this' thing. NTFS methods
+  # use stuff owned by MiqFS, so this is necessary.
+  def fs_fileOpen(p, _mode = "r")
+    fobj = FileObject.new(p, self)
+    fobj.open
+    fobj
+  end
+
+  # Seek to the requested position
+  def fs_fileSeek(fobj, offset, whence)
+    fobj.seek(offset, whence)
+  end
+
+  # Returns a Ruby String object.
+  def fs_fileRead(fobj, len)
+    return nil if fobj.data.nil?
+    fobj.data.read(len)
+  end
+
+  # Unless there's a way to explicitly destroy an object there's nothing to do here.
+  def fs_fileClose(_fobj)
+    fobj = nil
+  end
+
+  # IFS members: internal file system.
+
+  # Return DirectoryIndexNode for a given file or nil if not exist.
+  def ifs_getFile(p, miqfs = nil)
+    $log.debug "NTFS.ifs_getFile >> p=#{p}" if $log && $log.debug?
+
+    # 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).downcase
+
+    # Get directory & file as separate strings.
+    dir = p.split(/[\\\/]/)
+    fname = dir[dir.size - 1]
+    fname = "." if fname.nil? # Special case: if fname is nil then dir is root.
+    dir = dir.size > 2 ? dir[0...dir.size - 1].join('/') : '/'
+
+    # Check for this file in the cache.
+    cache_name = "#{dir == '/' ? '' : dir}/#{fname}"
+    if miqfs.index_cache.key?(cache_name)
+      miqfs.cache_hits += 1
+      file = miqfs.index_cache[cache_name]
+      $log.debug "NTFS.ifs_getFile << (cached) p=#{p} din=#{file}" if $log && $log.debug?
+      return file
+    end
+
+    # Look for file in dir, but don't error if it doesn't exist.
+    # NOTE: if p is a directory that's ok, find it.
+    file = nil
+    index = ifs_getDir(dir, miqfs)
+    unless index.nil?
+      $log.debug "NTFS.ifs_getFile -- getting din for #{fname} in <#{index.class.name}>" if $log && $log.debug?
+      file = index.find(fname)
+    end
+
+    $log.debug "NTFS.ifs_getFile << p=#{p} din=#{file}" if $log && $log.debug?
+    miqfs.index_cache[cache_name] = file
+  end
+
+  # Return an index of a path.
+  # Raise error if path doesn't exist.
+  def ifs_getDir(p, miqfs = nil)
+    $log.debug "NTFS.ifs_getDir >> p=#{p}" if $log && $log.debug?
+
+    # 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).downcase
+
+    # Get an array of directory names, kill off the first (it's always empty).
+    names = p.split(/[\\\/]/)
+    names.shift
+
+    # Get the index for this directory
+    index = ifs_getIndex(names, miqfs)
+    $log.debug "NTFS.ifs_getDir << #{index.nil? ? "Directory not found " : ""}p=#{p}" if $log && $log.debug?
+    index
+  end
+
+  # Return DirectoryIndexNode for given directory or nil if not exist.
+  def ifs_getIndex(names, miqfs)
+    return miqfs.drive_root if names.empty?
+
+    # Check for this path in the cache.
+    fname = names.join('/')
+    if miqfs.index_cache.key?(fname)
+      miqfs.cache_hits += 1
+      return miqfs.index_cache[fname]
+    end
+
+    name = names.pop
+    index = ifs_getIndex(names, miqfs)
+    return nil if index.nil?
+
+    din = index.find(name)
+    return nil if din.nil?
+
+    index = din.resolve(miqfs.boot_sector).indexRoot
+    return nil if index.nil?
+
+    miqfs.index_cache[fname] = index
+  end
+
+  # Wack leading drive leter & colon.
+  def unnormalizePath(p)
+    p[1] == 58 ? p[2, p.size] : p
+  end
+end

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

@@ -0,0 +1,21 @@
+module NTFSProbe
+  def self.probe(dobj)
+    $log.debug("NTFSProbe >> dobj=#{dobj}") if $log
+    unless dobj.kind_of?(MiqDisk)
+      $log.debug "NTFSProbe << FALSE because Disk Object class is not MiqDisk, but is '#{dobj.class}'" if $log
+      return false
+    end
+
+    # Check for oem name = NTFS.
+    dobj.seek(3)
+    oem = dobj.read(8).unpack('a8')[0].strip
+
+    ntfs = oem == 'NTFS'
+    if $log
+      $log.debug("NTFSProbe << TRUE") if ntfs
+      $log.debug("NTFSProbe << FALSE because OEM Name is not NTFS, but is '#{oem}'") unless ntfs
+    end
+
+    ntfs
+  end
+end

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

@@ -0,0 +1,155 @@
+module NativeFS
+  MOUNT_DIR = "/miq_mounts"
+  VOL_ID    = "/KNOPPIX/lib/udev/vol_id"
+
+  def self.supported?(dobj)
+    devNode = dobj.devFile
+    fsType = `fstype #{devNode}`.chomp
+    $log.debug "NativeFS.supported?: devNode = #{devNode}, fsType = #{fsType}" if $log.debug?
+
+    return(false) if fsType.empty? || fsType == "auto" || fsType == "swap"
+    (true)
+  end
+
+  def fs_init
+    dInfo = @dobj.dInfo
+    raise "NativeFS: disk is not a local device" unless @dobj.devFile
+
+    @devNode  = @dobj.devFile
+
+    self.fsType = `fstype #{@devNode}`.chomp
+    raise "NativeFS: cannot determine filesystem type for: #{@devNode}" if fsType.empty?
+
+    @volName  = `#{VOL_ID} -l #{@devNode}`.chomp
+    @fsId   = `#{VOL_ID} -u #{@devNode}`.chomp
+
+    if dInfo.lvObj
+      lv = "#{dInfo.lvObj.vgObj.vgName}-#{dInfo.lvObj.lvName}"
+      @mountPoint = File.join(MOUNT_DIR, lv)
+      @devNode  = File.join("/dev/mapper", lv)
+    else
+      @mountPoint = File.join(MOUNT_DIR, File.basename(@devNode))
+    end
+
+    if $log.debug?
+      $log.debug "NativeFS.fs_init: devNode   = #{@devNode}"
+      $log.debug "NativeFS.fs_init: fsType    = #{fsType}"
+      $log.debug "NativeFS.fs_init: volName     = #{@volName}"
+      $log.debug "NativeFS.fs_init: fsId      = #{@fsId}"
+    end
+
+    return if isMounted?(@devNode)
+    system("mkdir", "-p", @mountPoint)
+    $log.debug "NativeFS.fs_init: mounting #{@devNode} on #{@mountPoint}" if $log.debug?
+    unless system("mount", @devNode, @mountPoint)
+      raise "NativeFS: Could not mount #{@devNode} on #{@mountPoint}, exit status: #{$?.exitstatus}"
+    end
+  end
+
+  def fs_umount
+    raise "NativeFS: #{@devNode} is not mounted" if @mountPoint.nil?
+    $log.debug "NativeFS.fs_umount: unmounting #{@mountPoint}" if $log.debug?
+    unless system("umount", @mountPoint)
+      raise "NativeFS: Could not unmount #{@devNode} from #{@mountPoint}, exit status: #{$?.exitstatus}"
+    end
+    @mountPoint = nil
+  end
+
+  def freeBytes
+    raise "NativeFS: #{@devNode} is not mounted" if @mountPoint.nil?
+    (`df -lPB1 | grep '#{@mountPoint}$' | awk '{ print $4 }'`.chomp.to_i)
+  end
+
+  def fs_dirEntries(p)
+    Dir.entries(internalPath(p))
+  end
+
+  def fs_dirMkdir(p)
+    Dir.mkdir(internalPath(p))
+  end
+
+  def dirRmdir(p)
+    Dir.rmdir(internalPath(p))
+  end
+
+  def fs_fileDelete(p)
+    File.delete(internalPath(p))
+  end
+
+  def fs_fileExists?(p)
+    File.exist?(internalPath(p))
+  end
+
+  def fs_fileFile?(p)
+    File.file?(internalPath(p))
+  end
+
+  def fs_fileDirectory?(p)
+    File.directory? internalPath((p))
+  end
+
+  def fs_fileSize(p)
+    File.size(internalPath(p))
+  end
+
+  def fs_fileSize_obj(fobj)
+    fobj.stat.size
+  end
+
+  def fs_fileAtime(p)
+    File.atime(internalPath(p))
+  end
+
+  def fs_fileCtime(p)
+    File.ctime(internalPath(p))
+  end
+
+  def fs_fileMtime(p)
+    File.mtime(internalPath(p))
+  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")
+    File.new(internalPath(p), mode)
+  end
+
+  def fs_fileSeek(fobj, offset, whence)
+    fobj.seek(offset, whence)
+  end
+
+  def fs_fileRead(fobj, len)
+    fobj.read(len)
+  end
+
+  def fs_fileWrite(fobj, buf, len)
+    return(fobj.write(buf))     if buf.length == len
+    return(fobj.write(buf[0, len])) if buf.length > len
+    raise "NativeFS.fs_fileWrite: attempt to write passed the end of buffer"
+  end
+
+  def fs_fileClose(fobj)
+    fobj.close
+  end
+
+  def internalPath(p)
+    raise "NativeFS: #{@devNode} is not mounted" if @mountPoint.nil?
+    (File.join(@mountPoint, p))
+  end
+
+  def isMounted?(dev)
+    `mount`.each { |ml| return(true) if ml.split(" ", 2)[0] == dev }
+    (false)
+  end
+  private :isMounted?
+end

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

@@ -0,0 +1,17 @@
+module ReFSProbe
+  FS_SIGNATURE  = [0x00, 0x00, 0x00, 0x52, 0x65, 0x46, 0x53, 0x00] # ...ReFS.
+
+  def self.probe(dobj)
+    $log.debug "ReFSProbe >> dobj=#{dobj}"  if $log
+    return false  unless dobj.kind_of?(MiqDisk)
+
+    dobj.seek(0, IO::SEEK_SET)
+    magic = dobj.read(FS_SIGNATURE.size).unpack('C*')
+
+    # Check for ReFS signature
+    raise "ReFS is Not Supported" if magic == FS_SIGNATURE
+
+    # No ReFS
+    false
+  end
+end

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

@@ -0,0 +1,79 @@
+module RealFS
+  attr_reader :guestOS
+
+  def fs_init
+    case Sys::Platform::IMPL
+    when :mswin, :mingw
+      self.fsType = "NTFS"
+      @guestOS = "Windows"
+    when :linux
+      self.fsType = `df -lT / | tail -1 | awk '{ print $2 }'`
+      @guestOS = "Linux"
+    when :macosx
+    end
+  end
+
+  def fs_dirEntries(p)
+    Dir.entries(p)
+  end
+
+  def fs_fileExists?(p)
+    File.exist?(p)
+  end
+
+  def fs_fileFile?(p)
+    File.file?(p)
+  end
+
+  def fs_fileDirectory?(p)
+    File.directory?(p)
+  end
+
+  def fs_fileSize(p)
+    File.size(p)
+  end
+
+  def fs_fileSize_obj(fobj)
+    fobj.stat.size
+  end
+
+  def fs_fileAtime(p)
+    File.atime(p)
+  end
+
+  def fs_fileCtime(p)
+    File.ctime(p)
+  end
+
+  def fs_fileMtime(p)
+    File.mtime(p)
+  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")
+    File.new(p, mode)
+  end
+
+  def fs_fileSeek(fobj, offset, whence)
+    fobj.seek(offset, whence)
+  end
+
+  def fs_fileRead(fobj, len)
+    fobj.read(len)
+  end
+
+  def fs_fileClose(fobj)
+    fobj.close
+  end
+end

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

@@ -0,0 +1,6 @@
+module RealFSProbe
+  def self.probe(dobj)
+    return(true) if dobj.to_s == "test_disk"
+    (false)
+  end
+end

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

@@ -0,0 +1,18 @@
+module Reiser4Probe
+  REISER4_MASTER_OFFSET = 65536
+  REISER4_MAGIC_OFFSET  = REISER4_MASTER_OFFSET
+  REISER4_MAGIC_SIZE    = 10
+  REISER4_MAGIC         = "ReIsEr4"
+
+  def self.probe(dobj)
+    return(false) unless dobj.kind_of?(MiqDisk)
+
+    # Assume Reiser4 - read magic at offset.
+    dobj.seek(REISER4_MAGIC_OFFSET)
+    magic = dobj.read(REISER4_MAGIC_SIZE).strip
+    raise "Reiser4 is Not Supported" if magic == REISER4_MAGIC
+
+    # No Reiser4.
+    false
+  end
+end