pfuse 0.7.5

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,14 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.o
+*.bundle
+*.log
+Makefile
+pid
+hello
+ext/conftest.dSYM/
+tags
+old.c

data/API.txt

@@ -0,0 +1,279 @@
+FuseFS API DOCUMENT
+===================
+
+Last updated: 2005.09.19 by Greg Millam
+
+WARNING
+-------
+
+Note: If you use DirLink (in demo.rb) or in any way access a FuseFS filesystem
+from *within* the ruby script accessing the FuseFS, then FuseFS will hang, and
+the only recourse is a kill -KILL.
+
+Also: If there are any open files or shells with 'pwd's in your filesystem
+when you exit your ruby script, fuse *might* not actually be unmounted. To
+unmount a path yourself, run the command:
+
+  fusermount -u <path>
+
+to unmount any FUSE filesystems mounted at <path>.
+
+
+FuseFS API
+----------
+
+
+FuseFS provides a layer of abstraction to a programmer who wants to create a
+virtual filesystem via FUSE.
+
+FuseFS programs consist of two parts:
+
+1) FuseFS, which is defined in 'fusefs.rb'
+2) An object that defines a virtual directory. This must define a number of
+   methods (given below, in "Directory Methods" section) in order to be
+   usable.
+
+To write a FuseFS program, you must:
+
+* Define and create a Directory object that responds to the methods required
+  by FuseFS for its desired use.
+
+* Call FuseFS.set_root <virtualdir> with the object defining your virtual
+  directory.
+
+* Mount FuseFS under a real directory on your filesystem.
+
+* Call FuseFS.run to start receiving and executing events.
+
+Happy Filesystem Hacking!
+
+
+Hello World FS
+--------------
+helloworld.rb
+
+This creates a filesystem that contains exactly 1 file: "hello.txt" that, when
+read, returns "Hello, World!"
+
+This is not writable to, and contains no other files.
+
+  require 'fusefs'
+
+  class HelloDir
+    def contents(path)
+      ['hello.txt']
+    end
+    def file?(path)
+      path -- '/hello.txt'
+    end
+    def read_file(path)
+      "Hello, World!\n"
+    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
+
+
+Directory Methods
+-----------------
+
+Without any methods defined, any object is by default a content-less,
+file-less directory.
+
+The following are necessary for most or all filesystems:
+
+  Directory listing and file type methods:
+
+    :contents(path)     # Return an array of file and dirnames within <path>.
+    :directory?(path)   # Return true if <path> is a directory.
+    :file?(path)        # Return true if <path> is a file (not a directory).
+    :executable?(path)  # Return true if <path> is an executable file.
+    :size(path)         # Return the file size. Necessary for apache, xmms,
+                          etc.
+
+  File reading:
+
+    :read_file(path)    # Return the contents of the file at location <path>.
+
+The following are only necessary if you want a filesystem that can be modified
+by the user. Without defining any of the below, the contents of the filesystem
+are automatically read-only.
+
+  File manipulation:
+
+    :can_write?(path)   # Return true if the user can write to file at <path>.
+    :write_to(path,str) # Write the contents of <str> to file at <path>.
+
+    :can_delete?(path)  # Return true if the user can delete file at <path>.
+    :delete(path)       # Delete the file at <path>
+
+  Directory manipulation:
+
+    :can_mkdir?(path)   # Return true if user can make a directory at <path>.
+    :mkdir(path)        # Make a directory at path.
+
+    :can_rmdir?(path)   # Return true if user can remove directory at <path>.
+    :rmdir(path)        # Remove it.
+
+  Neat "toy":
+
+    :touch(path)        # Called when a file is 'touch'd or otherwise has
+                          their timestamps explicitly modified. I envision
+                          this as a neat toy, maybe you can use it for a
+                          push-button file?
+                            "touch button" -> unmounts fusefs?
+                            "touch musicfile.mp3" -> Play the mp3.
+
+If you want a lower level control of your file, then you can use:
+
+    :raw_open(path,mode)   # mode is "r" "w" or "rw", with "a" if the file
+                             is opened for append. If raw_open returns true,
+                             then the following calls are made:
+    :raw_read(path,off,sz) # Read sz bites from file at path starting at
+                             offset off
+    :raw_write(path,off,sz,buf) # Write sz bites of buf to path starting at
+                                  offset off
+    :raw_close(path)       # Close the file.
+    
+
+Method call flow
+================
+
+List contents:
+  :directory? will be checked before :contents
+  (Most 'ls' or 'dir' functions will go on next
+   to getattr() for all contents)
+
+Read file:
+  :file? will be checked before :read_file
+
+Getattr
+  :directory? will be checked first.
+
+  :file? will be checked before :can_write?
+  :file? will be checked before :executable?
+
+Writing files:
+  * directory? is usually called on the directory
+    The FS wants to write a new file to, before this
+    can occur.
+  :can_write? will be checked before :write_to
+
+Deleting files:
+  :file? will be checked before :can_delete?
+  :can_delete? will be checked before :delete
+
+Creating dirs:
+  * directory? is usually called on the directory
+    The FS wants to make a new directory in, before
+    this can occur.
+  :directory? will be checked.
+  :can_mkdir? is called only if :directory? is false.
+  :can_mkdir? will be checked before :mkdir
+
+Deleting dirs:
+  :directory? will be checked before :can_rmdir?
+  :can_rmdir? will be checked before :rmdir
+
+
+module FuseFS
+-------------
+
+FuseFS methods:
+  
+  FuseFS.set_root(object)
+      Set the root virtual directory to <object>. All queries for obtaining
+      file information is directed at object.
+  
+  FuseFS.mount_under(path[,opt[,opt,...]])
+      This will cause FuseFS to virtually mount itself under the given path.
+      'path' is required to be a valid directory in your actual filesystem.
+
+      'opt's are FUSE options. Most likely, you will only want 'allow_other'
+      or 'allow_root'. The two are mutually exclusive in FUSE, but allow_other
+      will let other users, including root, access your filesystem. allow_root
+      will only allow root to access it.
+      
+      Also available for FuseFS users are:
+        default_permissions, max_read=N, fsname=NAME.
+
+      For more information, look at FUSE.
+
+      (P.S: I know FUSE allows other options, but I don't think any of the
+      rest will do any good with FuseFS. If you think otherwise, please let me
+      know!)
+
+  FuseFS.run
+      This is the final step to make your virtual filesystem accessible. It is
+      recommended you run this as your main thread, but you can thread off to
+      run this.
+
+  FuseFS.handle_editor = bool (true by default)
+      If handle_editor is true, then FuseFS will attempt to capture all editor
+      files and prevent them from being passed to FuseRoot. It also prevents
+      created and unmodified files from being passed as well, as vim (among
+      others) will attempt to create and then remove a file that does not
+      exist.
+
+  FuseFS.reader_uid and FuseFS.reader_gid
+      When the filesystem is accessed, the accessor's uid or gid is returned
+      by FuseFS.reader_uid and FuseFS.reader_gid. You can use this in
+      determining your permissions, or even provide different files for
+      different users!
+  
+  FuseFS.fuse_fd and FuseFS.process
+      These are not intended for use by the programmer. If you want to muck
+      with this, read the code to see what they do :D.
+
+
+
+FuseDir
+----------
+
+FuseFS::FuseDir defines the methods "split_path" and "scan_path". You
+should typically inherit from FuseDir in your own directory objects.
+
+  base, rest = split_path(path)   # base is the file or directory in the
+                                    current context. rest is either nil,
+                                    or a path that is requested. If 'rest'
+                                    exists, then you should recurse the paths.
+  base, *rest = scan_path(path)   # scan_path returns an array of all
+                                    directory and file elements given by
+                                    <path>. This is useful when you're
+                                    encapsulating an entire fs into one
+                                    object.
+
+MetaDir
+-------
+
+MetaDir is a full filesystem defined with hashes. It is writable, and the user
+can create and edit files within it, as well as the programmer.
+
+Usage:
+  root = MetaDir.new
+
+  root.mkdir("/hello")
+  root.write_to("/hello/world","Hello, World!\n")
+  root.write_to("/hello/everybody","Hello, Everybody!\n")
+
+  FuseFS.set_root(root)
+
+Because MetaDir is fully recursive, you can mount your own or other defined
+directory structures under it. For example, to mount a dictionary filesystem
+(as demonstrated in samples/dictfs.rb), use:
+
+  root.mkdir("/dict",DictFS.new)
+
+Conclusion
+----------
+
+Happy Hacking! If you do anything neat with this, please let me know!
+
+My email address is walker@deafcode.com
+
+Thanks for using FuseFS!

data/Changes.txt

@@ -0,0 +1,63 @@
+FuseFS 0.7
+==========
+
+  * It's now a Rubygem on Github
+
+FuseFS 0.6
+==========
+
+  * FuseFS.mount_under() now takes FUSE options as optional arguments, such as
+    'allow_other' and 'allow_root'
+  * rmdir now works. (Whoops!)
+
+FuseFS 0.5.1
+============
+
+  * Bugfix for dealing with raw files (Thanks, Kent Sibilev)
+
+FuseFS 0.5
+==========
+
+  * Fixed for FUSE 2.4. direct_io turned from a mount option in 2.3 to a lib
+    option in 2.4.
+  * _why_the_lucky_stiff's railsfs.rb added to the samples/ dir.
+  * FuseRoot#raw_open is called with the path and "r" "w" "rw" for read or
+    write modes, along with "a" if it is called for appending.
+  * If raw_open returns true, FuseFS will call raw_read, raw_write, and
+    raw_close at necessary points. (See API.txt)
+  * FuseRoot#size is optionally called to determine file sizes, should the
+    user want a file size to be reported as anything other than 0.
+
+FuseFS 0.4
+==========
+
+  * Stronger and more robust handling of editor swap files, but still
+    incomplete.
+  * Peppered with debug statements.
+  * A bit cleaner method of calling ruby functions.
+  * rf_rename fixed. Whoops!
+
+FuseFS 0.3
+==========
+
+  * read_file borked FuseFS when a binary file was returned. Instead of using
+    strdup, it now mallocs according to the returned size, as appropriate.
+  * Addition of sample/openurifs.rb
+  * 'touch file' emptied a file, since it opened and then released without
+    writing. I added a 'modified' flag to fix this.
+  * 'touch' method call added, and called when a program attempts to modify
+    a file's time.
+  * 'executable?' check added in case programmer wants to the file to report
+    itself as executable to the filesystem.
+  * vim and emacs swap files are not passed to FuseFS =).
+
+FuseFS 0.2
+==========
+
+  * Fix call for deleting files from 'remove' to 'delete' to match API spec.
+  * Addition of sample/yamlfs.rb
+
+FuseFS 0.1
+==========
+
+  Initial import.

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2005 Greg Millam.
+Copyright (c) 2009 Kyle Maxwell.
+Copyright (c) 2009 David Turnbull.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,36 @@
+PFuseFS README
+============
+  Plain FUSE bindings.
+  The C ext is derived from fusefs-osx but stripped back to allow more logic in Ruby - the language you'd rather do tricky things in.
+  The FuseFS library also includes FuseFS::DirEntry, FuseFS::FileEntry and FuseFS::Entries helpers, the latter calling back to your getattr function to create an accurate stat struct.
+
+Requirements
+------------
+  * FUSE (http://fuse.sourceforge.org)
+  * Ruby 1.8
+ (* C compiler)
+
+Install
+-------
+	gem install dsturnbull-fusefs
+
+Usage
+-----
+  require 'fusefs'
+
+  Some sample ruby filesystems are listed in "sample/"
+
+  When you run a fusefs script, it will listen on a socket indefinitely, so
+  either background the script or open another terminal to mosey around in the
+  filesystem.
+
+  Also, check the API.txt file for more use.
+
+
+License
+-------
+  MIT license, in file "LICENSE"
+
+
+Authors: David Turnbull <dsturnbull@me.com>
+Inspired by: Greg Millam <walker@deafcode.com>, Kyle Maxwell <kyle@kylemaxwell.com> (fizx/fusefs-osx)

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pfuse"
+    gem.summary = %Q{fusefs}
+    gem.description = %Q{Gemified}
+    gem.email = "dsturnbull@gmail.com"
+    gem.homepage = "http://github.com/dsturnbull/pfuse"
+    gem.authors = ["David Turnbull", "Kyle Maxwell"]
+    gem.extensions = ["ext/extconf.rb"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+task :default => :build

data/TODO

@@ -0,0 +1,11 @@
+TODO for FuseFS
+===============
+
+- Problem with editors: vim attempts to create and then delete a numbered file.
+  This can be an issue if the filename (all digits) is reported as not valid.
+
+  I am looking for a solution for this, but it's gonna be a pain.
+
+- Tests, more tests, and unit tests!
+
+- Consider FIFOs? We can use FIFOs to mimic TCP internet, if we do this right.

data/VERSION

@@ -0,0 +1 @@
+0.7.5

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+#$CFLAGS << ' -fnested-functions'
+$CFLAGS << ' -Wall'
+$CFLAGS << ' -Werror'
+
+dir_config('fusefs_lib.so')
+if have_library('fuse_ino64') || have_library('fuse') 
+  create_makefile('fusefs_lib')
+else
+  puts "No FUSE install available"
+end

data/ext/fusefs_fuse.c

@@ -0,0 +1,150 @@
+/* fusefs_fuse.c */
+
+/* This is rewriting most of the things that occur
+ * in fuse_main up through fuse_loop */
+
+#define FUSE_USE_VERSION 26
+#define _FILE_OFFSET_BITS 64
+
+#include <fuse.h>
+#include <fuse/fuse_lowlevel.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <limits.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdint.h>
+#include <sys/param.h>
+#include <sys/uio.h>
+#include <signal.h>
+
+struct fuse *fuse_instance = NULL;
+struct fuse_chan *fusech = NULL;
+static char *mounted_at = NULL;
+
+static int set_one_signal_handler(int signal, void (*handler)(int));
+
+int fusefs_fd() {
+  if(fusech == NULL)
+    return -1;
+  return fuse_chan_fd(fusech);
+}
+
+int
+fusefs_unmount() {
+  char buf[128];
+
+  if (mounted_at && fusech) {
+    fuse_unmount(mounted_at, fusech);
+    sprintf(buf, "/sbin/umount %s", mounted_at);
+    system(buf);
+  }
+  if (fuse_instance)
+    fuse_destroy(fuse_instance);
+  fuse_instance = NULL;
+  free(mounted_at);
+  fusech = NULL;
+
+  return 0;
+}
+
+static void
+fusefs_ehandler() {
+  if (fuse_instance != NULL) {
+    fusefs_unmount();
+  }
+}
+
+int
+fusefs_setup(char *mountpoint, const struct fuse_operations *op, struct fuse_args *opts) {
+  fusech = NULL;
+  if (fuse_instance != NULL) {
+    return 0;
+  }
+  if (mounted_at != NULL) {
+    return 0;
+  }
+
+  /* First, mount us */
+  fusech = fuse_mount(mountpoint, opts);
+  if (fusech == NULL) return 0;
+
+  fuse_instance = fuse_new(fusech, opts, op, sizeof(*op), NULL);
+  if (fuse_instance == NULL)
+    goto err_unmount;
+
+  /* Set signal handlers */
+  if (set_one_signal_handler(SIGHUP, fusefs_ehandler) == -1 ||
+      set_one_signal_handler(SIGINT, fusefs_ehandler) == -1 ||
+      set_one_signal_handler(SIGTERM, fusefs_ehandler) == -1 ||
+      set_one_signal_handler(SIGPIPE, SIG_IGN) == -1)
+    return 0;
+
+  atexit(fusefs_ehandler);
+
+  /* We've initialized it! */
+  mounted_at = strdup(mountpoint);
+  return 1;
+err_unmount:
+  fuse_unmount(mountpoint, fusech);
+  return 0;
+}
+
+int
+fusefs_uid() {
+  struct fuse_context *context = fuse_get_context();
+  if (context) return context->uid;
+  return -1;
+}
+
+int
+fusefs_gid() {
+  struct fuse_context *context = fuse_get_context();
+  if (context) return context->gid;
+  return -1;
+}
+
+int
+fusefs_process() {
+  /* This gets exactly 1 command out of fuse fd. */
+  /* Ideally, this is triggered after a select() returns */
+  if (fuse_instance != NULL) {
+    struct fuse_cmd *cmd;
+
+    if (fuse_exited(fuse_instance))
+      return 0;
+
+    cmd = fuse_read_cmd(fuse_instance);
+    if (cmd == NULL)
+      return 1;
+
+    fuse_process_cmd(fuse_instance, cmd);
+  }
+  return 1;
+}
+
+
+static int set_one_signal_handler(int signal, void (*handler)(int))
+{
+    struct sigaction sa;
+    struct sigaction old_sa;
+
+    memset(&sa, 0, sizeof(struct sigaction));
+    sa.sa_handler = handler;
+    sigemptyset(&(sa.sa_mask));
+    sa.sa_flags = 0;
+
+    if (sigaction(signal, NULL, &old_sa) == -1) {
+        perror("FUSE: cannot get old signal handler");
+        return -1;
+    }
+
+    if (old_sa.sa_handler == SIG_DFL &&
+        sigaction(signal, &sa, NULL) == -1) {
+        perror("Cannot set signal handler");
+        return -1;
+    }
+    return 0;
+}

data/ext/fusefs_fuse.h

@@ -0,0 +1,19 @@
+/* fusefs_fuse.h */
+
+/* This is rewriting most of the things that occur
+ * in fuse_main up through fuse_loop */
+
+#ifndef __FUSEFS_FUSE_H_
+#define __FUSEFS_FUSE_H_
+
+struct fuse_args;
+
+int fusefs_fd();
+int fusefs_unmount();
+int fusefs_ehandler();
+int fusefs_setup(char *mountpoint, const struct fuse_operations *op, struct fuse_args *opts);
+int fusefs_process();
+int fusefs_uid();
+int fusefs_gid();
+
+#endif