lwoggardner / rfusefs Goto Github PK

#!/usr/bin/ruby

require 'rfusefs'

class HelloDir

  def contents(path)
    ['Foo.ISO']
  end

  def file?(path)
    path == '/Foo.ISO'
  end

  def size(path)
    42163830784
  end

  def raw_open(path, mode, rfusefs = nil)
    puts "opening #{path} mode=#{mode}"
    raise unless rfusefs
    if (path == '/Foo.ISO')
      return open("/mnt/fileserv/Foo/Foo.ISO", 'rb')
    end
  end

  def raw_read(path, off, sz, fh)
    puts "reading #{path} off=#{off} sz=#{sz} fh=#{fh}"
    raise unless fh
    raise unless path == '/Foo.ISO'
    fh.seek(off, IO::SEEK_SET)
    return fh.read(sz)
  end

  def raw_close(path, fh)
    puts "closing #{path} fh=#{fh}"
    raise unless fh
    raise unless path == '/Foo.ISO'
    fh.close if fh
  end

end

# Usage: #{$0} mountpoint [mount_options]
FuseFS.main() { |options| HelloDir.new }

#!/home/kazushi/bin/bin/ruby

require 'rubygems'
require 'rfusefs'
require 'fusefs/pathmapper'
require 'fusefs/dirlink'
require 'fusefs/metadir'

HOME = "/home/kazushi/fusetest"

class LoggerDir < FuseFS::FuseDir

  def initialize(dir)
    @base = dir
    @openfiles = Hash.new()
  end

  def can_mkdir?(path)
    true
  end

  def can_rmdir?(path)
    true
  end

  def can_delete?(path)
    true
  end

  def can_write?(path)
    true
  end

  def directory?(path)
    File.directory?(File.join(@base,path))
  end

  def file?(path)
    File.file?(File.join(@base,path))
  end

  def contents(path)
    fn = File.join(@base,path)
    ret = Dir.entries(fn).map { |file|
      file = file.sub(/^#{fn}\/?/,'')
      if ['..','.'].include?(file)
        nil
      else
        file
      end
    }.compact.sort
    p ret
  end

  def mkdir(path)
    puts "######################## MKDIR #{path} #############################"
    Dir.mkdir(unmap(path))
  end

  def size(path)
    puts "######################## SIZE #{path} #############################"
    File.size(unmap(path))
  end

  def rmdir(path)
    ##
    ## hack!!!
    ##    
    puts "######################## REMOVE DIR #{path} #############################"
    `rm -Rf #{unmap(path)}`
  end

  def delete(path)
    ##
    ## hack!!!
    ## 
    puts "######################## DELETE FILE #{path} #############################"
    `rm -f #{unmap(path)}`
  end

  def rename(from_path, to_path, to_fusefs = self)
    puts "######################## RENAME from #{from_path} to #{to_path} #############################"
    File.rename("#{unmap(from_path)}", "#{unmap(to_path)}")
  end

  def touch(path, modtime)
    puts "#{path} has been pushed like a button!"
    ##
    ## hack
    ##
    `touch #{unmap(path)}`
  end

  ##
  ## raw method
  ##
  def raw_open(path,mode,rfusefs)
    puts "######################## RAW_OPEN #{path} #############################"
    real_path = unmap(path)
    file = File.new(real_path, LoggerDir.open_mode(mode))
    @openfiles[path] = file
    return file
  end

  # @!visibility private
  def raw_read(path,off,sz,file=nil)
    puts "###################################### RAW_READ #{path} ##################################"
    file = @openfiles[path]
    file.sysseek(off)
    file.sysread(sz)
  end

  # @!visibility private
  def raw_write(path,offset,sz,buf,file=nil)
    puts "####################################### RAW_WRITE #{path} #{buf} #####################################"
    file = @openfiles[path]
    file.sysseek(offset)
    file.syswrite(buf[0,sz])
  end

  # @!visibility private
  def raw_close(path,file=nil)
    puts "####################################### RAW_CLOSE #{path} #{file} #####################################"
    file = @openfiles.delete(path)
    file.close if file
  end

  def self.open_mode(raw_mode)
    case raw_mode
    when "r"
      "r"
    when "ra"
      "r" #not really sensible..
    when "rw"
      "r+"
    when "rwa"
      "a+"
    when "w"
      "w"
    when "wa"
      "a"
    end
  end

  ##
  ##
  ## Warning private
  ##
  ##
  private 
  def unmap(path)
    "#{@base}#{path}"
  end

end

root = LoggerDir.new(HOME)

unless ARGV.length > 0 && File.directory?(ARGV[0])
  puts "Usage: #{$0} <mountpoint> <mountoptions>"
  exit
end

FuseFS.start(root, *ARGV)

#!/home/kazushi/bin/bin/ruby

##
## execute in /mnt/fuse
##

require 'securerandom'
require 'fileutils'

##
## success
##
n = 100
new_fname = SecureRandom.uuid
value = SecureRandom.random_bytes(n)
File.open(new_fname, "w"){|f|
  ret = f.write(value)
}
FileUtils.touch(new_fname)
File.open(new_fname, "r"){|f|
  ret = f.read(value.size)
  puts "[1] failed write -> touch by FileUtils -> read after mounting" if ret != value
}
File.delete(new_fname)


##
## FAILED!!
## The file becomes empty by touch (utime)
##
new_fname = SecureRandom.uuid
value = SecureRandom.random_bytes(n)
File.open(new_fname, "w"){|f|
  ret = f.write(value)
}
`touch #{new_fname}`
File.open(new_fname, "r"){|f|
  ret = f.read(value.size)
  puts "[2] failed write -> touch by shell command -> read after mounting" if ret != value
}
File.delete(new_fname)