rfuse-ng 0.3.0 → 0.4.0

data/CHANGELOG.txt

@@ -1,3 +1,20 @@
+2010-06-20
+
+Only poll() and ioctl() are missing. Fixed compilation error
+on 64 bit systems and random segfault because of uninicialized
+memory
+
+2010-05-03: 0.3.0
+
+Fixed read() and write() bugs, updated example. Implemented
+truncate() in the example.
+
+Fuse operation fields are filled only, when the class respond_to the
+particular method.
+
+The example filesystem was tested with several hundred big files and
+all came back intact.
+
 2010-05-01: 0.2.0
 
 Switched to Fuse API 26 from 22. Fixed incompatibilities.
@@ -7,4 +24,4 @@ functions.
 
 2010-05-01: 0.1
 
-Froked from rfuse, fixed compile warnings, gemified.
+Forked from rfuse, fixed compile warnings, gemified.

data/README.ng

@@ -17,6 +17,34 @@ DEPENDENCIES
 ruby 1.8
 fuse 2.8
 
+INSTALLING
+==========
+
+To install it with rubygems:
+
+$ sudo gem install rfuse-ng
+
+To build from the source, install libfuse-dev, and:
+
+$ ruby ext/extconf.rb
+$ make
+
+...and there should be a rfuse_ng.so in the project root directory.
+
+USING
+=====
+
+Sorry, no docs here, see sample/test-ruby.rb
+
+To run the example:
+
+$ sudo mkdir /tmp/fuse
+$ sudo sample/test-ruby.rb
+
+..and there should be a filesystem mounted at /tmp/fuse.
+
+Umount should stop the example example filesystem program.
+
 AUTHOR
 ======
 

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "rfuse-ng"
-    gem.version = "0.3.0"
+    gem.version = "0.4.0"
     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/THANKS

@@ -1 +1,3 @@
 Many thanks to Peter Schrammel for the parent project rfuse.
+
+Thanks to Roland Pallai for providing valueable feedback.

data/ext/helper.c

@@ -1,23 +1,48 @@
 #include "helper.h"
 
-void rstat2stat(VALUE rstat, struct stat *statbuf){
-    statbuf->st_dev=FIX2ULONG(rb_funcall(rstat,rb_intern("dev"),0));
-    statbuf->st_ino=FIX2ULONG(rb_funcall(rstat,rb_intern("ino"),0));
-    statbuf->st_mode=FIX2UINT(rb_funcall(rstat,rb_intern("mode"),0));
-    statbuf->st_nlink=FIX2UINT(rb_funcall(rstat,rb_intern("nlink"),0));
-    statbuf->st_uid=FIX2UINT(rb_funcall(rstat,rb_intern("uid"),0));
-    statbuf->st_gid=FIX2UINT(rb_funcall(rstat,rb_intern("gid"),0));
-    statbuf->st_rdev=FIX2ULONG(rb_funcall(rstat,rb_intern("rdev"),0));
-    statbuf->st_size=FIX2ULONG(rb_funcall(rstat,rb_intern("size"),0));
-    statbuf->st_blksize=NUM2ULONG(rb_funcall(rstat,rb_intern("blksize"),0));
-    statbuf->st_blocks=NUM2ULONG(rb_funcall(rstat,rb_intern("blocks"),0));
-    statbuf->st_atime=NUM2ULONG(rb_funcall(rb_funcall(rstat,
-        rb_intern("atime"),0),rb_intern("to_i"),0));
-    statbuf->st_mtime=NUM2ULONG(rb_funcall(rb_funcall(rstat,
-                        rb_intern("mtime"),0),rb_intern("to_i"),0));
-    statbuf->st_ctime=NUM2ULONG(rb_funcall(rb_funcall(rstat,
-                        rb_intern("ctime"),0),rb_intern("to_i"),0));
-};
+void rstat2stat(VALUE rstat, struct stat *statbuf)
+{
+  statbuf->st_dev     = FIX2ULONG(rb_funcall(rstat,rb_intern("dev"),0));
+  statbuf->st_ino     = FIX2ULONG(rb_funcall(rstat,rb_intern("ino"),0));
+  statbuf->st_mode    = FIX2UINT(rb_funcall(rstat,rb_intern("mode"),0));
+  statbuf->st_nlink   = FIX2UINT(rb_funcall(rstat,rb_intern("nlink"),0));
+  statbuf->st_uid     = FIX2UINT(rb_funcall(rstat,rb_intern("uid"),0));
+  statbuf->st_gid     = FIX2UINT(rb_funcall(rstat,rb_intern("gid"),0));
+  statbuf->st_rdev    = FIX2ULONG(rb_funcall(rstat,rb_intern("rdev"),0));
+  statbuf->st_size    = FIX2ULONG(rb_funcall(rstat,rb_intern("size"),0));
+  statbuf->st_blksize = NUM2ULONG(rb_funcall(rstat,rb_intern("blksize"),0));
+  statbuf->st_blocks  = NUM2ULONG(rb_funcall(rstat,rb_intern("blocks"),0));
+  statbuf->st_atime   =
+    NUM2ULONG(rb_funcall(rb_funcall(rstat,rb_intern("atime"),0),rb_intern("to_i"),0));
+  statbuf->st_mtime   =
+    NUM2ULONG(rb_funcall(rb_funcall(rstat,rb_intern("mtime"),0),rb_intern("to_i"),0));
+  statbuf->st_ctime   =
+    NUM2ULONG(rb_funcall(rb_funcall(rstat,rb_intern("ctime"),0),rb_intern("to_i"),0));
+}
+
+void rstatvfs2statvfs(VALUE rstatvfs,struct statvfs *statvfsbuf) {
+  statvfsbuf->f_bsize   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_bsize"),0));
+  statvfsbuf->f_frsize  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_frsize"),0));
+  statvfsbuf->f_blocks  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_blocks"),0));
+  statvfsbuf->f_bfree   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_bfree"),0));
+  statvfsbuf->f_bavail  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_bavail"),0));
+  statvfsbuf->f_files   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_files"),0));
+  statvfsbuf->f_ffree   = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_ffree"),0));
+  statvfsbuf->f_favail  = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_favail"),0));
+  statvfsbuf->f_fsid    = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_fsid"),0));
+  statvfsbuf->f_flag    = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_flag"),0));
+  statvfsbuf->f_namemax = FIX2ULONG(rb_funcall(rstatvfs,rb_intern("f_namemax"),0));
+}
+
+void rfuseconninfo2fuseconninfo(VALUE rfuseconninfo,struct fuse_conn_info *fuseconninfo) {
+  fuseconninfo->proto_major   = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("proto_major"),0));
+  fuseconninfo->proto_minor   = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("proto_minor"),0));
+  fuseconninfo->async_read    = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("async_read"),0));
+  fuseconninfo->max_write     = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("max_write"),0));
+  fuseconninfo->max_readahead = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("max_readahead"),0));
+  fuseconninfo->capable       = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("capable"),0));
+  fuseconninfo->want          = FIX2UINT(rb_funcall(rfuseconninfo,rb_intern("want"),0));
+}
 
 struct fuse_args * rarray2fuseargs(VALUE rarray){
 

data/ext/helper.h

@@ -1,4 +1,5 @@
 #include <sys/stat.h>
+#include <sys/statvfs.h>
 #include <ruby.h>
 #include <fuse.h>
 
@@ -6,6 +7,8 @@
 #define _RHUSE_HELPER_H
 
 void rstat2stat(VALUE rstat,struct stat *statbuf);
+void rstatvfs2statvfs(VALUE rstatvfs,struct statvfs *statvfsbuf);
+void rfuseconninfo2fuseconninfo(VALUE rfuseconninfo,struct fuse_conn_info *fuseconninfo);
 struct fuse_args * rarray2fuseargs(VALUE rarray);
 
 #endif

data/ext/intern_rfuse.c

@@ -6,6 +6,7 @@
 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;
 };
 

data/ext/rfuse.c

@@ -201,7 +201,6 @@ static VALUE unsafe_mknod(VALUE *args)
   return rb_funcall(fuse_object,rb_intern("mknod"),4,wrap_context(ctx),path,mode,dev);
 }
 
-//calls getattr with path and expects something like FuseStat back
 static int rf_mknod(const char *path, mode_t mode,dev_t dev)
 {
   VALUE args[3];
@@ -345,10 +344,37 @@ static int rf_release(const char *path, struct fuse_file_info *ffi)
 }
 
 //----------------------FSYNC
+static VALUE unsafe_fsync(VALUE *args) {
+  VALUE path     = args[0];
+  VALUE datasync = args[1];
+  VALUE ffi      = args[2];
+
+  struct fuse_context *ctx=fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("fsync"), 4, wrap_context(ctx),
+    path, datasync, ffi);
+}
+
 static int rf_fsync(const char *path, int datasync, struct fuse_file_info *ffi)
 {
-  //TODO
-  return 0;
+  VALUE args[3];
+  VALUE res;
+  int error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = INT2NUM(datasync);
+  args[2] = wrap_file_info(ffi);
+
+  res = rb_protect((VALUE (*)())unsafe_fsync,(VALUE) args,&error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    return 0;
+  }
 }
 
 //----------------------FLUSH
@@ -751,10 +777,35 @@ static int rf_write(const char *path,const char *buf,size_t size,
 }
 
 //----------------------STATFS
+static VALUE unsafe_statfs(VALUE *args)
+{
+  VALUE path = args[0];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("statfs"),2,
+        wrap_context(ctx),path);
+}
+
 static int rf_statfs(const char * path, struct statvfs * vfsinfo)
 {
-  // TODO
-  return 0;
+  VALUE args[1];
+  VALUE res;
+  int error = 0;
+
+  args[0] = rb_str_new2(path);
+
+  res = rb_protect((VALUE (*)())unsafe_statfs,(VALUE) args,&error);
+
+  if (error || (res == Qnil))
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    rstatvfs2statvfs(res,vfsinfo);
+    return 0;
+  }
 }
 
 //----------------------SETXATTR
@@ -784,7 +835,7 @@ static int rf_setxattr(const char *path,const char *name,
   args[0]=rb_str_new2(path);
   args[1]=rb_str_new2(name);
   args[2]=rb_str_new(value,size);
-  args[3]=INT2NUM(size); //TODO:FIX would be faster
+  args[3]=INT2NUM(size);
   args[4]=INT2NUM(flags);
 
   res=rb_protect((VALUE (*)())unsafe_setxattr,(VALUE) args,&error);
@@ -882,14 +933,14 @@ static int rf_listxattr(const char *path,char *buf,
       } else {
         return -ERANGE;
       }
-      printf("destination: %s,%d\n",buf,size);
-      printf("source:      %s,%d\n",rbuf,length);
+      printf("destination: %s,%zd\n",buf,size);
+      printf("source:      %s,%zd\n",rbuf,length);
       return length;
       //TODO optimize,check lenght
     }
     else
     {
-      printf ("not copied: %s, %d\n",buf,length);
+      printf ("not copied: %s, %zd\n",buf,length);
       return length;
     }
   }
@@ -999,7 +1050,7 @@ static VALUE unsafe_fsyncdir(VALUE *args)
 
   struct fuse_context *ctx=fuse_get_context();
 
-  return rb_funcall(fuse_object,rb_intern("fsyncdir"),3,wrap_context(ctx),path,
+  return rb_funcall(fuse_object,rb_intern("fsyncdir"),4,wrap_context(ctx),path,
         meta,ffi);
 }
 
@@ -1024,62 +1075,278 @@ static int rf_fsyncdir(const char *path,int meta,struct fuse_file_info *ffi)
 }
 
 //----------------------INIT
+static VALUE unsafe_init(VALUE* args)
+{
+  VALUE rfuseconninfo = args[0];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("init"),2,wrap_context(ctx),
+    rfuseconninfo);
+}
 
 static void *rf_init(struct fuse_conn_info *conn)
 {
-  // TODO
-  return NULL;
+  VALUE args[1];
+  VALUE res;
+  int error = 0;
+
+  //Create a struct for the conn_info
+  VALUE s  = rb_const_get(rb_cObject,rb_intern("Struct"));
+  VALUE fci = rb_funcall(s,rb_intern("new"),7,
+    ID2SYM(rb_intern("proto_major")),
+    ID2SYM(rb_intern("proto_minor")),
+    ID2SYM(rb_intern("async_read")),
+    ID2SYM(rb_intern("max_write")),
+    ID2SYM(rb_intern("max_readahead")),
+    ID2SYM(rb_intern("capable")),
+    ID2SYM(rb_intern("want"))
+  );
+
+  VALUE fcio = rb_funcall(fci,rb_intern("new"),7,
+    UINT2NUM(conn->proto_major),
+    UINT2NUM(conn->proto_minor),
+    UINT2NUM(conn->async_read),
+    UINT2NUM(conn->max_write),
+    UINT2NUM(conn->max_readahead),
+    UINT2NUM(conn->capable),
+    UINT2NUM(conn->want)
+  );
+
+  args[0] = fcio;
+
+  res = rb_protect((VALUE (*)())unsafe_init,(VALUE) args,&error);
+
+  if (error)
+  {
+    return NULL;
+  }
+  else
+  {
+    return (void *)res;
+  }
 }
 
 //----------------------DESTROY
 
+static VALUE unsafe_destroy(VALUE* args)
+{
+  VALUE user_data = args[0];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("destroy"),2,wrap_context(ctx),
+    user_data);
+}
+
 static void rf_destroy(void *user_data)
 {
-  // TODO
+  VALUE args[1];
+  int error = 0;
+
+  args[0] = (VALUE)user_data;
+
+  rb_protect((VALUE (*)())unsafe_destroy,(VALUE) args,&error);
+  // TODO: some kind of logging would be nice here.
 }
 
 //----------------------ACCESS
 
+static VALUE unsafe_access(VALUE* args)
+{
+  VALUE path = args[0];
+  VALUE mask = args[1];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("access"),3,wrap_context(ctx),
+    path, mask);
+}
+
 static int rf_access(const char *path, int mask)
 {
-  // TODO
-  return 0;
+  VALUE args[2];
+  VALUE res;
+  int error = 0;
+  args[0] = rb_str_new2(path);
+  args[1] = INT2NUM(mask);
+  res = rb_protect((VALUE (*)())unsafe_access,(VALUE) args,&error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    return 0;
+  }
 }
 
 //----------------------CREATE
 
+static VALUE unsafe_create(VALUE* args)
+{
+  VALUE path = args[0];
+  VALUE mode = args[1];
+  VALUE ffi  = args[2];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("create"),4,wrap_context(ctx),
+    path, mode, ffi);
+}
+
 static int rf_create(const char *path, mode_t mode,
   struct fuse_file_info *ffi)
 {
-  // TODO
-  return 0;
+  VALUE args[3];
+  VALUE res;
+  int error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = INT2NUM(mode);
+  args[2] = wrap_file_info(ffi);
+
+  res = rb_protect((VALUE (*)())unsafe_create,(VALUE) args,&error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    return 0;
+  }
 }
 
 //----------------------FTRUNCATE
 
+static VALUE unsafe_ftruncate(VALUE* args)
+{
+  VALUE path = args[0];
+  VALUE size = args[1];
+  VALUE ffi  = args[2];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("ftruncate"),4,wrap_context(ctx),
+    path, size, ffi);
+}
+
 static int rf_ftruncate(const char *path, off_t size,
   struct fuse_file_info *ffi)
 {
-  // TODO
-  return 0;
+  VALUE args[3];
+  VALUE res;
+  int error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = INT2NUM(size);
+  args[2] = wrap_file_info(ffi);
+
+  res = rb_protect((VALUE (*)())unsafe_ftruncate,(VALUE) args,&error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    return 0;
+  }
 }
 
 //----------------------FGETATTR
 
+static VALUE unsafe_fgetattr(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  = args[1];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("fgetattr"),3,wrap_context(ctx),
+    path,ffi);
+}
+
 static int rf_fgetattr(const char *path, struct stat *stbuf,
   struct fuse_file_info *ffi)
 {
-  // TODO
-  return 0;
+  VALUE args[2];
+  VALUE res;
+  int error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = wrap_file_info(ffi);
+
+  res=rb_protect((VALUE (*)())unsafe_fgetattr,(VALUE) args,&error);
+
+  if (error || (res == Qnil))
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    rstat2stat(res,stbuf);
+    return 0;
+  }
 }
 
 //----------------------LOCK
 
+static VALUE unsafe_lock(VALUE *args)
+{
+  VALUE path = args[0];
+  VALUE ffi  = args[1];
+  VALUE cmd  = args[2];
+  VALUE lock = args[3];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall(fuse_object,rb_intern("lock"),5,wrap_context(ctx),
+    path,ffi,cmd,lock);
+}
+
 static int rf_lock(const char *path, struct fuse_file_info *ffi,
   int cmd, struct flock *lock)
 {
-  // TODO
-  return 0;
+  VALUE args[4];
+  VALUE res;
+  int error = 0;
+
+  //Create a struct for the lock structure
+  VALUE s  = rb_const_get(rb_cObject,rb_intern("Struct"));
+  VALUE lockc = rb_funcall(s,rb_intern("new"),5,
+    ID2SYM(rb_intern("l_type")),
+    ID2SYM(rb_intern("l_whence")),
+    ID2SYM(rb_intern("l_start")),
+    ID2SYM(rb_intern("l_len")),
+    ID2SYM(rb_intern("l_pid"))
+  );
+
+  VALUE locko = rb_funcall(lockc,rb_intern("new"),5,
+    UINT2NUM(lock->l_type),
+    UINT2NUM(lock->l_whence),
+    UINT2NUM(lock->l_start),
+    UINT2NUM(lock->l_len),
+    UINT2NUM(lock->l_pid)
+  );
+
+  args[0] = rb_str_new2(path);
+  args[1] = wrap_file_info(ffi);
+  args[2] = INT2NUM(cmd);
+  args[3] = locko;
+
+  res = rb_protect((VALUE (*)())unsafe_lock,(VALUE) args,&error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    return 0;
+  }
 }
 
 //----------------------UTIMENS
@@ -1138,10 +1405,39 @@ static int rf_utimens(const char * path, const struct timespec tv[2])
 
 //----------------------BMAP
 
+static VALUE unsafe_bmap(VALUE *args)
+{
+  VALUE path      = args[0];
+  VALUE blocksize = args[1];
+  VALUE idx       = args[2];
+
+  struct fuse_context *ctx = fuse_get_context();
+
+  return rb_funcall( fuse_object, rb_intern("bmap"), 4, wrap_context(ctx),
+    path, blocksize, idx);
+}
+
 static int rf_bmap(const char *path, size_t blocksize, uint64_t *idx)
 {
-  //TODO
-  return 0;
+  VALUE args[3];
+  VALUE res;
+  int   error = 0;
+
+  args[0] = rb_str_new2(path);
+  args[1] = INT2NUM(blocksize);
+  args[2] = LL2NUM(*idx);
+
+  res = rb_protect((VALUE (*)())unsafe_bmap,(VALUE) args, &error);
+
+  if (error)
+  {
+    return -(return_error(ENOENT));
+  }
+  else
+  {
+    *idx = NUM2LL(args[2]);
+    return 0;
+  }
 }
 
 //----------------------IOCTL
@@ -1275,13 +1571,13 @@ static VALUE rf_initialize(
   if (RESPOND_TO(self,"write"))
     inf->fuse_op.write       = rf_write;
   if (RESPOND_TO(self,"statfs"))
-    inf->fuse_op.statfs      = rf_statfs;   //TODO
+    inf->fuse_op.statfs      = rf_statfs;
   if (RESPOND_TO(self,"flush"))
     inf->fuse_op.flush       = rf_flush;
   if (RESPOND_TO(self,"release"))
     inf->fuse_op.release     = rf_release;
   if (RESPOND_TO(self,"fsync"))
-    inf->fuse_op.fsync       = rf_fsync;    // TODO
+    inf->fuse_op.fsync       = rf_fsync;
   if (RESPOND_TO(self,"setxattr"))
     inf->fuse_op.setxattr    = rf_setxattr;
   if (RESPOND_TO(self,"getxattr"))
@@ -1299,23 +1595,23 @@ static VALUE rf_initialize(
   if (RESPOND_TO(self,"fsyncdir"))
     inf->fuse_op.fsyncdir    = rf_fsyncdir;
   if (RESPOND_TO(self,"init"))
-    inf->fuse_op.init        = rf_init;      // TODO
+    inf->fuse_op.init        = rf_init;
   if (RESPOND_TO(self,"destroy"))
-    inf->fuse_op.destroy     = rf_destroy;   // TODO
+    inf->fuse_op.destroy     = rf_destroy;
   if (RESPOND_TO(self,"access"))
-    inf->fuse_op.access      = rf_access;    // TODO
+    inf->fuse_op.access      = rf_access;
   if (RESPOND_TO(self,"create"))
-    inf->fuse_op.create      = rf_create;    // TODO
+    inf->fuse_op.create      = rf_create;
   if (RESPOND_TO(self,"ftruncate"))
-    inf->fuse_op.ftruncate   = rf_ftruncate; // TODO
+    inf->fuse_op.ftruncate   = rf_ftruncate;
   if (RESPOND_TO(self,"fgetattr"))
-    inf->fuse_op.fgetattr    = rf_fgetattr;  // TODO
+    inf->fuse_op.fgetattr    = rf_fgetattr;
   if (RESPOND_TO(self,"lock"))
-    inf->fuse_op.lock        = rf_lock;      // TODO
+    inf->fuse_op.lock        = rf_lock;
   if (RESPOND_TO(self,"utimens"))
     inf->fuse_op.utimens     = rf_utimens;
   if (RESPOND_TO(self,"bmap"))
-    inf->fuse_op.bmap        = rf_bmap;      // TODO
+    inf->fuse_op.bmap        = rf_bmap;
   if (RESPOND_TO(self,"ioctl"))
     inf->fuse_op.ioctl       = rf_ioctl;     // TODO
   if (RESPOND_TO(self,"poll"))

data/sample/test-ruby.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby -rubygems
+#!/usr/bin/ruby
 
 # TestFS for RFuse-ng
 
@@ -122,26 +122,43 @@ class MyFile
   end
 end
 
-#TODO: atime,mtime,ctime...nicer classes not only fixnums
 class Stat
   attr_accessor :uid,:gid,:mode,:size,:atime,:mtime,:ctime 
   attr_accessor :dev,:ino,:nlink,:rdev,:blksize,:blocks
-  def initialize(uid,gid,mode,size,atime,mtime,ctime,rdev,blocks,nlink,dev,ino,blksize)
-    @uid=uid
-    @gid=gid
-    @mode=mode
-    @size=size
-    @atime=atime
-    @mtime=mtime
-    @ctime=ctime
-    @dev=dev
-    @ino=ino
-    @nlink=nlink
-    @rdev=rdev
-    @blksize=blksize
-    @blocks=blocks
-  end
-end #class Stat
+  def initialize
+    @uid     = 0
+    @gid     = 0
+    @mode    = 0
+    @size    = 0
+    @atime   = 0
+    @mtime   = 0
+    @ctime   = 0
+    @dev     = 0
+    @ino     = 0
+    @nlink   = 0
+    @rdev    = 0
+    @blksize = 0
+    @blocks  = 0
+  end
+end
+
+class StatVfs
+  attr_accessor :f_bsize,:f_frsize,:f_blocks,:f_bfree,:f_bavail
+  attr_accessor :f_files,:f_ffree,:f_favail,:f_fsid,:f_flag,:f_namemax
+  def initialize
+    @f_bsize    = 0
+    @f_frsize   = 0
+    @f_blocks   = 0
+    @f_bfree    = 0
+    @f_bavail   = 0
+    @f_files    = 0
+    @f_ffree    = 0
+    @f_favail   = 0
+    @f_fsid     = 0
+    @f_flag     = 0
+    @f_namemax  = 0
+  end
+end
 
 class MyFuse < RFuse::Fuse
 
@@ -168,8 +185,13 @@ class MyFuse < RFuse::Fuse
     d=@root.search(path)
     if d.isdir then
       d.each {|name,obj| 
-        stat=Stat.new(obj.uid,obj.gid,obj.mode,obj.size,obj.actime,obj.modtime,
-        0,0,0,0,0,0,0)
+        stat = Stat.new
+        stat.uid   = obj.uid
+        stat.gid   = obj.gid
+        stat.mode  = obj.mode
+        stat.size  = obj.size
+        stat.atime = obj.actime
+        stat.mtime = obj.modtime
         filler.push(name,stat,0)
       }
     else
@@ -178,9 +200,14 @@ class MyFuse < RFuse::Fuse
   end
 
   def getattr(ctx,path)
-    d=@root.search(path)
-    stat=Stat.new(d.uid,d.gid,d.mode,d.size,d.actime,d.modtime,
-      0,0,0,0,0,0,0)
+    d = @root.search(path)
+    stat = Stat.new
+    stat.uid   = d.uid
+    stat.gid   = d.gid
+    stat.mode  = d.mode
+    stat.size  = d.size
+    stat.atime = d.actime
+    stat.mtime = d.modtime
     return stat
   end #getattr
 
@@ -192,8 +219,8 @@ class MyFuse < RFuse::Fuse
     @root.insert_obj(MyFile.new(File.basename(path),mode,ctx.uid,ctx.gid),path)
   end #mknod
 
-  #def open(ctx,path,ffi)
-  #end
+  def open(ctx,path,ffi)
+  end
 
   #def release(ctx,path,fi)
   #end
@@ -303,6 +330,31 @@ class MyFuse < RFuse::Fuse
   #def fsyncdir(ctx,path,meta,ffi)
   #end
 
+  # Some random numbers to show with df command
+  def statfs(ctx,path)
+    s = StatVfs.new
+    s.f_bsize    = 1024
+    s.f_frsize   = 1024
+    s.f_blocks   = 1000000
+    s.f_bfree    = 500000
+    s.f_bavail   = 990000
+    s.f_files    = 10000
+    s.f_ffree    = 9900
+    s.f_favail   = 9900
+    s.f_fsid     = 23423
+    s.f_flag     = 0
+    s.f_namemax  = 10000
+    return s
+  end
+
+  def init(ctx,rfuseconninfo)
+    print "init called\n"
+    print "proto_major: "
+    print rfuseconninfo.proto_major
+    print "\n"
+    return nil
+  end
+
 end #class Fuse
 
 fo = MyFuse.new("/tmp/fuse",["allow_other"],["debug"], MyDir.new("",493));
@@ -318,7 +370,5 @@ end
 begin
   fo.loop
 rescue
-  f=File.new("/tmp/error","w+")
-  f.puts "Error:" + $!
-  f.close
+  print "Error:" + $!
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rfuse-ng
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - !binary |
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-03 00:00:00 +02:00
+date: 2010-06-20 00:00:00 +02:00
 default_executable: 
 dependencies: []