kgio 2.4.2 → 2.5.0

data/.document

@@ -14,3 +14,4 @@ ext/kgio/kgio_ext.c
 ext/kgio/poll.c
 ext/kgio/read_write.c
 ext/kgio/wait.c
+ext/kgio/tryopen.c

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v2.4.2.GIT
+DEF_VER=v2.5.0.GIT
 
 LF='
 '

data/HACKING

@@ -29,7 +29,7 @@ characters wide) and NOT the indentation style of Matz Ruby.
 
 Contributions are welcome in the form of patches, pull requests, code
 review, testing, documentation, user support or any other feedback.  The
-{kgio mailing list}[mailto:kgio@librelist.com] is the
+{kgio mailing list}[mailto:kgio@librelist.org] is the
 central coordination point for all user and developer feedback and bug
 reports.
 

data/ISSUES

@@ -1,6 +1,6 @@
 = Issues
 
-The kgio {mailing list}[mailto:kgio@librelist.com] is the best
+The kgio {mailing list}[mailto:kgio@librelist.org] is the best
 place to report bugs, submit patches and/or obtain support after you
 have searched the mailing list archives and
 {documentation}[http://bogomips.org/kgio].
@@ -25,7 +25,7 @@ guidelines for patch submission.
 == Mailing List Info
 
 * subscribe: send a message to the mailing list
-* post: mailto:kgio@librelist.com
+* post: mailto:kgio@librelist.org
 * private: mailto:kgio@bogomips.org
 
 == Mailing List Archives (coming soon)

data/README

@@ -3,7 +3,7 @@
 kgio provides non-blocking I/O methods for Ruby without raising
 exceptions on EAGAIN and EINPROGRESS.  It is intended for use with the
 Unicorn and Rainbows! Rack servers, but may be used by other
-applications.
+applications (that run on Unix-like platforms).
 
 == Features
 
@@ -30,11 +30,8 @@ applications.
 
 == Install
 
-The library consists of a C extension so you'll need a C compiler
-and Ruby development libraries/headers.
-
-You may download the tarball from the Rainbows! project page on Rubyforge
-and run setup.rb after unpacking it:
+The library consists of a C extension so you'll need a Unix-like system
+with a C compiler and Ruby development libraries/headers.
 
 http://rubyforge.org/frs/?group_id=8977
 
@@ -61,7 +58,7 @@ from git.
 
 All feedback (bug reports, user/development dicussion, patches, pull
 requests) go to the mailing list/newsgroup.  See the ISSUES document for
-information on the {kgio mailing list}[mailto:kgio@librelist.com]
+information on the {kgio mailing list}[mailto:kgio@librelist.org]
 
 For the latest on kgio releases, you may check our NEWS page (and
 subscribe to our Atom feed).

data/ext/kgio/accept.c

@@ -1,6 +1,8 @@
 #include "kgio.h"
 #include "missing_accept4.h"
 #include "sock_for_fd.h"
+#include "my_fileno.h"
+#include "nonblock.h"
 
 static VALUE localhost;
 static VALUE cClientSocket;

data/ext/kgio/ancient_ruby.h

@@ -2,11 +2,12 @@
 #define MISSING_ANCIENT_RUBY_H
 
 #ifndef HAVE_RB_STR_SET_LEN
-static void rb_str_set_len(VALUE str, long len)
+static void my_str_set_len(VALUE str, long len)
 {
 	RSTRING(str)->len = len;
 	RSTRING(str)->ptr[len] = '\0';
 }
+#define rb_str_set_len(str,len) my_str_set_len((str),(len))
 #endif /* ! HAVE_RB_STR_SET_LEN */
 
 #ifndef RSTRING_PTR

data/ext/kgio/autopush.c

@@ -13,6 +13,7 @@
  */
 
 #include "kgio.h"
+#include "my_fileno.h"
 #include <netinet/tcp.h>
 
 /*
@@ -142,10 +143,6 @@ static VALUE autopush_get(VALUE io)
  */
 static VALUE autopush_set(VALUE io, VALUE vbool)
 {
-	int fd = my_fileno(io);
-	int val;
-	socklen_t len = sizeof(val);
-
 	if (RTEST(vbool))
 		state_set(io, AUTOPUSH_STATE_WRITER);
 	else

data/ext/kgio/connect.c

@@ -61,7 +61,6 @@ static VALUE tcp_connect(VALUE klass, VALUE ip, VALUE port, int io_wait)
 	struct sockaddr_storage addr;
 	int rc;
 	struct addrinfo *res;
-	VALUE sock;
 	const char *ipname = StringValuePtr(ip);
 	char ipport[6];
 	unsigned uport = FIX2UINT(port);

data/ext/kgio/extconf.rb

@@ -21,16 +21,20 @@ have_func("getnameinfo", %w(sys/types.h sys/socket.h netdb.h)) or
 have_type("struct sockaddr_storage", %w(sys/types.h sys/socket.h)) or
   abort "struct sockaddr_storage required"
 have_func('accept4', %w(sys/socket.h))
+have_header("sys/select.h")
+
 if have_header('ruby/io.h')
   rubyio = %w(ruby.h ruby/io.h)
   have_struct_member("rb_io_t", "fd", rubyio)
   have_struct_member("rb_io_t", "mode", rubyio)
+  have_struct_member("rb_io_t", "pathv", rubyio)
 else
   rubyio = %w(ruby.h rubyio.h)
   rb_io_t = have_type("OpenFile", rubyio) ? "OpenFile" : "rb_io_t"
   have_struct_member(rb_io_t, "f", rubyio)
   have_struct_member(rb_io_t, "f2", rubyio)
   have_struct_member(rb_io_t, "mode", rubyio)
+  have_struct_member(rb_io_t, "path", rubyio)
   have_func('rb_fdopen')
 end
 have_type("struct RFile", rubyio) and check_sizeof("struct RFile", rubyio)
@@ -40,5 +44,7 @@ have_func('rb_io_ascii8bit_binmode')
 have_func('rb_thread_blocking_region')
 have_func('rb_thread_io_blocking_region')
 have_func('rb_str_set_len')
+have_func('rb_time_interval')
+have_func('rb_wait_for_single_fd')
 
 create_makefile('kgio_ext')

data/ext/kgio/kgio.h

@@ -19,8 +19,6 @@
 #include <netdb.h>
 
 #include "ancient_ruby.h"
-#include "nonblock.h"
-#include "my_fileno.h"
 
 struct io_args {
 	VALUE io;
@@ -36,6 +34,7 @@ void init_kgio_accept(void);
 void init_kgio_connect(void);
 void init_kgio_autopush(void);
 void init_kgio_poll(void);
+void init_kgio_tryopen(void);
 
 void kgio_autopush_accept(VALUE, VALUE);
 void kgio_autopush_recv(VALUE);

data/ext/kgio/kgio_ext.c

@@ -8,4 +8,5 @@ void Init_kgio_ext(void)
 	init_kgio_accept();
 	init_kgio_autopush();
 	init_kgio_poll();
+	init_kgio_tryopen();
 }

data/ext/kgio/poll.c

@@ -1,5 +1,6 @@
 #include "kgio.h"
 #if defined(USE_KGIO_POLL)
+#include "my_fileno.h"
 #include <time.h>
 #include "broken_system_compat.h"
 #include <poll.h>

data/ext/kgio/read_write.c

@@ -1,4 +1,6 @@
 #include "kgio.h"
+#include "my_fileno.h"
+#include "nonblock.h"
 static VALUE sym_wait_readable, sym_wait_writable;
 static VALUE eErrno_EPIPE, eErrno_ECONNRESET;
 static ID id_set_backtrace;
@@ -518,9 +520,10 @@ void init_kgio_read_write(void)
 	rb_define_method(mSocketMethods, "kgio_peek", kgio_peek, -1);
 
 	/*
-	 * Returns the client IPv4 address of the socket in dotted quad
-	 * form as a string.  This is always the value of the
-	 * Kgio::LOCALHOST constant for UNIX domain sockets.
+	 * Returns the client IP address of the socket as a string
+	 * (e.g. "127.0.0.1" or "::1").
+	 * This is always the value of the Kgio::LOCALHOST constant
+	 * for UNIX domain sockets.
 	 */
 	rb_define_attr(mSocketMethods, "kgio_addr", 1, 1);
 	id_set_backtrace = rb_intern("set_backtrace");

data/ext/kgio/set_file_path.h

@@ -0,0 +1,26 @@
+#if defined(HAVE_RB_IO_T) && \
+    defined(HAVE_TYPE_STRUCT_RFILE) && \
+    defined(HAVE_ST_PATHV)
+/* MRI 1.9 */
+static void set_file_path(VALUE io, VALUE path)
+{
+	rb_io_t *fptr = RFILE(io)->fptr;
+	fptr->pathv = rb_str_new4(path);
+}
+#elif defined(HAVE_TYPE_OPENFILE) && \
+      defined(HAVE_TYPE_STRUCT_RFILE) && \
+      defined(HAVE_ST_PATH)
+/* MRI 1.8 */
+#include "util.h"
+static void set_file_path(VALUE io, VALUE path)
+{
+	OpenFile *fptr = RFILE(io)->fptr;
+	fptr->path = ruby_strdup(RSTRING_PTR(path));
+}
+#else
+/* Rubinius */
+static void set_file_path(VALUE io, VALUE path)
+{
+	rb_iv_set(io, "@path", rb_str_new4(path));
+}
+#endif

data/ext/kgio/tryopen.c

@@ -0,0 +1,181 @@
+#include <ruby.h>
+#ifdef HAVE_RUBY_IO_H
+#  include <ruby/io.h>
+#else
+#  include <rubyio.h>
+#endif
+
+#ifdef HAVE_RUBY_ST_H
+#  include <ruby/st.h>
+#else
+#  include <st.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include "set_file_path.h"
+
+static ID id_for_fd, id_to_path, id_path;
+static st_table *errno2sym;
+
+struct open_args {
+	const char *pathname;
+	int flags;
+	mode_t mode;
+};
+
+static VALUE nogvl_open(void *ptr)
+{
+	struct open_args *o = ptr;
+
+	return (VALUE)open(o->pathname, o->flags, o->mode);
+}
+
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+#  define RUBY_UBF_IO ((void *)(-1))
+#  include "rubysig.h"
+typedef void rb_unblock_function_t(void *);
+typedef VALUE rb_blocking_function_t(void *);
+static VALUE rb_thread_blocking_region(
+	rb_blocking_function_t *fn, void *data1,
+	rb_unblock_function_t *ubf, void *data2)
+{
+	VALUE rv;
+
+	TRAP_BEG; /* for FIFO */
+	rv = fn(data1);
+	TRAP_END;
+
+	return rv;
+}
+#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
+
+/*
+ * call-seq:
+ *
+ *	Kgio::File.tryopen(filename, [, mode [, perm]])	-> Kgio::File or Symbol
+ *
+ * Returns a Kgio::File object on a successful open.  +filename+ is a
+ * path to any file on the filesystem.  If specified, +mode+ is a bitmask
+ * of flags (see IO.sysopen) and +perm+ should be an octal number.
+ *
+ * This does not raise errors for most failures, but installs returns a
+ * Ruby symbol for the constant in the Errno::* namespace.
+ *
+ * Common error symbols are:
+ *
+ * - :ENOENT
+ * - :EACCES
+ *
+ * See your open(2) manpage for more information on open(2) errors.
+ */
+static VALUE s_tryopen(int argc, VALUE *argv, VALUE klass)
+{
+	int fd;
+	VALUE pathname, flags, mode;
+	struct open_args o;
+	int retried = 0;
+	VALUE rv;
+
+	rb_scan_args(argc, argv, "12", &pathname, &flags, &mode);
+	if (rb_respond_to(pathname, id_to_path))
+		pathname = rb_funcall(pathname, id_to_path, 0);
+	o.pathname = StringValueCStr(pathname);
+
+	switch (TYPE(flags)) {
+	case T_NIL: o.flags = O_RDONLY; break;
+	case T_FIXNUM: o.flags = FIX2INT(flags); break;
+	case T_BIGNUM: o.flags = NUM2INT(flags); break;
+	default: rb_raise(rb_eArgError, "flags must be an Integer");
+	}
+	switch (TYPE(mode)) {
+	case T_NIL: o.mode = 0666; break;
+	case T_FIXNUM: o.mode = FIX2INT(mode); break;
+	case T_BIGNUM: o.mode = NUM2INT(mode); break;
+	default: rb_raise(rb_eArgError, "mode must be an Integer");
+	}
+
+retry:
+	fd = (int)rb_thread_blocking_region(nogvl_open, &o, RUBY_UBF_IO, 0);
+	if (fd == -1) {
+		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+			rb_gc();
+			if (retried)
+				rb_sys_fail(o.pathname);
+			retried = 1;
+			goto retry;
+		}
+		if (fd == -1) {
+			int saved_errno = errno;
+
+			if (!st_lookup(errno2sym, (st_data_t)errno, &rv)) {
+				errno = saved_errno;
+				rb_sys_fail(o.pathname);
+			}
+			return rv;
+		}
+	}
+	rv = rb_funcall(klass, id_for_fd, 1, INT2FIX(fd));
+	set_file_path(rv, pathname);
+	return rv;
+}
+
+void init_kgio_tryopen(void)
+{
+	VALUE mKgio = rb_define_module("Kgio");
+	VALUE mPipeMethods = rb_const_get(mKgio, rb_intern("PipeMethods"));
+	VALUE cFile;
+	VALUE tmp;
+	VALUE *ptr;
+	long len;
+
+	id_path = rb_intern("path");
+	id_for_fd = rb_intern("for_fd");
+	id_to_path = rb_intern("to_path");
+
+	/*
+	 * Document-class: Kgio::File
+	 *
+	 * This subclass of the core File class adds the "tryopen" singleton
+	 * method for opening files.  A single "tryopen" and check for the
+	 * return value may be used to avoid unnecessary stat(2) syscalls
+	 * or File.open exceptions when checking for the existence of a file
+	 * and opening it.
+	 */
+	cFile = rb_define_class_under(mKgio, "File", rb_cFile);
+	rb_define_singleton_method(cFile, "tryopen", s_tryopen, -1);
+	rb_include_module(cFile, mPipeMethods);
+
+	if (!rb_funcall(cFile, rb_intern("method_defined?"), 1,
+	                ID2SYM(id_to_path)))
+		rb_define_alias(cFile, "to_path", "path");
+
+	errno2sym = st_init_numtable();
+	tmp = rb_funcall(rb_mErrno, rb_intern("constants"), 0);
+	ptr = RARRAY_PTR(tmp);
+	len = RARRAY_LEN(tmp);
+	for (; --len >= 0; ptr++) {
+		VALUE error;
+		ID const_id;
+
+		switch (TYPE(*ptr)) {
+		case T_SYMBOL: const_id = SYM2ID(*ptr); break;
+		case T_STRING: const_id = rb_intern(RSTRING_PTR(*ptr)); break;
+		default: rb_bug("constant not a symbol or string");
+		}
+
+		error = rb_const_get(rb_mErrno, const_id);
+		if ((TYPE(error) != T_CLASS) ||
+		    !rb_const_defined(error, rb_intern("Errno")))
+			continue;
+
+		error = rb_const_get(error, rb_intern("Errno"));
+		switch (TYPE(error)) {
+		case T_FIXNUM:
+		case T_BIGNUM:
+			st_insert(errno2sym, (st_data_t)NUM2INT(error),
+			          ID2SYM(const_id));
+		}
+	}
+}

data/ext/kgio/wait.c

@@ -1,53 +1,93 @@
 #include "kgio.h"
-
+#include "my_fileno.h"
 static ID id_wait_rd, id_wait_wr;
 
-/*
- * avoiding rb_thread_select() or similar since rb_io_wait_*able can be
- * made to use poll() later on.  It's highly unlikely Ruby will move to
- * use an edge-triggered event notification, so assigning EAGAIN is
- * probably safe...
- */
+#if defined(HAVE_RB_TIME_INTERVAL) && defined(HAVE_RB_WAIT_FOR_SINGLE_FD)
+static int kgio_timedwait(VALUE self, VALUE timeout, int write_p)
+{
+	struct timeval tv = rb_time_interval(timeout);
+	int events = write_p ? RB_WAITFD_OUT : RB_WAITFD_IN;
+
+	return rb_wait_for_single_fd(my_fileno(self), events, &tv);
+}
+#else  /* ! (HAVE_RB_TIME_INTERVAL && HAVE_RB_WAIT_FOR_SINGLE_FD) */
+static int kgio_timedwait(VALUE self, VALUE timeout, int write_p)
+{
+	VALUE argv[4];
+	VALUE set = rb_ary_new3(1, self);
 
+	argv[0] = write_p ? Qnil : set;
+	argv[1] = write_p ? set : Qnil;
+	argv[2] = Qnil;
+	argv[3] = timeout;
+
+	set = rb_funcall2(rb_cIO, rb_intern("select"), 4, argv);
+	return NIL_P(set) ? 0 : 1;
+}
+#endif /* ! (HAVE_RB_TIME_INTERVAL && HAVE_RB_WAIT_FOR_SINGLE_FD) */
+
+static int kgio_wait(int argc, VALUE *argv, VALUE self, int write_p)
+{
+	int fd;
+	VALUE timeout;
+
+	if (rb_scan_args(argc, argv, "01", &timeout) == 1 && !NIL_P(timeout))
+		return kgio_timedwait(self, timeout, write_p);
+
+	fd = my_fileno(self);
+	errno = EAGAIN;
+	write_p ? rb_io_wait_writable(fd) : rb_io_wait_readable(fd);
+	return 1;
+}
 
 /*
- * Blocks the running Thread indefinitely until +self+ IO object is readable.
- * This method is automatically called by default whenever kgio_read needs
- * to block on input.
+ * call-seq:
+ *
+ *	io.kgio_wait_readable           -> IO
+ *	io.kgio_wait_readable(timeout)  -> IO or nil
+ *
+ * Blocks the running Thread indefinitely until the IO object is readable
+ * or if +timeout+ expires.  If +timeout+ is specified and expires, +nil+
+ * is returned.
+ *
+ * This method is automatically called (without timeout argument) by default
+ * whenever kgio_read needs to block on input.
  *
  * Users of alternative threading/fiber libraries are
  * encouraged to override this method in their subclasses or modules to
  * work with their threading/blocking methods.
  */
-static VALUE kgio_wait_readable(VALUE self)
+static VALUE kgio_wait_readable(int argc, VALUE *argv, VALUE self)
 {
-	int fd = my_fileno(self);
-
-	errno = EAGAIN;
-	if (!rb_io_wait_readable(fd))
-		rb_sys_fail("kgio_wait_readable");
+	int r = kgio_wait(argc, argv, self, 0);
 
-	return self;
+	if (r < 0) rb_sys_fail("kgio_wait_readable");
+	return r == 0 ? Qnil : self;
 }
 
 /*
- * Blocks the running Thread indefinitely until +self+ IO object is writable.
- * This method is automatically called whenever kgio_write needs to
- * block on output.
+ * call-seq:
+ *
+ *	io.kgio_wait_writeable          -> IO
+ *	io.kgio_wait_writable(timeout)  -> IO or nil
+ *
+ * Blocks the running Thread indefinitely until the IO object is writable
+ * or if +timeout+ expires.  If +timeout+ is specified and expires, +nil+
+ * is returned.
+ *
+ * This method is automatically called (without timeout argument) by default
+ * whenever kgio_write needs to block on output.
  *
  * Users of alternative threading/fiber libraries are
  * encouraged to override this method in their subclasses or modules to
  * work with their threading/blocking methods.
  */
-static VALUE kgio_wait_writable(VALUE self)
+static VALUE kgio_wait_writable(int argc, VALUE *argv, VALUE self)
 {
-	int fd = my_fileno(self);
-
-	errno = EAGAIN;
-	if (!rb_io_wait_writable(fd))
-		rb_sys_fail("kgio_wait_writable");
+	int r = kgio_wait(argc, argv, self, 1);
 
-	return self;
+	if (r < 0) rb_sys_fail("kgio_wait_writable");
+	return r == 0 ? Qnil : self;
 }
 
 VALUE kgio_call_wait_writable(VALUE io)
@@ -80,7 +120,7 @@ void init_kgio_wait(void)
 	id_wait_wr = rb_intern("kgio_wait_writable");
 
 	rb_define_method(mWaiters, "kgio_wait_readable",
-	                 kgio_wait_readable, 0);
+	                 kgio_wait_readable, -1);
 	rb_define_method(mWaiters, "kgio_wait_writable",
-	                 kgio_wait_writable, 0);
+	                 kgio_wait_writable, -1);
 }

data/pkg.mk

@@ -69,7 +69,7 @@ doc:: .document .wrongdoc.yml $(pkg_extra)
 	$(RM) -r doc
 	$(WRONGDOC) all
 	install -m644 COPYING doc/COPYING
-	install -m644 $(shell grep '^[A-Z]' .document) doc/
+	install -m644 $(shell LC_ALL=C grep '^[A-Z]' .document) doc/
 
 ifneq ($(VERSION),)
 pkggem := pkg/$(rfpackage)-$(VERSION).gem
@@ -167,5 +167,9 @@ doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
 doc_gz:
 	for i in $(docs); do \
 	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+check-warnings:
+	@(for i in $$(git ls-files '*.rb'| grep -v '^setup\.rb$$'); \
+	  do $(RUBY) -d -W2 -c $$i; done) | grep -v '^Syntax OK$$' || :
 
 .PHONY: all .FORCE-GIT-VERSION-FILE doc test $(test_units) manifest
+.PHONY: check-warnings

data/test/test_default_wait.rb

@@ -18,4 +18,28 @@ class TestDefaultWait < Test::Unit::TestCase
     b.syswrite('.')
     assert_equal a, a.kgio_wait_readable
   end
+
+  def test_wait_readable_timed
+    a, b = Kgio::Pipe.new
+    t0 = Time.now
+    assert_nil a.kgio_wait_readable(1.1)
+    diff = Time.now - t0
+    assert_in_delta diff, 1.1, 0.05
+
+    b.kgio_write '.'
+    assert_equal a, a.kgio_wait_readable(1.1)
+  end
+
+  def test_wait_writable_timed
+    a, b = Kgio::Pipe.new
+    buf = "*" * 65536
+    true until Symbol === b.kgio_trywrite(buf)
+    t0 = Time.now
+    assert_nil b.kgio_wait_writable(1.1)
+    diff = Time.now - t0
+    assert_in_delta diff, 1.1, 0.05
+
+    a.kgio_read(16384)
+    assert_equal b, b.kgio_wait_writable(1.1)
+  end
 end

data/test/test_tryopen.rb

@@ -0,0 +1,81 @@
+require 'tempfile'
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestTryopen < Test::Unit::TestCase
+
+  def test_tryopen_success
+    tmp = Kgio::File.tryopen(__FILE__)
+    assert_kind_of File, tmp
+    assert_equal File.read(__FILE__), tmp.read
+    assert_equal __FILE__, tmp.path
+    assert_equal __FILE__, tmp.to_path
+    assert_nothing_raised { tmp.close }
+  end
+
+  def test_tryopen_ENOENT
+    tmp = Tempfile.new "tryopen"
+    path = tmp.path
+    tmp.close!
+    tmp = Kgio::File.tryopen(path)
+    assert_equal :ENOENT, tmp
+  end
+
+  def test_tryopen_EPERM
+    tmp = Tempfile.new "tryopen"
+    File.chmod 0000, tmp.path
+    tmp = Kgio::File.tryopen(tmp.path)
+    assert_equal :EACCES, tmp
+  end
+
+  def test_tryopen_readwrite
+    tmp = Tempfile.new "tryopen"
+    file = Kgio::File.tryopen(tmp.path, IO::RDWR)
+    file.syswrite "FOO"
+    assert_equal "FOO", tmp.sysread(3)
+  end
+
+  def test_tryopen_try_readwrite
+    tmp = Tempfile.new "tryopen"
+    file = Kgio::File.tryopen(tmp.path, IO::RDWR)
+    assert_nil file.kgio_trywrite("FOO")
+    file.rewind
+    assert_equal "FOO", file.kgio_tryread(3)
+  end
+
+  def test_tryopen_mode
+    tmp = Tempfile.new "tryopen"
+    path = tmp.path
+    tmp.close!
+    file = Kgio::File.tryopen(path, IO::RDWR|IO::CREAT, 0000)
+    assert_equal 0100000, File.stat(path).mode
+    ensure
+      File.unlink path
+  end
+
+  require "benchmark"
+  def test_benchmark
+    nr = 1000000
+    tmp = Tempfile.new('tryopen')
+    file = tmp.path
+    Benchmark.bmbm do |x|
+      x.report("tryopen (OK)") do
+        nr.times { Kgio::File.tryopen(file).close }
+      end
+      x.report("open (OK)") do
+        nr.times { File.readable?(file) && File.open(file).close }
+      end
+    end
+    tmp.close!
+    assert_equal :ENOENT, Kgio::File.tryopen(file)
+    Benchmark.bmbm do |x|
+      x.report("tryopen (ENOENT)") do
+        nr.times { Kgio::File.tryopen(file) }
+      end
+      x.report("open (ENOENT)") do
+        nr.times { File.readable?(file) && File.open(file) }
+      end
+    end
+  end if ENV["BENCHMARK"]
+end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 2
-  - 4
-  - 2
-  version: 2.4.2
+  - 5
+  - 0
+  version: 2.5.0
 platform: ruby
 authors: 
 - kgio hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-14 00:00:00 Z
+date: 2011-06-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: wrongdoc
@@ -51,7 +51,7 @@ description: |-
   kgio provides non-blocking I/O methods for Ruby without raising
   exceptions on EAGAIN and EINPROGRESS.  It is intended for use with the
   Unicorn and Rainbows! Rack servers, but may be used by other
-  applications.
+  applications (that run on Unix-like platforms).
 email: kgio@librelist.org
 executables: []
 
@@ -74,6 +74,7 @@ extra_rdoc_files:
 - ext/kgio/poll.c
 - ext/kgio/read_write.c
 - ext/kgio/wait.c
+- ext/kgio/tryopen.c
 files: 
 - .document
 - .gitignore
@@ -106,7 +107,9 @@ files:
 - ext/kgio/nonblock.h
 - ext/kgio/poll.c
 - ext/kgio/read_write.c
+- ext/kgio/set_file_path.h
 - ext/kgio/sock_for_fd.h
+- ext/kgio/tryopen.c
 - ext/kgio/wait.c
 - kgio.gemspec
 - lib/kgio.rb
@@ -132,6 +135,7 @@ files:
 - test/test_tcp_connect.rb
 - test/test_tcp_server.rb
 - test/test_tcp_server_read_client_write.rb
+- test/test_tryopen.rb
 - test/test_unix_client_read_server_write.rb
 - test/test_unix_connect.rb
 - test/test_unix_server.rb
@@ -189,6 +193,7 @@ test_files:
 - test/test_connect_fd_leak.rb
 - test/test_singleton_read_write.rb
 - test/test_kgio_addr.rb
+- test/test_tryopen.rb
 - test/test_tcp6_client_read_server_write.rb
 - test/test_tcp_server_read_client_write.rb
 - test/test_unix_client_read_server_write.rb