jio 0.1

data/.gitignore

@@ -0,0 +1,22 @@
+.libs/*
+.rbx/*
+*.rbc
+*.lo
+*.la
+*.lai
+*.dylib.dSYM
+*.dylib
+*.o
+*.a
+*.log
+tmp/*
+true/*
+*.bundle
+*.gem
+doc/*
+.DS_Store
+ext/libjio
+pkg
+scratch
+ext/jio/dst
+ext/jio/Makefile

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - rbx-18mode
+  - rbx-19mode
+  - ree
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+script: "bundle exec rake"
+gemfile:
+  - Gemfile
+notifications:
+  recipients:
+    - lourens@methodmissing.com
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gemspec
+
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    jio (0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (0.9.2.2)
+    rake-compiler (0.8.1)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jio!
+  rake
+  rake-compiler (~> 0.8.1)

data/LICENSE

@@ -0,0 +1,16 @@
+jio is copyrighted Free Software by all contributors, see logs in
+revision control for names and email addresses of all of them.
+
+You can redistribute it and/or modify it under the terms of the GNU
+Lesser General Public License as published by the Free Software Foundation,
+version 2.1 or later {LGPLv2.1}[http://www.gnu.org/licenses/lgpl-2.1.txt]
+(see link:COPYING).
+
+eio is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

data/README.rdoc

@@ -0,0 +1,92 @@
+= jio - transactional, journaled file I/O for Ruby {<img src="https://secure.travis-ci.org/methodmissing/jio.png" alt="Build Status" />}[http://travis-ci.org/methodmissing/jio]
+
+(c) 2011 Lourens Naudé (methodmissing), with API guidance from the libjio (http://blitiri.com.ar/p/libjio/) Python extension
+
+  http://github.com/methodmissing/jio
+
+== Why you may need this
+
+Some problems don't map well to database systems and journaled flat files are often a good fit for append
+logs and Event Sourcing implementations. The API is simple (modeled to known UNIX and libc APIs), there's no external dependencies (we vendor libjio) and is known to work on most POSIX systems. The library (libjio) and thus this Ruby extension guarantees file integrity even after unexpected crashes, never leaving your files in an inconsistent state. Crash recovery is fast and safe as well.
+
+== How it works
+
+On the disk, the file you work on is exactly like a regular one, but a special directory is created to store in-flight transactions (lock file and transaction in contents). For further details see http://blitiri.com.ar/p/libjio/doc/libjio.html
+
+== Requirements
+
+* A POSIX compliant OS, known to work well on Linux, BSD variants and Mac OS X
+* Ruby MRI 1.8, 1.9 or Rubinius
+* A C compiler
+
+== Installation
+
+Rubygems installation
+
+    gem install jio # pending upload to rubygems.org
+
+Building from source
+
+    git clone git@github.com:methodmissing/jio.git
+    rake
+
+Running tests
+
+    rake test
+
+== Documentation
+
+RDOC document pending.
+
+== How to use
+
+    # libjio file handle
+    file = JIO.open("file.jio", JIO::RDWR | JIO::CREAT, 0600, JIO::J_LINGER)
+
+    # spawn a new lingering transaction with a write operation
+    trans = file.transaction(JIO::J_LINGER)
+    trans.write('COMMIT', 0)
+
+    # spawn 2 read operations
+    trans.read(2, 2)
+    trans.read(2, 4)
+
+    # Empty views - not committed yet
+    trans.views # [] 
+    # Commit write / read operations to / from disk
+    trans.commit # true
+
+    # View represents the 2 read operations requested earlier
+    trans.views %w(MM IT)
+    trans.committed? # true
+
+    # rollback and cleanup
+    trans.rollback
+    trans.release
+    file.close
+
+    # Assert journal integrity
+    JIO.check("file.jio", 0) # {"reapplied"=>1,
+                             #  "invalid"=>0,
+                             #  "corrupt"=>0,
+                             #  "total"=>1,
+                             #  "in_progress"=>0,
+                             #  "broken"=>0}
+
+See the unit tests for further examples.
+
+== Todo
+
+* More intuitive API
+* Release the GIL where appropriate
+* Support vectored I/O readv and writev
+* More examples
+* Stress tests
+* Better test coverage
+* Gem release
+
+== Contact, feedback and bugs
+
+This project is still work in progress and I'm looking for guidance on API design, use cases and any outlier experiences. Please log bugs and suggestions at https://github.com/methodmissing/jio/issues
+
+Thanks !

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems' unless defined?(Gem)
+require 'rake' unless defined?(Rake)
+
+require 'rake/extensiontask'
+require 'rake/testtask'
+begin
+require 'rdoc/task'
+rescue LoadError # fallback to older 1.8.7 rubies
+require 'rake/rdoctask'
+end
+
+gemspec = eval(IO.read('jio.gemspec'))
+
+Gem::PackageTask.new(gemspec) do |pkg|
+end
+
+Rake::ExtensionTask.new('jio', gemspec) do |ext|
+  ext.name = 'jio_ext'
+  ext.ext_dir = 'ext/jio'
+
+  CLEAN.include 'ext/jio/dst'
+  CLEAN.include 'ext/libjio'
+  CLEAN.include 'lib/**/jio_ext.*'
+end
+
+Rake::RDocTask.new do |rd|
+  files = FileList["README.rdoc", "lib/**/*.rb", "ext/jio/*.c"]
+  rd.title = "jio - transactional, journaled file I/O for Ruby"
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc"
+  rd.options << "--promiscuous"
+  rd.rdoc_files.include(files)
+end
+
+desc 'Run jio tests'
+Rake::TestTask.new(:test) do |t|
+  t.test_files = Dir.glob("test/**/test_*.rb")
+  t.verbose = true
+  t.warning = true
+end
+
+task :test => :compile
+task :default => :test

data/ext/jio/extconf.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+require 'mkmf'
+require 'pathname'
+
+def sys(cmd, err_msg)
+  p cmd
+  system(cmd) || fail(err_msg)
+end
+
+def fail(msg)
+  STDERR.puts msg
+  exit(1)
+end
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+# XXX fallbacks specific to Darwin for JRuby (does not set these values in RbConfig::CONFIG)
+LIBEXT = RbConfig::CONFIG['LIBEXT'] || 'a'
+DLEXT = RbConfig::CONFIG['DLEXT'] || 'bundle'
+
+cwd = Pathname(File.expand_path(File.dirname(__FILE__)))
+dst_path = cwd + 'dst'
+libs_path = dst_path + 'lib'
+vendor_path = cwd + '..'
+libjio_path = vendor_path + 'libjio'
+libjio_include_path = libjio_path + 'libjio'
+
+# Courtesy of EventMachine and @tmm1
+def check_libs libs = [], fatal = false
+  libs.all? { |lib| have_library(lib) || (abort("could not find library: #{lib}") if fatal) }
+end
+
+def check_heads heads = [], fatal = false
+  heads.all? { |head| have_header(head) || (abort("could not find header: #{head}") if fatal)}
+end
+
+case RUBY_PLATFORM
+when /mswin32/, /mingw32/, /bccwin32/
+  check_heads(%w[windows.h winsock.h], true)
+  check_libs(%w[kernel32 rpcrt4 gdi32], true)
+
+  if GNU_CHAIN
+    CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
+  else
+    $defs.push "-EHs"
+    $defs.push "-GR"
+  end
+
+when /solaris/
+  add_define 'OS_SOLARIS8'
+
+  if CONFIG['CC'] == 'cc' and `cc -flags 2>&1` =~ /Sun/ # detect SUNWspro compiler
+    # SUN CHAIN
+    add_define 'CC_SUNWspro'
+    $preload = ["\nCXX = CC"] # hack a CXX= line into the makefile
+    $CFLAGS = CONFIG['CFLAGS'] = "-KPIC"
+    CONFIG['CCDLFLAGS'] = "-KPIC"
+    CONFIG['LDSHARED'] = "$(CXX) -G -KPIC -lCstd"
+  else
+    # GNU CHAIN
+    # on Unix we need a g++ link, not gcc.
+    CONFIG['LDSHARED'] = "$(CXX) -shared"
+  end
+
+when /openbsd/
+  # OpenBSD branch contributed by Guillaume Sellier.
+
+  # on Unix we need a g++ link, not gcc. On OpenBSD, linking against libstdc++ have to be explicitly done for shared libs
+  CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++ -fPIC"
+  CONFIG['LDSHAREDXX'] = "$(CXX) -shared -lstdc++ -fPIC"
+
+when /darwin/
+  # on Unix we need a g++ link, not gcc.
+  # Ff line contributed by Daniel Harple.
+  CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+when /aix/
+  CONFIG['LDSHARED'] = "$(CXX) -shared -Wl,-G -Wl,-brtl"
+
+else
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+# extract dependencies
+unless File.directory?(libjio_path)
+  fail "The 'tar' (creates and manipulates streaming archive files) utility is required to extract dependencies" if `which tar`.strip.empty?
+  Dir.chdir(vendor_path) do
+    sys "tar xvzf libjio.tar.gz", "Could not extract the libjio archive!"
+  end
+end
+
+# build libjio
+lib = libs_path + "libjio.#{LIBEXT}"
+Dir.chdir libjio_path do
+  sys "make DEBUG=1 PREFIX=#{dst_path} install", "libjio compile error!"
+end unless File.exist?(lib)
+
+dir_config('jio')
+
+have_func('rb_thread_blocking_region')
+
+$INCFLAGS << " -I#{libjio_include_path}"
+
+$LIBPATH << libs_path.to_s
+
+# Special case to prevent Rubinius compile from linking system libjio if present
+if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/ && RUBY_PLATFORM =~ /linux/
+  CONFIG['LDSHARED'] = "#{CONFIG['LDSHARED']} -Wl,-rpath=#{libs_path.to_s}"
+end
+
+fail "Error compiling and linking libjio" unless have_library("jio")
+
+$defs << "-pedantic"
+# libjio requires large file support
+$defs << "-D_LARGEFILE_SOURCE=1"
+$defs << "-D_LARGEFILE64_SOURCE=1"
+
+$CFLAGS << ' -Wall -funroll-loops'
+$CFLAGS << ' -Wextra -O0 -ggdb3' if ENV['DEBUG']
+
+create_makefile('jio_ext')

data/ext/jio/file.c

@@ -0,0 +1,488 @@
+#include "jio_ext.h"
+
+/*
+ *  GC callbacks for JIO::File
+ */
+static void rb_jio_free_file(void *ptr)
+{
+    jio_jfs_wrapper *file = (jio_jfs_wrapper *)ptr;
+    if (file) {
+        if (file->fs != NULL && !(file->flags & JIO_FILE_CLOSED)) jclose(file->fs);
+        xfree(file);
+    }
+}
+
+/*
+ *  call-seq:
+ *     JIO.open("/path/file", JIO::CREAT | JIO::RDWR, 0600, JIO::J_LINGER)    =>  JIO::File
+ *
+ *  Returns a handle to a journaled file instance. Same semantics as the UNIX open(2) libc call, with
+ *  an additional one for libjio specific flags.
+ *
+ * === Examples
+ *     JIO.open("/path/file", JIO::CREAT | JIO::RDWR, 0600, JIO::J_LINGER)    =>  JIO::File
+ *
+*/
+
+static VALUE rb_jio_s_open(JIO_UNUSED VALUE jio, VALUE path, VALUE flags, VALUE mode, VALUE jflags)
+{
+    VALUE obj;
+    jio_jfs_wrapper *file = NULL;
+    Check_Type(path, T_STRING);
+    Check_Type(flags, T_FIXNUM);
+    Check_Type(mode, T_FIXNUM);
+    Check_Type(jflags, T_FIXNUM);
+    obj = Data_Make_Struct(rb_cJioFile, jio_jfs_wrapper, 0, rb_jio_free_file, file);
+    TRAP_BEG;
+    file->fs = jopen(RSTRING_PTR(path), FIX2INT(flags), FIX2INT(mode), FIX2UINT(jflags));
+    TRAP_END;
+    if (file->fs == NULL) {
+        xfree(file);
+        rb_sys_fail("jopen");
+    }
+    file->flags = 0;
+    rb_obj_call_init(obj, 0, NULL);
+    return obj;
+}
+
+
+/*
+ *  call-seq:
+ *     file.sync    =>  boolean
+ *
+ *  Sync a file to disk. Makes sense only when using lingering transactions.
+ *
+ * === Examples
+ *     file.sync    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_sync(VALUE obj)
+{
+    JioGetFile(obj);
+    TRAP_BEG;
+    return (jsync(file->fs) == 0) ? Qtrue : Qfalse;
+    TRAP_END;
+}
+
+/*
+ *  call-seq:
+ *     file.close    =>  boolean
+ *
+ *  After a call to this method, the memory allocated for the open file will be freed. If there was an
+ *  autosync thread started for this file, it will be stopped.
+ *
+ * === Examples
+ *     file.close    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_close(VALUE obj)
+{
+    JioGetFile(obj);
+    TRAP_BEG;
+    if (jclose(file->fs) != 0) return Qfalse;
+    TRAP_END;
+    file->flags |= JIO_FILE_CLOSED;
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     file.move_journal("/path")    =>  boolean
+ *
+ *  Changes the location of the journal direction. The file cannot be in use at this time.
+ *
+ * === Examples
+ *     file.move_journal("/path")    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_move_journal(VALUE obj, VALUE path)
+{
+    JioGetFile(obj);
+    Check_Type(path, T_STRING);
+    TRAP_BEG;
+    return (jmove_journal(file->fs, RSTRING_PTR(path)) == 0) ? Qtrue : Qfalse;
+    TRAP_END;
+}
+
+/*
+ *  call-seq:
+ *     file.autosync(5, 4000)    =>  boolean
+ *
+ *  Syncs to disk every X seconds, or every Y bytes written. Only one autosync thread per open file is
+ *  allowed. Only makes sense with lingering transactions.
+ *
+ * === Examples
+ *     file.autosync(5, 4000)    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_autosync(VALUE obj, VALUE max_seconds, VALUE max_bytes)
+{
+    JioGetFile(obj);
+    Check_Type(max_seconds, T_FIXNUM);
+    Check_Type(max_bytes, T_FIXNUM);
+    TRAP_BEG;
+    return (jfs_autosync_start(file->fs, (time_t)FIX2LONG(max_seconds), (size_t)FIX2LONG(max_bytes)) == 0) ? Qtrue : Qfalse;
+    TRAP_END;
+}
+
+/*
+ *  call-seq:
+ *     file.stop_autosync    =>  boolean
+ *
+ *  Stops a previously started autosync thread.
+ *
+ * === Examples
+ *     file.stop_autosync    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_stop_autosync(VALUE obj)
+{
+    JioGetFile(obj);
+    TRAP_BEG;
+    return (jfs_autosync_stop(file->fs) == 0) ? Qtrue : Qfalse;
+    TRAP_END;
+}
+
+/*
+ *  call-seq:
+ *     file.read(10)    =>  String
+ *
+ *  Reads from a libjio file handle. Works just like UNIX read(2)
+ *
+ * === Examples
+ *     file.read(10)    =>  String
+ *
+*/
+
+static VALUE rb_jio_file_read(VALUE obj, VALUE length)
+{
+    ssize_t bytes;
+    char *buf = NULL;
+    ssize_t len;
+    JioGetFile(obj);
+    AssertLength(length);
+    len = (ssize_t)FIX2LONG(length);
+    buf = xmalloc(len + 1);
+    if (buf == NULL) rb_memerror();
+    TRAP_BEG;
+    bytes = jread(file->fs, buf, len);
+    TRAP_END;
+    if (bytes == -1) {
+       xfree(buf);
+       rb_sys_fail("jread");
+    }
+    return JioEncode(rb_str_new(buf, (long)len));
+}
+
+/*
+ *  call-seq:
+ *     file.pread(10, 10)    =>  String
+ *
+ *  Reads from a libjio file handle at a given offset. Works just like UNIX pread(2)
+ *
+ * === Examples
+ *     file.pread(10, 10)    =>  String
+ *
+*/
+
+static VALUE rb_jio_file_pread(VALUE obj, VALUE length, VALUE offset)
+{
+    ssize_t bytes;
+    char *buf = NULL;
+    ssize_t len;
+    JioGetFile(obj);
+    AssertLength(length);
+    AssertOffset(offset);
+    len = (ssize_t)FIX2LONG(length);
+    buf = xmalloc(len + 1);
+    if (buf == NULL) rb_memerror();
+    TRAP_BEG;
+    bytes = jpread(file->fs, buf, len, (off_t)NUM2OFFT(offset));
+    TRAP_END;
+    if (bytes == -1) {
+       xfree(buf);
+       rb_sys_fail("jpread");
+    }
+    return JioEncode(rb_str_new(buf, (long)len));
+}
+
+/*
+ *  call-seq:
+ *     file.write("buffer")    =>  Fixnum
+ *
+ *  Writes to a libjio file handle. Works just like UNIX write(2)
+ *
+ * === Examples
+ *     file.write("buffer")    =>  Fixnum
+ *
+*/
+
+static VALUE rb_jio_file_write(VALUE obj, VALUE buf)
+{
+    ssize_t bytes;
+    JioGetFile(obj);
+    Check_Type(buf, T_STRING);
+    TRAP_BEG;
+    bytes = jwrite(file->fs, RSTRING_PTR(buf), (size_t)RSTRING_LEN(buf));
+    TRAP_END;
+    if (bytes == -1) rb_sys_fail("jwrite");
+    return INT2NUM(bytes);
+}
+
+/*
+ *  call-seq:
+ *     file.pwrite("buffer", 10)    =>  Fixnum
+ *
+ *  Writes to a libjio file handle at a given offset. Works just like UNIX pwrite(2)
+ *
+ * === Examples
+ *     file.pwrite("buffer", 10)    =>  Fixnum
+ *
+*/
+
+static VALUE rb_jio_file_pwrite(VALUE obj, VALUE buf, VALUE offset)
+{
+    ssize_t bytes;
+    JioGetFile(obj);
+    Check_Type(buf, T_STRING);
+    AssertOffset(offset);
+    TRAP_BEG;
+    bytes = jpwrite(file->fs, RSTRING_PTR(buf), (size_t)RSTRING_LEN(buf), (off_t)NUM2OFFT(offset));
+    TRAP_END;
+    if (bytes == -1) rb_sys_fail("jpwrite");
+    return INT2NUM(bytes);
+}
+
+/*
+ *  call-seq:
+ *     file.lseek(10, JIO::SEEK_SET)    =>  Fixnum
+ *
+ *  Reposition the file pointer to the given offset, according to the whence directive.
+ *
+ * === Examples
+ *     file.lseek(10, JIO::SEEK_SET)    =>  Fixnum
+ *
+*/
+
+static VALUE rb_jio_file_lseek(VALUE obj, VALUE offset, VALUE whence)
+{
+    off_t off;
+    JioGetFile(obj);
+    AssertOffset(offset);
+    Check_Type(whence, T_FIXNUM);
+    TRAP_BEG;
+    off = jlseek(file->fs, (off_t)NUM2OFFT(offset), FIX2INT(whence));
+    TRAP_END;
+    if (off == -1) rb_sys_fail("jlseek");
+    return OFFT2NUM(off);
+}
+
+/*
+ *  call-seq:
+ *     file.truncate(10)    =>  Fixnum
+ *
+ *  Truncate the file to the given size.
+ *
+ * === Examples
+ *     file.truncate(10)    =>  Fixnum
+ *
+*/
+
+static VALUE rb_jio_file_truncate(VALUE obj, VALUE length)
+{
+    off_t len;
+    JioGetFile(obj);
+    AssertLength(length);
+    TRAP_BEG;
+    len = jtruncate(file->fs, (off_t)NUM2OFFT(length));
+    TRAP_END;
+    if (len == -1) rb_sys_fail("jtruncate");
+    return OFFT2NUM(len);
+}
+
+/*
+ *  call-seq:
+ *     file.fileno    =>  Fixnum
+ *
+ *  Return the file descriptor number for the file.
+ *
+ * === Examples
+ *     file.fileno    =>  Fixnum
+ *
+*/
+
+static VALUE rb_jio_file_fileno(VALUE obj)
+{
+    int fd;
+    JioGetFile(obj);
+    TRAP_BEG;
+    fd = jfileno(file->fs);
+    TRAP_END;
+    if (fd == -1) rb_sys_fail("jfileno");
+    return INT2NUM(fd);
+}
+
+/*
+ *  call-seq:
+ *     file.rewind    =>  nil
+ *
+ *  Adjusts the file so that the next I/O operation will take place at the beginning of the file.
+ *
+ * === Examples
+ *     file.rewind    =>  nil
+ *
+*/
+
+static VALUE rb_jio_file_rewind(VALUE obj)
+{
+    JioGetFile(obj);
+    TRAP_BEG;
+    jrewind(file->fs);
+    TRAP_END;
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     file.tell    =>  Fixnum
+ *
+ *  Determine the current file offset.
+ *
+ * === Examples
+ *     file.tell    =>  Fixnum
+ *
+*/
+
+static VALUE rb_jio_file_tell(VALUE obj)
+{
+    long size;
+    JioGetFile(obj);
+    TRAP_BEG;
+    size = jftell(file->fs);
+    TRAP_END;
+    if (size == -1) rb_sys_fail("jftell");
+    return INT2NUM(size);
+}
+
+/*
+ *  call-seq:
+ *     file.eof?    =>  boolean
+ *
+ *  Check for end-of-file.
+ *
+ * === Examples
+ *     file.eof?    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_eof_p(VALUE obj)
+{
+    JioGetFile(obj);
+    TRAP_BEG;
+    return (jfeof(file->fs) != 0) ? Qtrue : Qfalse;
+    TRAP_END;
+}
+
+/*
+ *  call-seq:
+ *     file.error?    =>  boolean
+ *
+ *  Determines if an error condition has occurred.
+ *
+ * === Examples
+ *     file.error?    =>  boolean
+ *
+*/
+
+static VALUE rb_jio_file_error_p(VALUE obj)
+{
+    int res;
+    JioGetFile(obj);
+    TRAP_BEG;
+    res = jferror(file->fs);
+    TRAP_END;
+    if (res == 0) return Qfalse;
+    return INT2NUM(res);
+}
+
+/*
+ *  call-seq:
+ *     file.clearerr    =>  nil
+ *
+ *  Resets the error flag for this file, if any.
+ *
+ * === Examples
+ *     file.clearerr    =>  nil
+ *
+*/
+
+static VALUE rb_jio_file_clearerr(VALUE obj)
+{
+    JioGetFile(obj);
+    TRAP_BEG;
+    jclearerr(file->fs);
+    TRAP_END;
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     file.transaction(JIO::J_LINGER)    =>  JIO::Transaction
+ *
+ *  Creates a new low level transaction from a libjio file reference.
+ *
+ * === Examples
+ *     file.transaction(JIO::J_LINGER)    =>  JIO::Transaction
+ *
+*/
+
+VALUE rb_jio_file_new_transaction(VALUE obj, VALUE flags)
+{
+    VALUE transaction;
+    jio_jtrans_wrapper *trans = NULL;
+    JioGetFile(obj);
+    Check_Type(flags, T_FIXNUM);
+    transaction = Data_Make_Struct(rb_cJioTransaction, jio_jtrans_wrapper, rb_jio_mark_transaction, rb_jio_free_transaction, trans);
+    TRAP_BEG;
+    trans->trans = jtrans_new(file->fs, FIX2INT(flags));
+    TRAP_END;
+    if (trans->trans == NULL) {
+        xfree(trans);
+        rb_sys_fail("jtrans_new");
+    }
+    trans->views = Qnil;
+    trans->flags = 0;
+    rb_obj_call_init(transaction, 0, NULL);
+    return transaction;
+}
+
+void _init_rb_jio_file()
+{
+    rb_define_module_function(mJio, "open", rb_jio_s_open, 4);
+
+    rb_cJioFile = rb_define_class_under(mJio, "File", rb_cObject);
+
+    rb_define_method(rb_cJioFile, "sync", rb_jio_file_sync, 0);
+    rb_define_method(rb_cJioFile, "close", rb_jio_file_close, 0);
+    rb_define_method(rb_cJioFile, "move_journal", rb_jio_file_move_journal, 1);
+    rb_define_method(rb_cJioFile, "autosync", rb_jio_file_autosync, 2);
+    rb_define_method(rb_cJioFile, "stop_autosync", rb_jio_file_stop_autosync, 0);
+    rb_define_method(rb_cJioFile, "read", rb_jio_file_read, 1);
+    rb_define_method(rb_cJioFile, "pread", rb_jio_file_pread, 2);
+    rb_define_method(rb_cJioFile, "write", rb_jio_file_write, 1);
+    rb_define_method(rb_cJioFile, "pwrite", rb_jio_file_pwrite, 2);
+    rb_define_method(rb_cJioFile, "lseek", rb_jio_file_lseek, 2);
+    rb_define_method(rb_cJioFile, "truncate", rb_jio_file_truncate, 1);
+    rb_define_method(rb_cJioFile, "fileno", rb_jio_file_fileno, 0);
+    rb_define_method(rb_cJioFile, "rewind", rb_jio_file_rewind, 0);
+    rb_define_method(rb_cJioFile, "tell", rb_jio_file_tell, 0);
+    rb_define_method(rb_cJioFile, "eof?", rb_jio_file_eof_p, 0);
+    rb_define_method(rb_cJioFile, "error?", rb_jio_file_error_p, 0);
+    rb_define_method(rb_cJioFile, "clearerr", rb_jio_file_clearerr, 0);
+    rb_define_method(rb_cJioFile, "transaction", rb_jio_file_new_transaction, 1);
+}