rfuse_symbolic_fs 0.0.1

data/bin/rfuse_symbolic_fs

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rfuse_symbolic_fs'
+require 'rfuse_symbolic_fs_opts'
+
+options = RFuseSymbolicFSOpts.parse(ARGV)
+
+filesystem = RFuseSymbolicFS.new(options)
+FuseFS.set_root( filesystem )
+
+# Mount under a directory given on the command line.
+FuseFS.mount_under options.mountpoint
+FuseFS.run
+

data/lib/amaras_fs.rb

@@ -0,0 +1,144 @@
+require 'pp'
+
+class AmarasFS
+
+   def initialize(*args)
+      start_time = Time.now
+      begin
+         @root = args[0]
+   
+         @partitions = Array.new
+         (1...(args.size)).each_with_index do |x, index|
+            @partitions << args[x]
+            #puts args[x]
+         end
+         puts
+         puts
+
+         puts
+         puts "Starting Linking"
+         @partitions.each do |y|
+            build_links( @root, y )         
+         end
+   
+   
+   
+      rescue => e
+         puts
+         puts "ERROR caught Exception"
+         puts $!
+         puts e.inspect
+         puts e.backtrace
+         puts 
+      end
+      puts "Run Time #{start_time - Time.now}"
+
+   end
+
+
+   private
+
+   def build_links( root, y , spacer=' ')
+         #puts "build_links( root, y )"
+         puts "#{spacer}build_links( #{root}, #{y})"
+      
+         files = Dir.glob(y + '/*')
+
+         pp files
+
+         #puts "Iterating of SubFiles"
+         files.each do |x|
+
+            #TODO validation that link does not already exist
+
+            new_link = x.dup
+            new_link[y] = "" 
+            new_link = root + new_link
+
+            puts 
+            puts "#{spacer}Thinking about linking #{new_link} "
+            #puts " sub file #{x}" 
+
+            #Verify that new_link does not exists
+            if not File.exist?( new_link )
+               puts "#{spacer}Mode :1 INFO   : File.symlink(#{x}, #{new_link} )"
+               File.symlink(x, new_link)
+
+            elsif ( ( File.symlink?(new_link)) and ( File.readlink(new_link) == x))
+               #readlink rasies exception if called on non links so check is a link first
+               #Link exists but points to location we tried to set
+               puts "#{spacer}Mode :2 INFO   : Link Exists & correct"
+            elsif ( ( File.symlink?(new_link)) and  ( not File.readlink(new_link) == x ))
+               test_folder(new_link)
+               
+               puts "#{spacer}Mode :3 ERROR   : #{new_link} already exists"
+               puts "#{spacer}                  This section requires programming"
+               
+               current_pointer =  File.readlink(new_link)
+               
+               puts "current_pointer #{current_pointer}"
+               puts "                #{root}"
+               puts "                #{x}"
+               puts "                #{y}"
+               
+               pos = current_pointer.rindex(File::SEPARATOR)
+               extra_bit = current_pointer[pos...(current_pointer.size)]
+
+               puts "extra_bit #{extra_bit}"
+
+               #/A/1/x
+               #/A/1/Y
+               #/B/1/z
+               #
+               # current_pointer = /A/1
+
+               #current pointer already has the extra_bit
+               new_root                = root + extra_bit               
+               next_pointer            = x    + extra_bit
+             
+               puts "File Maintenance"
+
+               FileUtils.rm(    new_root )
+               FileUtils.mkdir( new_root )
+               
+               build_links(new_root , x, spacer+' ')
+               build_links(new_root , current_pointer, spacer+' ')
+
+
+            elsif File.directory?(new_link)
+               #new_link already exists as folder
+               # this implies it already exists on another drive
+               # just recurse on this lower level
+               puts "#{spacer}Mode :4 INFO   : Doing recursive call to build links"
+
+               
+
+               new_root = x.dup
+               new_root[y] = "" 
+               new_root = root + new_root
+
+               build_links(new_root, x, spacer+' ' )
+            else 
+               #Link does exist and points to different Location
+               # What could have caused this?
+               #  1) Data has been completely moved to another Drive
+               #  2) Drive was running out of room and this folder has been split across 2 or more drives
+               #
+               # To resolve this copy current link location if it exists save location for later
+               # Create this folder and link in contnents from new drive then repeat for original location
+
+               puts "#{spacer}Mode :5 ERROR   : #{new_link} already exists"
+               puts "#{spacer}                  This section requires programming"
+            end
+         end
+   end
+
+
+   def test_folder(path)
+      puts "File    #{File.file?(path)}"
+      puts "Folder  #{File.directory?(path)}"
+      puts "Symlink #{File.symlink?(path)}"
+   end
+
+end
+

data/lib/rfuse_symbolic_fs.rb

@@ -0,0 +1,88 @@
+require "rubygems"
+require 'fusefs'
+require 'rfuse_symbolic_fs_opts'
+
+
+class RFuseSymbolicFS
+   # contents( path )
+   # file?( path )
+   # directory?( path )
+   # read_file( path )
+   # size( path )
+   # 
+   # save
+   # touch( path )
+   # can_write?(path)
+   # write_to(path,body)
+   # 
+   # can_delete?(path)
+   # delete( path )
+   #
+   # can_mkdir?( path )
+   # mkdir( path )
+   # can_rmdir( path )
+   # rmdir( path )
+   # 
+
+
+
+   def initialize( options )
+      @base_dir = options.input
+   end
+
+   def contents(path)
+      n_path = File.expand_path( @base_dir + path )
+      Dir.chdir(n_path)  
+
+      files = Dir.glob('*')
+      #Added command to OS X Finder not to index.
+      files << 'metadata_never_index'
+
+      return files
+   end
+  
+   def file?(path)
+      #If path ends with metadata_never_index it is a file
+      if path =~ /metadata_never_index$/
+         return true
+      end
+
+      return (not File.directory?( @base_dir + path ))
+   end
+
+   def directory?(path)
+      File.directory?(@base_dir + path)
+   end
+  
+   def read_file(path)
+      
+      #puts "read file #{path}"
+      if File.exists?( @base_dir + path )
+         return File.new(@base_dir + path , "r").read
+      end
+      return "ERROR, file not found\n"
+
+   end
+
+
+   def size(path)
+      if File.exists?( @base_dir + path )
+         return File.size( @base_dir + path )
+      else
+         return 16
+      end
+   end
+end
+
+
+if $0 == __FILE__
+
+   options = RFuseSymbolicFSOpts.parse(ARGV)
+   filesystem = RFuseSymbolicFS.new( options )
+   FuseFS.set_root( filesystem )
+
+   # Mount under a directory given on the command line.
+   FuseFS.mount_under options.mountpoint
+   FuseFS.run
+end
+

data/lib/rfuse_symbolic_fs_opts.rb

@@ -0,0 +1,72 @@
+require 'optparse'
+require 'optparse/time'
+require 'ostruct'
+
+class RFuseSymbolicFSOpts
+
+
+    #
+    # Return a structure describing the options.
+    #
+    def self.parse(args)
+      @VERSION = "0.0.1"
+      
+      # The options specified on the command line will be collected in *options*.
+      # We set default values here.
+      options = OpenStruct.new
+      
+      options.verbose = false
+      options.mountpoint = ""
+      options.input   = ""
+       
+
+      opts = OptionParser.new do |opts|
+         opts.banner = "Usage: #{__FILE__} [options]"
+         opts.separator ""
+         opts.separator "Common options:"
+
+         # No argument, shows at tail. This will print an options summary.
+         opts.on("-h", "--help", "Show this message") do
+            puts opts
+            exit
+         end
+
+         # Another typical switch to print the version.
+         opts.on("--version", "Show version") do
+            #puts OptionParser::Version.join('.')
+            puts "Version #{@VERSION}"
+            exit
+         end
+
+         # Boolean switch.
+         #opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+         #   options.verbose = v
+         #end
+
+         opts.separator ""
+         opts.separator "Specific options:"
+
+
+         # Cast 'delay' argument to a Float.
+         opts.on("--mountpoint path", String, "Root of new Filesystem") do |n|
+            options.mountpoint = n
+         end
+         
+         opts.on("--input N", String, "Folder FS will point to") do |n|
+            options.input = n
+         end
+         
+        
+      end
+      
+      options.leftovers = opts.parse!(args)
+
+      if (options.mountpoint == "") and (options.input == "") and (options.leftovers.size==2)
+         options.mountpoint = options.leftovers[0]
+         options.input      = options.leftovers[1]
+      end
+      return options
+    end # parse()
+
+  end # class OptparseExample
+

data/lib/test_fuse.rb

@@ -0,0 +1,74 @@
+require "rubygems"
+require 'fusefs'
+
+class HelloDir
+  
+   def initialize
+      @base_dir = '/Users/morgy/Movies'
+   end
+
+   def contents(path)
+      n_path = File.expand_path( @base_dir + path )
+      Dir.chdir(n_path)  
+
+      files = Dir.glob('*')
+      files << 'hello.txt'
+      files << 'metadata_never_index'
+   end
+  
+   def file?(path)
+      if path == '/hello.txt'
+         return true
+      end
+
+      if path == '/metadata_never_index'
+         return true
+      end
+
+      if File.exists?(@base_dir + path )
+         #puts "file? #{@base_dir}#{path} "
+         if File.directory?(@base_dir + path )
+            return false
+         else 
+            return true
+         end
+      end
+
+   end
+
+   def directory?(path)
+      File.directory?(@base_dir + path)
+   end
+  
+  def read_file(path)
+  puts "read file #{path}"
+   if path == '/hello.txt'
+    return "Hello, World!\n"
+   end
+   puts "exists?"
+   if File.exists?( @base_dir + path )
+      puts " true #{@base_dir}#{path}"
+      return File.new(@base_dir + path , "r").read
+   else
+      puts " fail #{@base_dir}#{path}"
+   end
+   return "ERROR, file not found\n"
+
+  end
+
+  def size(path)
+   if File.exists?( @base_dir + path )
+      return File.size( @base_dir + path )
+   else
+      return 16
+   end
+   #read_file(path).size
+  end
+end
+
+hellodir = HelloDir.new
+FuseFS.set_root( hellodir )
+
+# Mount under a directory given on the command line.
+FuseFS.mount_under ARGV.shift
+FuseFS.run

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: rfuse_symbolic_fs
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Morgan Prior
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-07 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fusefs
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  type: :runtime
+  version_requirements: *id001
+description: Virtual Filesystem Written in Ruby Fuse, which acts like a symbolic link
+email: rfuse_symbolic_fs_gem@amaras-tech.co.uk
+executables: 
+- rfuse_symbolic_fs
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/rfuse_symbolic_fs
+- lib/amaras_fs.rb
+- lib/rfuse_symbolic_fs.rb
+- lib/rfuse_symbolic_fs_opts.rb
+- lib/test_fuse.rb
+has_rdoc: true
+homepage: http://amaras-tech.co.uk/software/rfuse_symbolic_fs
+licenses: []
+
+post_install_message: To use 'rfuse_symbolic_fs' as a standalone application your gems folder must be on your path
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby Fuse, Filesystem which basically is a soft link on Mac OS X, Linux and Unix.
+test_files: []
+