manageiq-smartstate 0.1.0

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

@@ -0,0 +1,315 @@
+# ReiserFS stuff.
+require 'fs/ReiserFS/superblock'
+require 'fs/ReiserFS/directory'
+require 'fs/ReiserFS/directory_entry'
+require 'fs/ReiserFS/file_data'
+
+require 'rufus/lru'
+
+# Reiser file system interface to MiqFS.
+module ReiserFS
+  # Default directory cache size.
+  DEF_CACHE_SIZE = 50
+
+  # Members (these become members of an MiqFS instance).
+  attr_accessor :superblock, :rootDir, :entry_cache, :dir_cache, :cache_hits
+
+  # Top level file object.
+  class FileObject
+    include ReiserFS
+    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")
+      # ReiserFS module methods use miqfs instance accessors to touch @boot_sector.
+      @mode = mode.downcase
+      @de = ifs_getFile(@path, @miqfs)
+      raise "File is directory: '#{@path}'" if @de && @de.isDir?
+
+      if mode.include?("r")
+        raise "File not found: '#{@path}'" if @de.nil?
+        @data = FileData.new(@de, @miqfs.superblock)
+      end
+    end
+
+    def aTime
+      @de.aTime
+    end
+
+    def cTime
+      @de.cTime
+    end
+
+    def mTime
+      @de.mTime
+    end
+
+    def length
+      @de.length
+    end
+  end
+
+  # File system interface.
+  def fs_init
+    self.fsType = "ReiserFS"
+
+    # Initialize bs & read root dir.
+    @dobj.seek(0, IO::SEEK_SET)
+    self.superblock  = Superblock.new(@dobj)
+    self.rootDir     = Directory.new(superblock)
+    self.entry_cache = LruHash.new(DEF_CACHE_SIZE)
+    self.dir_cache   = LruHash.new(DEF_CACHE_SIZE)
+    self.cache_hits  = 0
+  end
+
+  # Returns free space on file system in bytes.
+  def fs_freeBytes
+    @superblock.freeBytes
+  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)
+    raise "Write functionality is not yet supported on ReiserFS."
+  end
+
+  # Remove a directory.
+  def fs_dirRmdir(_p)
+    raise "Write functionality is not yet supported on ReiserFS."
+  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.length
+  end
+
+  # Delete file.
+  def fs_fileDelete(_p)
+    raise "Write functionality is not yet supported on ReiserFS."
+  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
+
+  # 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.length
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileAtime_obj(fobj)
+    fobj.aTime
+  end
+
+  # Returns a Ruby Time object.
+  def fs_fileCtime_obj(fobj)
+    fobj.cTime
+  end
+
+  # Returns a Ruby Time obect.
+  def fs_fileMtime_obj(fobj)
+    fobj.mTime
+  end
+
+  # New FileObject instance.
+  # NOTE: FileObject must have access to Ext3 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 yet supported on ReiserFS."
+    # fobj.data.write(buf, len)
+  end
+
+  # Write changes & destroy.
+  def fs_fileClose(_fobj)
+    # TODO: unrem when write is supported.
+    # 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 Ext3 module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # Preprocess path.
+    p = unnormalizePath(p)
+    dir, fname = File.split(p)
+    # Fix for FB#835: if fname == root then fname needs to be "."
+    fname = "." if fname == "/" || fname == "\\"
+
+    # Check for this file in the cache.
+    cache_name = "#{dir == '/' ? '' : dir}/#{fname}"
+    if miqfs.entry_cache.key?(cache_name)
+      miqfs.cache_hits += 1
+      return miqfs.entry_cache[cache_name]
+    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.
+    begin
+      dirObj = ifs_getDir(dir, miqfs)
+      dirEnt = dirObj.nil? ? nil : dirObj.findEntry(fname)
+    rescue RuntimeError
+      dirEnt = nil
+    end
+
+    miqfs.entry_cache[cache_name] = dirEnt
+  end
+
+  # Create a directory entry.
+  def ifs_putFile(p, miqfs = nil)
+    raise "Write functionality is not yet supported on ReiserFS."
+
+    # Commented out for now to avoid unreachable code
+    #
+    # # If this is being called from a FileObject instance, then MiqFS owns contained instance members.
+    # # If this is being called from an ReiserFS 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.
+    # dirObj = ifs_getDir(dir, miqfs)
+    # return nil if dir.nil?
+    # dirObj.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 ReiserFS module method, then self owns contained instance members.
+    miqfs = self if miqfs.nil?
+
+    # Wack leading drive.
+    p = unnormalizePath(p)
+
+    # Get an array of directory names, kill off the first (it's always empty).
+    names = p.split(/[\\\/]/)
+    names.shift
+
+    dir = ifs_getDirR(names, miqfs)
+    raise "Directory '#{p}' not found" if dir.nil?
+    dir
+  end
+
+  # Return Directory recursively for given directory or nil if not exist.
+  def ifs_getDirR(names, miqfs)
+    return miqfs.rootDir if names.empty?
+
+    # Check for this path in the cache.
+    fname = names.join('/')
+    if miqfs.dir_cache.key?(fname)
+      miqfs.cache_hits += 1
+      return miqfs.dir_cache[fname]
+    end
+
+    name = names.pop
+    pdir = ifs_getDirR(names, miqfs)
+    return nil if pdir.nil?
+
+    key = pdir.findKey(name)
+    return nil if key.nil?
+
+    dir = Directory.new(miqfs.superblock, key)
+    return nil if dir.nil?
+
+    miqfs.dir_cache[fname] = dir
+  end
+
+  # Wack leading drive leter & colon.
+  def unnormalizePath(p)
+    p[1] == 58 ? p[2, p.size] : p
+  end
+end

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

@@ -0,0 +1,42 @@
+module ReiserFSProbe
+  REISERFS_DISK_OFFSET_NEW = 64 * 1024
+  REISERFS_DISK_OFFSET_OLD =  8 * 1024
+
+  REISERFS_SUPER_SIZE   = 204
+
+  REISERFS_MAGIC_OFFSET = 52
+  REISERFS_MAGIC_SIZE   = 10
+
+  REISERFS_MAGIC1 = "ReIsErFs"
+  REISERFS_MAGIC2 = "ReIsEr2Fs"
+  REISERFS_MAGIC3 = "ReIsEr3Fs"
+
+  def self.probe(dobj)
+    return false unless dobj.kind_of?(MiqDisk)
+
+    return true if ReiserFSProbe.isMagic?(ReiserFSProbe.getMagic(dobj, REISERFS_DISK_OFFSET_NEW))
+    return true if ReiserFSProbe.isMagic?(ReiserFSProbe.getMagic(dobj, REISERFS_DISK_OFFSET_OLD))
+
+    # No ReiserFS.
+    false
+  end
+
+  def self.getMagic(dobj, offset)
+    # Assume ReiserFS - read superblock at desired offset.
+    dobj.seek(offset) # new disk start offset.
+    sb = dobj.read(REISERFS_SUPER_SIZE)
+
+    return nil if sb.nil?
+    return nil if sb.size < (REISERFS_MAGIC_OFFSET + REISERFS_MAGIC_SIZE - 1)
+
+    # Check magic at offset 52 for accepted ReiserFS identifiers.
+    magic = sb[REISERFS_MAGIC_OFFSET, REISERFS_MAGIC_SIZE].strip
+  end
+
+  def self.isMagic?(magic)
+    return true if magic == REISERFS_MAGIC1
+    return true if magic == REISERFS_MAGIC2
+    return true if magic == REISERFS_MAGIC3
+    false
+  end
+end

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

@@ -0,0 +1,18 @@
+module UnionFSProbe
+  UNIONFS_SUPER_OFFSET  = 1024
+  UNIONFS_MAGIC_OFFSET  = 52
+  UNIONFS_MAGIC_SIZE    = 4
+  UNIONFS_MAGIC         = 0xf15f083d
+
+  def self.probe(dobj)
+    return false unless dobj.kind_of?(MiqDisk)
+
+    # Assume UnionFS - read magic at offset.
+    dobj.seek(UNIONFS_SUPER_OFFSET + UNIONFS_MAGIC_OFFSET)
+    magic = dobj.read(UNIONFS_MAGIC_SIZE).unpack('L')
+    raise "UnionFS is Not Supported" if magic == UNIONFS_MAGIC
+
+    # No UnionFS.
+    false
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'uri'
+require 'net/http'
+
+require 'fs/MiqFS/modules/WebDAVFile'
+
+module WebDAV
+  attr_reader :guestOS
+
+  def fs_init
+    @fsType = "WebDAV"
+    @guestOS = @dobj.guest_os
+
+    @uri = URI(@dobj.uri.to_s)
+    @headers = @dobj.headers || {}
+
+    @connection = Net::HTTP.start(
+      @uri.host,
+      @uri.port,
+      @dobj.http_options
+    )
+  end
+
+  def fs_unmount
+    @connection.finish
+  end
+
+  def freeBytes
+    0
+  end
+
+  def fs_dirEntries(_path)
+    raise NotImplementedError
+  end
+
+  def fs_fileExists?(path)
+    response = WebDAVFile.head_response(@connection, remote_uri(path), @headers)
+    case response
+    when Net::HTTPOK
+      return true
+    when Net::HTTPNotFound
+      return false
+    else
+      raise Errno::EINVAL
+    end
+  end
+
+  def fs_fileDirectory?(path)
+    # TODO: implement proper check for being a directory
+    path += '/' unless path.end_with?('/')
+    fs_fileExists?(path)
+  end
+
+  def fs_fileFile?(_path)
+    raise NotImplementedError
+  end
+
+  def fs_fileSize(path)
+    WebDAVFile.file_size(remote_uri(path))
+  end
+
+  def fs_fileSize_obj(fobj)
+    fobj.size
+  end
+
+  def fs_fileAtime(_path)
+    raise NotImplementedError
+  end
+
+  def fs_fileCtime(_path)
+    raise NotImplementedError
+  end
+
+  def fs_fileMtime(_path)
+    raise NotImplementedError
+  end
+
+  def fs_fileAtime_obj(_fobj)
+    raise NotImplementedError
+  end
+
+  def fs_fileCtime_obj(_fobj)
+    raise NotImplementedError
+  end
+
+  def fs_fileMtime_obj(_fobj)
+    raise NotImplementedError
+  end
+
+  def fs_fileOpen(path, mode = "r")
+    raise Errno::EACCES unless mode == 'r'
+    WebDAVFile.new(remote_uri(path), @dobj.http_options, @headers)
+  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
+
+  def fs_fileWrite(_fobj, _buf, _len)
+    raise Errno::EACCES
+  end
+
+  def fs_dirMkdir(_path)
+    raise Errno::EACCES
+  end
+
+  def dirRmdir(_path)
+    raise Errno::EACCES
+  end
+
+  def fs_fileDelete(_path)
+    raise Errno::EACCES
+  end
+
+  private
+
+  def remote_uri(path)
+    @uri.merge(@uri.path + path)
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'net/http'
+
+class WebDAVFile
+  def initialize(uri, http_options, headers)
+    @uri = uri
+    @headers = headers
+    @offset = 0
+    @connection = Net::HTTP.start(
+      @uri.host,
+      @uri.port,
+      http_options
+    )
+  end
+
+  def seek(offset, whence)
+    case whence
+    when IO::SEEK_SET
+      @offset = offset
+    when IO::SEEK_CUR
+      @offset += offset
+    else
+      raise NotImplementedError
+    end
+  end
+
+  def read(length)
+    @next_offset = @offset + length
+
+    request = Net::HTTP::Get.new(@uri, @headers)
+    request.set_range(@offset, @next_offset)
+
+    response = @connection.request(request)
+
+    case response
+    when Net::HTTPOK
+      # In this case (server not supporting ranges) the communication
+      # is highly inefficient.
+      data = response.body[@offset..@next_offset]
+    when Net::HTTPPartialContent
+      data = response.body
+    else
+      raise Errno::ENOENT
+    end
+
+    @offset = @next_offset
+    data
+  end
+
+  def size
+    self.class.file_size(@connection, @uri, @headers)
+  end
+
+  def self.head_response(connection, uri, headers)
+    request = Net::HTTP::Head.new(uri, headers)
+    connection.request(request)
+  end
+
+  def self.file_size(connection, uri, headers)
+    response = head_response(connection, uri, headers)
+    raise Errno::ENOENT unless response.kind_of?(Net::HTTPOK)
+    raise Errno::EINVAL if response["content-length"].nil?
+    response["content-length"].to_i
+  end
+
+  def close
+    @connection.finish
+  end
+end