rfuse-ng 0.4.0 → 0.5.3

data/CHANGELOG.txt

@@ -1,3 +1,71 @@
+2011-02-27
+
+All fuse operations are implemented. ioctl() and poll() are untested,
+thus, probably won't work properly. Please contact me if you can test
+these features, now I have a little bit more time for the project.
+
+Itegrated features from other folks' patches. Thanks for Grant Gardner
+(GG) and Yonatan Maman (YM)
+
+Pathces:
+
+YM-1: ruby_19_yonatan.pathc
+  * allow rfuse-ng to compile under ruby 1.9.2
+
+GG-1: 0001-allow-nil-for-readder-filler.patch
+  * allow readdir to push "nil" as the stat value into filler (fuse will
+    then call getattr() when required)
+  * allow open to place a ruby object into fuse_file_info->fh and be
+    cleaned up again in release
+
+GG-2: 0002-exception-backtraces-and-ruby-filehandle-object-in-o.patch
+  * tweak the error handling to log the caught exception and its
+    backtrace
+  * The error handling part will not print any output if the thrown
+    exception responds_to?(:errno) since I gather that would be expected
+    (eg ENOENT)
+
+GG-3: 0003-Add-fd-and-process-calls-to-RFuse-object.patch
+
+  This one allows you to run the event loop in ruby instead of calling
+  fuse_loop() which is useful if you want to install your own signal handlers
+  and cleanup nicely if fuse is unmounted externally.
+
+  eg...
+
+  def FuseFS.run
+    unless @fuse
+      raise "fuse is not mounted
+    end
+
+    begin
+        #Get the /dev/fuse fd
+        io = IO.for_fd(@fuse.fd)
+    rescue Errno::EBADF
+        raise "fuse not mounted"
+    end
+
+    @running = true
+    while @running
+        begin
+                IO.select([io])
+                # Process a fuse command, returns -1 if fuse has been
+                  unmounted remotely.
+                if (@fuse.process() < 0)
+                    @running = false
+                end
+        rescue Errno::EBADF
+                #We've tried to select on a dead fd...
+                @running = false
+        end
+    end
+   end
+
+BUGS to fix:
+
+Parameters are not handled correctly to fuse_mount, see test-ruby.rb
+for details.
+
 2010-06-20
 
 Only poll() and ioctl() are missing. Fixed compilation error

data/Rakefile

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'rubygems'
 require 'rake'
 
@@ -5,7 +7,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "rfuse-ng"
-    gem.version = "0.4.0"
+    gem.version = "0.5.3"
     gem.summary = 'Ruby language binding for FUSE'
     gem.description = 'Ruby language binding for FUSE. It was forked from rfuse'
     gem.rubyforge_project = 'rfuse-ng'

data/TODO.txt

@@ -2,5 +2,26 @@ Todo list from rfuse:
 
 *Unit Test
 *Multithreading
-*Better Errorhandling
+*Better Error handling
 *Test,test,test
+
+Todo list for ng:
+
+Basicly same as above, except:
+
+A lot of testing has been done and an army of bugs was slaughtered in
+the process, so rfuse-ng can be called "beta", means other folks have
+to test it probably by trying to do something useful.
+
+Error handling still needs to be improved greatly. Stuff needs logging
+(syslog?) with different verbosity levels to support developement and
+still don't litter the logs on production systems.
+
+Multithreading is still a mistery for me, but definitely a must to have
+feature.
+
+Since manual testing takes up some 60% of my time, I desperately need
+unit tests, so this item still valid too.
+
+BUG: find out why kernel parameter passing behaves very oddly (see
+test-ruby.rb for details).

data/ext/bufferwrapper.c

@@ -0,0 +1,48 @@
+#include <stdlib.h>
+#include <ruby.h>
+#include <fuse.h>
+
+#include "bufferwrapper.h"
+
+VALUE bufferwrapper_new(VALUE class)
+{
+  rb_raise(rb_eNotImpError, "new() not implemented (it has no use), and should not be called");
+  return Qnil;
+}
+
+VALUE bufferwrapper_initialize(VALUE self)
+{
+  return self;
+}
+
+VALUE bufferwrapper_getdata(VALUE self, VALUE size)
+{
+  void *buf;
+
+  Data_Get_Struct(self, void, buf);
+
+  return rb_str_new(buf, FIX2INT(size));
+}
+
+VALUE wrap_buffer(void *buf)
+{
+  VALUE rRFuse;
+  VALUE rBufferWrapper;
+
+  rRFuse         = rb_const_get(rb_cObject,rb_intern("RFuse"));
+  rBufferWrapper = rb_const_get(rRFuse,rb_intern("BufferWrapper"));
+
+  return Data_Wrap_Struct(rBufferWrapper, NULL, NULL, buf);
+}
+
+VALUE bufferwrapper_init(VALUE module)
+{
+  VALUE cBufferWrapper = rb_define_class_under(module,"BufferWrapper",rb_cObject);
+
+  rb_define_alloc_func(cBufferWrapper,bufferwrapper_new);
+
+  rb_define_method(cBufferWrapper,"initialize",bufferwrapper_initialize,0);
+  rb_define_method(cBufferWrapper,"getData",bufferwrapper_getdata,1);
+
+  return cBufferWrapper;
+}

data/ext/bufferwrapper.h

@@ -0,0 +1,10 @@
+#include <fuse.h>
+#include <ruby.h>
+
+VALUE wrap_buffer(void *buf);
+
+VALUE bufferwrapper_new(VALUE class);
+VALUE bufferwrapper_getdata(VALUE self, VALUE size);
+VALUE bufferwrapper_init(VALUE module);
+
+VALUE bufferwrapper_initialize(VALUE self);

data/ext/file_info.c

@@ -2,12 +2,21 @@
 #include <fuse.h>
 
 
+static void file_info_mark(struct fuse_file_info *ffi) {
+  if (TYPE(ffi->fh) != T_NONE) {
+     rb_gc_mark((VALUE) ffi->fh);
+  } 
+}
+
+//creates a FileInfo object from an already allocated ffi
 VALUE wrap_file_info(struct fuse_file_info *ffi) {
   VALUE rRFuse;
   VALUE rFileInfo;
   rRFuse=rb_const_get(rb_cObject,rb_intern("RFuse"));
   rFileInfo=rb_const_get(rRFuse,rb_intern("FileInfo"));
-  return Data_Wrap_Struct(rFileInfo,0,0,ffi); //shouldn't be freed!
+  //TODO GG: we need a mark function here to ensure the ffi-fh value is not GC'd
+  //between open and release
+  return Data_Wrap_Struct(rFileInfo,file_info_mark,0,ffi); //shouldn't be freed!
 
 };
 
@@ -16,11 +25,12 @@ VALUE file_info_initialize(VALUE self){
   return self;
 }
 
+//TODO GG: This probably needs a free function and be converted to alloc/initialize
+//but this probably never gets called anyway
+//TODO FT: test: this _should_not_ be called, an exception would do the trick :)
 VALUE file_info_new(VALUE class){
-  VALUE self;
-  struct fuse_file_info *f;
-  self = Data_Make_Struct(class, struct fuse_file_info, 0,NULL,f);
-  return self;
+  rb_raise(rb_eNotImpError, "new() not implemented (it has no use), and should not be called");
+  return Qnil;
 }
 
 VALUE file_info_writepage(VALUE self) {
@@ -35,11 +45,31 @@ VALUE file_info_flags(VALUE self) {
   return INT2FIX(f->flags);
 }
 
+//fh is possibly a pointer to a ruby object and can be set
+VALUE file_info_fh(VALUE self) {
+   struct fuse_file_info *f;
+   Data_Get_Struct(self,struct fuse_file_info,f);
+  if (TYPE(f->fh) != T_NONE) {
+    return (VALUE) f->fh;
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE file_info_fh_assign(VALUE self,VALUE value) {
+   struct fuse_file_info *f;
+   Data_Get_Struct(self,struct fuse_file_info,f);
+   f->fh = value;
+   return value;
+}
+
 VALUE file_info_init(VALUE module) {
   VALUE cFileInfo=rb_define_class_under(module,"FileInfo",rb_cObject);
   rb_define_alloc_func(cFileInfo,file_info_new);
   rb_define_method(cFileInfo,"initialize",file_info_initialize,0);
   rb_define_method(cFileInfo,"flags",file_info_flags,0);
   rb_define_method(cFileInfo,"writepage",file_info_writepage,0);
+  rb_define_method(cFileInfo,"fh",file_info_fh,0);
+  rb_define_method(cFileInfo,"fh=",file_info_fh_assign,1);
   return cFileInfo;
 }

data/ext/filler.c

@@ -16,10 +16,15 @@ VALUE rfiller_new(VALUE class){
 VALUE rfiller_push(VALUE self, VALUE name, VALUE stat, VALUE offset) {
   struct filler_t *f;
   Data_Get_Struct(self,struct filler_t,f);
-  struct stat st;
-  memset(&st, 0, sizeof(st));
-  rstat2stat(stat,&st);
-  f->filler(f->buffer,STR2CSTR(name),&st,NUM2LONG(offset));
+  //Allow nil return instead of a stat
+  if (NIL_P(stat)) {
+    f->filler(f->buffer,STR2CSTR(name),NULL,NUM2LONG(offset));
+  } else {
+    struct stat st;
+    memset(&st, 0, sizeof(st));
+    rstat2stat(stat,&st);
+    f->filler(f->buffer,STR2CSTR(name),&st,NUM2LONG(offset));
+  }
   return self;
 }
 

data/ext/helper.c

@@ -47,24 +47,20 @@ void rfuseconninfo2fuseconninfo(VALUE rfuseconninfo,struct fuse_conn_info *fusec
 struct fuse_args * rarray2fuseargs(VALUE rarray){
 
   Check_Type(rarray, T_ARRAY);
-
   struct fuse_args *args = malloc(sizeof(struct fuse_args));
-
-  args->argc      = RARRAY(rarray)->len;
-  args->argv      = malloc(args->argc * sizeof(char *) + 1);
-  /* Nope, this isn't really 'allocated'. The elements
-   * of this array shouldn't be freed */
-  args->allocated = 0;
+  args->argc      = RARRAY_LEN(rarray);
+  args->argv      = malloc((args->argc + 1) * sizeof(char *));
+  args->allocated = 1;
 
   int i;
   VALUE v;
+
   for(i = 0; i < args->argc; i++) {
-    v = RARRAY(rarray)->ptr[i];
+    v = RARRAY_PTR(rarray)[i];
     Check_Type(v, T_STRING);
-    args->argv[i] = STR2CSTR(RSTRING(v));
+    args->argv[i] = rb_string_value_ptr(&v); //STR2CSTR(RSTRING(v));
   }
   args->argv[args->argc] = NULL;
   
   return args;
 }
-

data/ext/helper.h

@@ -11,4 +11,9 @@ void rstatvfs2statvfs(VALUE rstatvfs,struct statvfs *statvfsbuf);
 void rfuseconninfo2fuseconninfo(VALUE rfuseconninfo,struct fuse_conn_info *fuseconninfo);
 struct fuse_args * rarray2fuseargs(VALUE rarray);
 
+#if defined(RUBY_VERSION) && RUBY_VERSION >= 19
+  #define STR2CSTR(X) StringValuePtr(X)
+#endif
+
+
 #endif

data/ext/intern_rfuse.c

@@ -1,21 +1,22 @@
+#include "intern_rfuse.h"
+#include <fuse/fuse_lowlevel.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <fuse.h>
-#include "intern_rfuse.h"
 
 struct intern_fuse *intern_fuse_new() {
   struct intern_fuse *inf;
   inf = (struct intern_fuse *) malloc(sizeof(struct intern_fuse));
   memset(&inf->fuse_op, 0, sizeof(struct fuse_operations));
   return inf;
-};
+}
 
 int intern_fuse_destroy(struct intern_fuse *inf){
   //you have to take care, that fuse is unmounted yourself!
   fuse_destroy(inf->fuse);
   free(inf);
   return 0;
-};
+}
 
 int intern_fuse_init(
   struct intern_fuse *inf,
@@ -40,4 +41,37 @@ int intern_fuse_init(
 
   strncpy(inf->mountname, mountpoint, MOUNTNAME_MAX);
   return 0;
-};
+}
+
+// Return the /dev/fuse file descriptor for use with IO.select
+int intern_fuse_fd(struct intern_fuse *inf)
+{
+   if (inf->fc == NULL) {
+     return -1;
+   }
+
+  struct fuse_chan *fc = inf->fc;
+  return fuse_chan_fd(fc);
+}
+
+//Process one fuse command (ie after IO.select)
+int intern_fuse_process(struct intern_fuse *inf)
+{
+  if (inf->fuse == NULL) {
+    return -1;
+  }
+
+
+  if (fuse_exited(inf->fuse)) {
+    return -1;
+  }
+
+  struct fuse_cmd *cmd;
+  cmd = fuse_read_cmd(inf->fuse);
+
+  if (cmd != NULL) {
+    fuse_process_cmd(inf->fuse, cmd);
+  }
+
+  return 0;
+}

data/ext/intern_rfuse.h

@@ -20,4 +20,6 @@ int intern_fuse_init(
   struct fuse_args *libopts
 );
 
+int intern_fuse_fd(struct intern_fuse *inf);
+int intern_fuse_process(struct intern_fuse *inf);
 int intern_fuse_destroy(struct intern_fuse *inf);

data/ext/pollhandle.c

@@ -0,0 +1,54 @@
+#include <ruby.h>
+#include <fuse.h>
+
+#include "pollhandle.h"
+
+static int pollhandle_destroy(struct fuse_pollhandle *ph)
+{
+  fuse_pollhandle_destroy(ph);
+  return 0;
+}
+
+VALUE pollhandle_new(VALUE class)
+{
+  rb_raise(rb_eNotImpError, "new() not implemented (it has no use), and should not be called");
+  return Qnil;
+}
+
+VALUE pollhandle_initialize(VALUE self)
+{
+  return self;
+}
+
+VALUE pollhandle_notify_poll(VALUE self)
+{
+  struct fuse_pollhandle *ph;
+  Data_Get_Struct(self, struct fuse_pollhandle, ph);
+  return INT2FIX(fuse_notify_poll(ph));
+}
+
+VALUE wrap_pollhandle(struct fuse_pollhandle *ph)
+{
+  VALUE rRFuse;
+  VALUE rPollHandle;
+
+  rRFuse      = rb_const_get(rb_cObject,rb_intern("RFuse"));
+  rPollHandle = rb_const_get(rRFuse,rb_intern("PollHandle"));
+
+  // We need a mark function here to ensure the ph is not GC'd
+  // between poll and notify_poll
+  return Data_Wrap_Struct(rPollHandle, NULL, pollhandle_destroy, ph);
+
+}
+
+VALUE pollhandle_init(VALUE module)
+{
+  VALUE cPollHandle = rb_define_class_under(module,"PollHandle",rb_cObject);
+
+  rb_define_alloc_func(cPollHandle,pollhandle_new);
+
+  rb_define_method(cPollHandle,"initialize",pollhandle_initialize,0);
+  rb_define_method(cPollHandle,"notifyPoll",pollhandle_notify_poll,0);
+
+  return cPollHandle;
+}

data/ext/pollhandle.h

@@ -0,0 +1,10 @@
+#include <fuse.h>
+#include <ruby.h>
+
+VALUE wrap_pollhandle(struct fuse_pollhandle *ph);
+
+VALUE pollhandle_new(VALUE class);
+VALUE pollhandle_initialize(VALUE self);
+VALUE pollhandle_notify_poll(VALUE self);
+
+VALUE pollhandle_init(VALUE module);

data/ext/rfuse.c

@@ -17,18 +17,44 @@
 #include "intern_rfuse.h"
 #include "filler.h"
 #include "context.h"
+
 #include "file_info.h"
+#include "pollhandle.h"
+#include "bufferwrapper.h"
 
 //this is a global variable where we store the fuse object
 static VALUE fuse_object;
 
+#if !defined(STR2CSTR)
+  #define STR2CSTR(X) StringValuePtr(X) 
+#endif
+
+// The ugliest hack I've seen today
+#if HAVE_RUBY_RUBY_H
+  static VALUE ruby_errinfo()
+  {
+    return rb_errinfo();
+  }
+#endif
+
 static int unsafe_return_error(VALUE *args)
 {
-  VALUE info;
-  info = rb_inspect(ruby_errinfo);
-  rb_backtrace();
-  printf ("ERROR %s\n",STR2CSTR(info));
-  return rb_funcall(info,rb_intern("errno"),0);
+ 
+  if (rb_respond_to(ruby_errinfo,rb_intern("errno"))) {
+    //We expect these and they get passed on the fuse so be quiet...
+    return rb_funcall(ruby_errinfo,rb_intern("errno"),0);
+  } else {
+    VALUE info;
+    info = rb_inspect(ruby_errinfo);
+    printf ("ERROR: Exception %s not an Errno:: !respond_to?(:errno) \n",STR2CSTR(info)); 
+    //We need the ruby_errinfo backtrace not fuse.loop ... rb_backtrace();
+    VALUE bt_ary = rb_funcall(ruby_errinfo, rb_intern("backtrace"),0);
+    int c;
+    for (c=0;c<RARRAY(bt_ary)->len;c++) {
+      printf("%s\n",RSTRING(RARRAY(bt_ary)->ptr[c])->ptr);
+    }
+    return Qnil;
+  }
 }
 
 static int return_error(int def_error)
@@ -39,14 +65,14 @@ static int return_error(int def_error)
   int error = 0;
   res=rb_protect((VALUE (*)())unsafe_return_error,Qnil,&error);
   if (error)
-  { //this exception has no errno method or something else 
-    //went wrong
-    printf ("ERROR: Not an Errno::xxx error or exception in exception!\n");
+  { 
+    //something went wrong resolving the exception
+    printf ("ERROR: Exception in exception!\n");
     return def_error;
   }
-  else
+  else 
   {
-    return FIX2INT(res);
+    return NIL_P(res) ? def_error : FIX2INT(res);
   }
 }
 
@@ -300,6 +326,7 @@ static int rf_open(const char *path,struct fuse_file_info *ffi)
   VALUE res;
   int error = 0;
   args[0]=rb_str_new2(path);
+  //GG: is args[1] kept on the stack and thus referenced from the GC's perspective?
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_open,(VALUE) args,&error);
   if (error)
@@ -308,6 +335,10 @@ static int rf_open(const char *path,struct fuse_file_info *ffi)
   }
   else
   {
+    if (TYPE(ffi->fh) != T_NONE) {
+       //Make sure the GC doesn't collect our FileHandle
+       rb_gc_register_address((VALUE*) &ffi->fh);
+    }
     return 0;
   }
 }
@@ -332,7 +363,9 @@ static int rf_release(const char *path, struct fuse_file_info *ffi)
   args[0]=rb_str_new2(path);
   args[1]=wrap_file_info(ffi);
   res=rb_protect((VALUE (*)())unsafe_release,(VALUE) args,&error);
-
+  if (TYPE(ffi->fh) != T_NONE) {
+     rb_gc_unregister_address((VALUE*) &ffi->fh);
+  }
   if (error)
   {
     return -(return_error(ENOENT));
@@ -701,6 +734,22 @@ static VALUE unsafe_read(VALUE *args)
         wrap_context(ctx),path,size,offset,ffi);
 }
 
+
+
+char*
+rb_str2cstr(str, len)
+    VALUE str;
+    long *len;
+{
+    StringValue(str);
+    if (len) *len = RSTRING_LEN(str);
+    else if (RTEST(ruby_verbose) &&  RSTRING_LEN(str) != ((long)strlen(RSTRING_PTR(str))) )  {
+	rb_warn("string contains \\0 character");
+    }
+    return RSTRING_PTR(str);
+}
+
+
 static int rf_read(const char *path,char * buf, size_t size,off_t offset,struct fuse_file_info *ffi)
 {
   VALUE args[4];
@@ -724,7 +773,7 @@ static int rf_read(const char *path,char * buf, size_t size,off_t offset,struct
   {
     length = NUM2LONG(rb_funcall(res, rb_intern("length"), 0));
     rbuf = rb_str2cstr(res, &length);
-    if (length<=size)
+    if (length<=(long)size)
     {
       memcpy(buf,rbuf,length);
       return length;
@@ -1442,19 +1491,82 @@ static int rf_bmap(const char *path, size_t blocksize, uint64_t *idx)
 
 //----------------------IOCTL
 
+static VALUE unsafe_ioctl(VALUE *args)
+{
+  VALUE path  = args[0];
+  VALUE cmd   = args[1];
+  VALUE arg   = args[2];
+  VALUE ffi   = args[3];
+  VALUE flags = args[4];
+  VALUE data  = args[5];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall( fuse_object, rb_intern("ioctl"), 7, wrap_context(ctx),
+    path, cmd, arg, ffi, flags, data);
+}
+
 static int rf_ioctl(const char *path, int cmd, void *arg,
   struct fuse_file_info *ffi, unsigned int flags, void *data)
 {
-  //TODO
+  VALUE args[6];
+  VALUE res;
+  int   error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = INT2NUM(cmd);
+  args[2] = wrap_buffer(arg);
+  args[3] = wrap_file_info(ffi);
+  args[4] = INT2NUM(flags);
+  args[5] = wrap_buffer(data);
+
+  res = rb_protect((VALUE (*)())unsafe_ioctl,(VALUE) args, &error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+
   return 0;
 }
 
 //----------------------POLL
 
+static VALUE unsafe_poll(VALUE *args)
+{
+  VALUE path     = args[0];
+  VALUE ffi      = args[1];
+  VALUE ph       = args[2];
+  VALUE reventsp = args[3];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall( fuse_object, rb_intern("poll"), 5, wrap_context(ctx),
+    path, ffi, ph, reventsp);
+}
+
 static int rf_poll(const char *path, struct fuse_file_info *ffi,
   struct fuse_pollhandle *ph, unsigned *reventsp)
 {
-  //TODO
+  VALUE args[4];
+  VALUE res;
+  int   error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = wrap_file_info(ffi);
+  args[2] = wrap_pollhandle(ph);
+  args[3] = INT2NUM(*reventsp);
+
+  res = rb_protect((VALUE (*)())unsafe_poll,(VALUE) args, &error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    *reventsp = NUM2INT(args[3]);
+  }
   return 0;
 }
 
@@ -1516,6 +1628,25 @@ VALUE rf_invalidate(VALUE self,VALUE path)
   return fuse_invalidate(inf->fuse,STR2CSTR(path)); //TODO: check if str?
 }
 
+//----------------------FD
+// Return /dev/fuse file descriptor for use with IO.select
+VALUE rf_fd(VALUE self)
+{
+ struct intern_fuse *inf;
+ Data_Get_Struct(self,struct intern_fuse,inf);
+ return INT2NUM(intern_fuse_fd(inf));
+}
+
+//----------------------PROCESS
+// Process one fuse command from the kernel
+// returns < 0 if we're not mounted.. won't be this simple in a mt scenario
+VALUE rf_process(VALUE self)
+{
+ struct intern_fuse *inf;
+ Data_Get_Struct(self,struct intern_fuse,inf);
+ return INT2NUM(intern_fuse_process(inf));
+}
+
 #define RESPOND_TO(obj,methodname) \
   rb_funcall( \
     obj,rb_intern("respond_to?"), \
@@ -1531,11 +1662,12 @@ static VALUE rf_initialize(
   VALUE libopts)
 {
   Check_Type(mountpoint, T_STRING);
-
-  // getdir is deprecated, use readdir instead
+  Check_Type(kernelopts, T_ARRAY);
+  Check_Type(libopts, T_ARRAY);
 
   struct intern_fuse *inf;
   Data_Get_Struct(self,struct intern_fuse,inf);
+
   if (RESPOND_TO(self,"getattr"))
     inf->fuse_op.getattr     = rf_getattr;
   if (RESPOND_TO(self,"readlink"))
@@ -1613,9 +1745,10 @@ static VALUE rf_initialize(
   if (RESPOND_TO(self,"bmap"))
     inf->fuse_op.bmap        = rf_bmap;
   if (RESPOND_TO(self,"ioctl"))
-    inf->fuse_op.ioctl       = rf_ioctl;     // TODO
+    inf->fuse_op.ioctl       = rf_ioctl;
   if (RESPOND_TO(self,"poll"))
-    inf->fuse_op.poll        = rf_poll;      // TODO
+    inf->fuse_op.poll        = rf_poll;
+
 
   struct fuse_args
     *kargs = rarray2fuseargs(kernelopts),
@@ -1634,7 +1767,7 @@ static VALUE rf_new(VALUE class)
   struct intern_fuse *inf;
   VALUE self;
   inf = intern_fuse_new();
-  self=Data_Wrap_Struct(class, 0,intern_fuse_destroy,inf);
+  self=Data_Wrap_Struct(class, 0, intern_fuse_destroy, inf);
   return self;
 }
 
@@ -1646,11 +1779,13 @@ VALUE rfuse_init(VALUE module)
 
   rb_define_method(cFuse,"initialize",rf_initialize,3);
   rb_define_method(cFuse,"loop",rf_loop,0);
-  rb_define_method(cFuse,"loop_mt",rf_loop_mt,0); //TODO: not until RIKE!
+  rb_define_method(cFuse,"loop_mt",rf_loop_mt,0); //TODO: multithreading
   rb_define_method(cFuse,"exit",rf_exit,0);
   rb_define_method(cFuse,"invalidate",rf_invalidate,1);
   rb_define_method(cFuse,"unmount",rf_unmount,0);
   rb_define_method(cFuse,"mountname",rf_mountname,0);
+  rb_define_method(cFuse,"fd",rf_fd,0);
+  rb_define_method(cFuse,"process",rf_process,0);
 
   return cFuse;
 }

data/sample/test-ruby.rb

@@ -347,7 +347,21 @@ class MyFuse < RFuse::Fuse
     return s
   end
 
+  def ioctl(ctx, path, cmd, arg, ffi, flags, data)
+    # FT: I was not been able to test it.
+    print "*** IOCTL: command: ", cmd, "\n"
+  end
+
+  def poll(ctx, path, ffi, ph, reventsp)
+    print "*** POLL: ", path, "\n"
+    # This is how we notify the caller if something happens:
+    ph.notifyPoll();
+    # when the GC harvests the object it calls fuse_pollhandle_destroy
+    # by itself.
+  end
+
   def init(ctx,rfuseconninfo)
+    print "RFuse-ng TestFS started\n"
     print "init called\n"
     print "proto_major: "
     print rfuseconninfo.proto_major
@@ -357,7 +371,13 @@ class MyFuse < RFuse::Fuse
 
 end #class Fuse
 
-fo = MyFuse.new("/tmp/fuse",["allow_other"],["debug"], MyDir.new("",493));
+# Parameters are intended to passed as array elements. This clearly don't
+# work with kernel options. The first element is discarded and the first
+# element after the -o is also discarded. Somebody please figure this out,
+# I already wasted half my weekend trying to solve this.
+
+fo = MyFuse.new("/tmp/fuse",["notparsed","-o notparsed,allow_other"],["debug"], MyDir.new("",0777));
+
 #kernel:  default_permissions,allow_other,kernel_cache,large_read,direct_io
 #         max_read=N,fsname=NAME
 #library: debug,hard_remove

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rfuse-ng
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  hash: 13
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 3
+  version: 0.5.3
 platform: ruby
 authors: 
 - !binary |
@@ -11,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-20 00:00:00 +02:00
+date: 2011-02-27 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -26,7 +32,6 @@ extra_rdoc_files:
 - README.ng
 - README.rfuse
 files: 
-- .gitignore
 - CHANGELOG.txt
 - LICENSE
 - README.ng
@@ -34,6 +39,8 @@ files:
 - Rakefile
 - THANKS
 - TODO.txt
+- ext/bufferwrapper.c
+- ext/bufferwrapper.h
 - ext/context.c
 - ext/context.h
 - ext/extconf.rb
@@ -45,6 +52,8 @@ files:
 - ext/helper.h
 - ext/intern_rfuse.c
 - ext/intern_rfuse.h
+- ext/pollhandle.c
+- ext/pollhandle.h
 - ext/rfuse.c
 - ext/rfuse.h
 - ext/rfuse_mod.c
@@ -55,26 +64,32 @@ homepage: http://rubyforge.org/projects/rfuse-ng
 licenses: 
 - LGPL
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+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"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: rfuse-ng
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Ruby language binding for FUSE

data/.gitignore

@@ -1,7 +0,0 @@
-pkg
-*.gemspec
-*.o
-*.so
-*~
-Makefile
-pushgem.sh