jio 0.1

data/ext/jio/file.h

@@ -0,0 +1,20 @@
+#ifndef JIO_FILE_H
+#define JIO_FILE_H
+
+#define JIO_FILE_CLOSED 0x01
+
+typedef struct {
+    jfs_t *fs;
+    int flags;
+} jio_jfs_wrapper;
+
+#define JioAssertFile(obj) JioAssertType(obj, rb_cJioFile, "JIO::File")
+#define JioGetFile(obj) \
+    jio_jfs_wrapper *file = NULL; \
+    JioAssertFile(obj); \
+    Data_Get_Struct(obj, jio_jfs_wrapper, file); \
+    if (!file) rb_raise(rb_eTypeError, "uninitialized JIO file handle!");
+
+void _init_rb_jio_file();
+
+#endif

data/ext/jio/jio_ext.c

@@ -0,0 +1,119 @@
+#include "jio_ext.h"
+
+VALUE mJio;
+VALUE rb_cJioFile;
+VALUE rb_cJioTransaction;
+
+VALUE jio_zero;
+VALUE jio_empty_view;
+
+#ifdef HAVE_RUBY_ENCODING_H
+rb_encoding *binary_encoding;
+#endif
+
+static VALUE jio_s_total;
+static VALUE jio_s_invalid;
+static VALUE jio_s_in_progress;
+static VALUE jio_s_broken;
+static VALUE jio_s_corrupt;
+static VALUE jio_s_reapplied;
+
+/*
+ *  call-seq:
+ *     JIO.check("/path/file", JIO::J_CLEANUP)    =>  Hash
+ *
+ *  Checks and repairs a file previously created and managed through libjio.
+ *
+ * === Examples
+ *     JIO.check("/path/file", JIO::J_CLEANUP)    =>  Hash
+ *
+*/
+
+static VALUE rb_jio_s_check(JIO_UNUSED VALUE jio, VALUE path, VALUE flags)
+{
+    int ret;
+    VALUE result;
+    struct jfsck_result res;
+    Check_Type(path, T_STRING);
+    Check_Type(flags, T_FIXNUM);
+    ret = jfsck(RSTRING_PTR(path), NULL, &res, FIX2UINT(flags));
+    if (ret == J_ENOMEM) rb_memerror();
+    if (ret < 0) rb_sys_fail("jfsck");
+    result = rb_hash_new();
+    rb_hash_aset(result, jio_s_total, INT2NUM(res.total));
+    rb_hash_aset(result, jio_s_invalid, INT2NUM(res.invalid));
+    rb_hash_aset(result, jio_s_in_progress, INT2NUM(res.in_progress));
+    rb_hash_aset(result, jio_s_broken, INT2NUM(res.broken));
+    rb_hash_aset(result, jio_s_corrupt, INT2NUM(res.corrupt));
+    rb_hash_aset(result, jio_s_reapplied, INT2NUM(res.reapplied));
+    return result;
+}
+
+void
+Init_jio_ext()
+{
+    mJio = rb_define_module("JIO");
+
+/*
+ *  Generic globals (Fixnum 0 and empty Array for blank transaction views)
+ */
+    jio_zero = INT2NUM(0);
+    rb_gc_register_address(&jio_empty_view);
+    jio_empty_view = rb_ary_new();
+
+    jio_s_total = ID2SYM(rb_intern("total"));
+    jio_s_invalid = ID2SYM(rb_intern("invalid"));
+    jio_s_in_progress = ID2SYM(rb_intern("in_progress"));
+    jio_s_broken = ID2SYM(rb_intern("broken"));
+    jio_s_corrupt = ID2SYM(rb_intern("corrupt"));
+    jio_s_reapplied = ID2SYM(rb_intern("reapplied"));
+
+#ifdef HAVE_RUBY_ENCODING_H
+    binary_encoding = rb_enc_find("binary");
+#endif
+
+/*
+ *  Journal check specific constants
+ */
+    rb_define_const(mJio, "J_ESUCCESS", INT2NUM(J_ESUCCESS));
+    rb_define_const(mJio, "J_ENOENT", INT2NUM(J_ENOENT));
+    rb_define_const(mJio, "J_ENOJOURNAL", INT2NUM(J_ENOJOURNAL));
+    rb_define_const(mJio, "J_ENOMEM", INT2NUM(J_ENOMEM));
+    rb_define_const(mJio, "J_ECLEANUP", INT2NUM(J_ECLEANUP));
+    rb_define_const(mJio, "J_EIO", INT2NUM(J_EIO));
+
+/*
+ *  jfscheck specific constants
+ */
+    rb_define_const(mJio, "J_CLEANUP", INT2NUM(J_CLEANUP));
+
+/*
+ *  Open specific constants (POSIX)
+ */
+    rb_define_const(mJio, "RDONLY", INT2NUM(O_RDONLY));
+    rb_define_const(mJio, "WRONLY", INT2NUM(O_WRONLY));
+    rb_define_const(mJio, "RDWR", INT2NUM(O_RDWR));
+    rb_define_const(mJio, "CREAT", INT2NUM(O_CREAT));
+    rb_define_const(mJio, "EXCL", INT2NUM(O_EXCL));
+    rb_define_const(mJio, "TRUNC", INT2NUM(O_TRUNC));
+    rb_define_const(mJio, "APPEND", INT2NUM(O_APPEND));
+    rb_define_const(mJio, "NONBLOCK", INT2NUM(O_NONBLOCK));
+    rb_define_const(mJio, "NDELAY", INT2NUM(O_NDELAY));
+    rb_define_const(mJio, "SYNC", INT2NUM(O_SYNC));
+    rb_define_const(mJio, "ASYNC", INT2NUM(O_ASYNC));
+
+/*
+ *  lseek specific constants
+ */
+    rb_define_const(mJio, "SEEK_SET", INT2NUM(SEEK_SET));
+    rb_define_const(mJio, "SEEK_CUR", INT2NUM(SEEK_CUR));
+    rb_define_const(mJio, "SEEK_END", INT2NUM(SEEK_END));
+
+/*
+ *  JIO module methods
+ */
+    rb_define_module_function(mJio, "check", rb_jio_s_check, 2);
+
+    _init_rb_jio_file();
+    _init_rb_jio_transaction();
+}

data/ext/jio/jio_ext.h

@@ -0,0 +1,46 @@
+#ifndef JIO_EXT_H
+#define JIO_EXT_H
+
+#include "libjio.h"
+#include "trans.h"
+#include "ruby.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+/* Compiler specific */
+
+#if defined(__GNUC__) && (__GNUC__ >= 3)
+#define JIO_UNUSED __attribute__ ((unused))
+#define JIO_NOINLINE __attribute__ ((noinline))
+#else
+#define JIO_UNUSED
+#define JIO_NOINLINE
+#endif
+
+#include "jio_prelude.h"
+
+#define JioAssertType(obj, type, desc) \
+    if (!rb_obj_is_kind_of(obj,type)) \
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s): %s", rb_obj_classname(obj), desc, RSTRING_PTR(rb_obj_as_string(obj)));
+
+#define AssertOffset(off) \
+    Check_Type(off, T_FIXNUM); \
+    if (off < jio_zero) rb_raise(rb_eArgError, "offset must be >= 0"); \
+
+#define AssertLength(len) \
+    Check_Type(len, T_FIXNUM); \
+    if (len < jio_zero) rb_raise(rb_eArgError, "length must be >= 0"); \
+
+#include "file.h"
+#include "transaction.h"
+
+extern VALUE mJio;
+extern VALUE rb_cJioFile;
+extern VALUE rb_cJioTransaction;
+
+extern VALUE jio_zero;
+extern VALUE jio_empty_view;
+
+#endif

data/ext/jio/jio_prelude.h

@@ -0,0 +1,22 @@
+#ifndef JIO_PRELUDE_H
+#define JIO_PRELUDE_H
+
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+
+#ifdef RUBINIUS
+#include "rubinius.h"
+#else
+#ifdef JRUBY
+#include "jruby.h"
+#else
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#include "ruby19.h"
+#else
+#include "ruby18.h"
+#endif
+#endif
+#endif
+
+#endif

data/ext/jio/jruby.h

@@ -0,0 +1,20 @@
+#ifndef JIO_JRUBY_H
+#define JIO_JRUBY_H
+
+#include "st.h"
+
+/* XXX */
+#define JioEncode(str) str
+#ifndef THREAD_PASS
+#define THREAD_PASS rb_thread_schedule();
+#endif
+
+#define TRAP_BEG
+#define TRAP_END
+
+#undef rb_errinfo
+#define rb_errinfo() (rb_gv_get("$!"))
+
+#define HAVE_RB_THREAD_BLOCKING_REGION 1
+
+#endif

data/ext/jio/rubinius.h

@@ -0,0 +1,22 @@
+#ifndef JIO_RUBINIUS_H
+#define JIO_RUBINIUS_H
+
+#define RSTRING_NOT_MODIFIED
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#include <ruby/io.h>
+extern rb_encoding *binary_encoding;
+#define JioEncode(str) rb_enc_associate(str, binary_encoding)
+#else
+#include "st.h"
+#define JioEncode(str) str
+#endif
+
+#define TRAP_BEG
+#define TRAP_END
+
+#define THREAD_PASS rb_thread_schedule();
+
+#endif

data/ext/jio/ruby18.h

@@ -0,0 +1,43 @@
+#ifndef JIO_RUBY18_H
+#define JIO_RUBY18_H
+
+#define THREAD_PASS rb_thread_schedule();
+#define JioEncode(str) str
+#include "rubyio.h"
+#include "rubysig.h"
+#include "st.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+/*
+ * partial emulation of the 1.9 rb_thread_blocking_region under 1.8,
+ * this is enough for dealing with blocking I/O functions in the
+ * presence of threads.
+ */
+
+#define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
+typedef void rb_unblock_function_t(void *);
+typedef VALUE rb_blocking_function_t(void *);
+static VALUE
+rb_thread_blocking_region(
+  rb_blocking_function_t *func, void *data1,
+  JIO_UNUSED rb_unblock_function_t *ubf,
+  JIO_UNUSED void *data2)
+{
+  VALUE rv;
+  TRAP_BEG;
+  rv = func(data1);
+  TRAP_END;
+  return rv;
+}
+
+struct timeval rb_time_interval _((VALUE));
+
+#define rb_errinfo() ruby_errinfo
+
+#endif

data/ext/jio/ruby19.h

@@ -0,0 +1,15 @@
+#ifndef JIO_RUBY19_H
+#define JIO_RUBY19_H
+
+#include <ruby/encoding.h>
+#include <ruby/io.h>
+extern rb_encoding *binary_encoding;
+#define JioEncode(str) rb_enc_associate(str, binary_encoding)
+#ifndef THREAD_PASS
+#define THREAD_PASS rb_thread_schedule();
+#endif
+
+#define TRAP_BEG
+#define TRAP_END
+
+#endif

data/ext/jio/transaction.c

@@ -0,0 +1,260 @@
+#include "jio_ext.h"
+
+/*
+ *  Generic transaction error handler
+ */
+static inline VALUE rb_jio_transaction_result(ssize_t ret, const char *ctx)
+{
+    char err_buf[BUFSIZ];
+    if (ret >= 0) return Qtrue;
+    if (ret == -1) snprintf(err_buf, BUFSIZ, "JIO transaction error on %s (atomic warranties preserved)", ctx);
+    if (ret == -2) snprintf(err_buf, BUFSIZ, "JIO transaction error on %s (atomic warranties broken)", ctx);
+    rb_sys_fail(err_buf);
+}
+
+/*
+ *  GC callbacks for JIO::Transaction
+ */
+void rb_jio_mark_transaction(void *ptr)
+{
+    jio_jtrans_wrapper *trans = (jio_jtrans_wrapper *)ptr;
+    if (ptr) rb_gc_mark(trans->views);
+}
+
+void rb_jio_free_transaction(void *ptr)
+{
+    jio_jtrans_wrapper *trans = (jio_jtrans_wrapper *)ptr;
+    if(trans) {
+        if (trans->trans != NULL && !(trans->flags & JIO_TRANSACTION_RELEASED)) jtrans_free(trans->trans);
+        xfree(trans);
+    }
+}
+
+/*
+ *  call-seq:
+ *     transaction.read(2, 2)    =>  boolean
+ *
+ *  Reads X bytes from Y offset into a transaction view. The buffered data is only visible once the
+ *  transaction has been committed.
+ *
+ * === Examples
+ *     transaction.read(2, 2)    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_read(VALUE obj, VALUE length, VALUE offset)
+{
+    int ret;
+    VALUE buf;
+    ssize_t len;
+    JioGetTransaction(obj);
+    AssertLength(length);
+    AssertOffset(offset);
+    len = (ssize_t)FIX2LONG(length);
+    buf = rb_str_new(0, len);
+    TRAP_BEG;
+    ret = jtrans_add_r(trans->trans, RSTRING_PTR(buf), len, (off_t)NUM2OFFT(offset));
+    TRAP_END;
+    if (ret == -1) rb_sys_fail("jtrans_add_r");
+    if (NIL_P(trans->views)) trans->views = rb_ary_new();
+    rb_ary_push(trans->views, JioEncode(buf));
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     transaction.views    =>  Array
+ *
+ *  Returns a sequence of buffers representing previous transactional read operations. The result is
+ *  always an empty Array if the transaction hasn't been committed yet. Operations will be applied in
+ *  order, and overlapping operations are permitted, in which case the latest one will prevail.
+ *
+ * === Examples
+ *     transaction.views    =>  Array
+ *
+*/
+
+static VALUE rb_jio_transaction_views(VALUE obj)
+{
+    jtrans_t *t = NULL;
+    JioGetTransaction(obj);
+    t = trans->trans;
+    if ((t->flags & J_COMMITTED) && !NIL_P(trans->views)) return trans->views;
+    return jio_empty_view;
+}
+
+/*
+ *  call-seq:
+ *     transaction.write("data", 2)    =>  boolean
+ *
+ *  Spawns a write operation from a given buffer to X offset for this transaction. Only written to disk
+ *  when the transaction has been committed. Operations will be applied in order, and overlapping
+ *  operations are permitted, in which case the latest one will prevail.
+ *
+ * === Examples
+ *     transaction.write("data", 2)    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_write(VALUE obj, VALUE buf, VALUE offset)
+{
+    int ret;
+    JioGetTransaction(obj);
+    Check_Type(buf, T_STRING);
+    AssertOffset(offset);
+    TRAP_BEG;
+    ret = jtrans_add_w(trans->trans, RSTRING_PTR(buf), (size_t)RSTRING_LEN(buf), (off_t)NUM2OFFT(offset));
+    TRAP_END;
+    if (ret == -1) rb_sys_fail("jtrans_add_w");
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     transaction.commit    =>  boolean
+ *
+ *  Reads / writes all operations for this transaction to / from disk, in the order they were added.
+ *  After this function returns successfully, all the data can be trusted to be on the disk. The commit
+ *  is atomic with regards to other processes using libjio, but not accessing directly to the file.
+ *
+ * === Examples
+ *     transaction.commit    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_commit(VALUE obj)
+{
+    ssize_t ret;
+    JioGetTransaction(obj);
+    TRAP_BEG;
+    ret = jtrans_commit(trans->trans);
+    TRAP_END;
+    return rb_jio_transaction_result(ret, "commit");
+}
+
+/*
+ *  call-seq:
+ *     transaction.rollback    =>  boolean
+ *
+ *  This function atomically undoes a previous committed transaction. After its successful return, the
+ *  data can be trusted to be on disk. The read operations will be ignored as we only care about on disk
+ *  consistency.
+ *
+ * === Examples
+ *     transaction.rollback    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_rollback(VALUE obj)
+{
+    ssize_t ret;
+    VALUE res;
+    JioGetTransaction(obj);
+    TRAP_BEG;
+    ret = jtrans_rollback(trans->trans);
+    TRAP_END;
+    res = rb_jio_transaction_result(ret, "rollback");
+    if (!NIL_P(trans->views)) rb_ary_clear(trans->views);
+    return res;
+}
+
+/*
+ *  call-seq:
+ *     transaction.release    =>  nil
+ *
+ *  Free all transaction state and operation buffers
+ *
+ * === Examples
+ *     transaction.release    =>  nil
+ *
+*/
+
+static VALUE rb_jio_transaction_release(VALUE obj)
+{
+    JioGetTransaction(obj);
+    TRAP_BEG;
+    jtrans_free(trans->trans);
+    TRAP_END;
+    trans->flags |= JIO_TRANSACTION_RELEASED;
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     transaction.committed?    =>  boolean
+ *
+ *  Determines if this transaction has been committed.
+ *
+ * === Examples
+ *     transaction.committed?    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_committed_p(VALUE obj)
+{
+    jtrans_t *t = NULL;
+    JioGetTransaction(obj);
+    t = trans->trans;
+    return (t->flags & J_COMMITTED) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     transaction.rollbacked?    =>  boolean
+ *
+ *  Determines if this transaction has been rolled back.
+ *
+ * === Examples
+ *     transaction.rollbacked?    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_rollbacked_p(VALUE obj)
+{
+    jtrans_t *t = NULL;
+    JioGetTransaction(obj);
+    t = trans->trans;
+    return (t->flags & J_ROLLBACKED) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     transaction.rollbacking?    =>  boolean
+ *
+ *  Determines if this transaction is in the process of being rolled back.
+ *
+ * === Examples
+ *     transaction.rollbacking?    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_transaction_rollbacking_p(VALUE obj)
+{
+    jtrans_t *t = NULL;
+    JioGetTransaction(obj);
+    t = trans->trans;
+    return (t->flags & J_ROLLBACKING) ? Qtrue : Qfalse;
+}
+
+void _init_rb_jio_transaction()
+{
+    rb_define_const(mJio, "J_NOLOCK", INT2NUM(J_NOLOCK));
+    rb_define_const(mJio, "J_NOROLLBACK", INT2NUM(J_NOROLLBACK));
+    rb_define_const(mJio, "J_LINGER", INT2NUM(J_LINGER));
+    rb_define_const(mJio, "J_COMMITTED", INT2NUM(J_COMMITTED));
+    rb_define_const(mJio, "J_ROLLBACKED", INT2NUM(J_ROLLBACKED));
+    rb_define_const(mJio, "J_ROLLBACKING", INT2NUM(J_ROLLBACKING));
+    rb_define_const(mJio, "J_RDONLY", INT2NUM(J_RDONLY));
+
+    rb_cJioTransaction = rb_define_class_under(mJio, "Transaction", rb_cObject);
+
+    rb_define_method(rb_cJioTransaction, "read", rb_jio_transaction_read, 2);
+    rb_define_method(rb_cJioTransaction, "views", rb_jio_transaction_views, 0);
+    rb_define_method(rb_cJioTransaction, "write", rb_jio_transaction_write, 2);
+    rb_define_method(rb_cJioTransaction, "commit", rb_jio_transaction_commit, 0);
+    rb_define_method(rb_cJioTransaction, "rollback", rb_jio_transaction_rollback, 0);
+    rb_define_method(rb_cJioTransaction, "release", rb_jio_transaction_release, 0);
+    rb_define_method(rb_cJioTransaction, "committed?", rb_jio_transaction_committed_p, 0);
+    rb_define_method(rb_cJioTransaction, "rollbacked?", rb_jio_transaction_rollbacked_p, 0);
+    rb_define_method(rb_cJioTransaction, "rollbacking?", rb_jio_transaction_rollbacking_p, 0);
+}