kgio 2.2.0 → 2.3.0

data/.document

@@ -8,7 +8,9 @@ ISSUES
 HACKING
 lib
 ext/kgio/accept.c
+ext/kgio/autopush.c
 ext/kgio/connect.c
 ext/kgio/kgio_ext.c
+ext/kgio/poll.c
 ext/kgio/read_write.c
 ext/kgio/wait.c

data/GIT-VERSION-GEN

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

data/README

@@ -33,7 +33,7 @@ applications.
 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 Mongrel project page on Rubyforge
+You may download the tarball from the Rainbows! project page on Rubyforge
 and run setup.rb after unpacking it:
 
 http://rubyforge.org/frs/?group_id=8977

data/ext/kgio/accept.c

@@ -248,7 +248,7 @@ static VALUE addr_bang(VALUE io)
  * An optional class argument may be specified to override the
  * Kgio::Socket-class return value:
  *
- *      server.kgio_accept(MySocket) -> MySocket
+ *      server.kgio_tryaccept(MySocket) -> MySocket
  */
 static VALUE tcp_tryaccept(int argc, VALUE *argv, VALUE io)
 {
@@ -453,13 +453,26 @@ void init_kgio_accept(void)
 	rb_define_singleton_method(mKgio, "accept_class=", set_accepted, 1);
 	rb_define_singleton_method(mKgio, "accept_class", get_accepted, 0);
 
+	/*
+	 * Document-class: Kgio::UNIXServer
+	 *
+	 * Kgio::UNIXServer should be used in place of the plain UNIXServer
+	 * when kgio_accept and kgio_tryaccept methods are needed.
+	 */
 	cUNIXServer = rb_const_get(rb_cObject, rb_intern("UNIXServer"));
 	cUNIXServer = rb_define_class_under(mKgio, "UNIXServer", cUNIXServer);
 	rb_define_method(cUNIXServer, "kgio_tryaccept", unix_tryaccept, -1);
 	rb_define_method(cUNIXServer, "kgio_accept", unix_accept, -1);
 
+	/*
+	 * Document-class: Kgio::TCPServer
+	 *
+	 * Kgio::TCPServer should be used in place of the plain TCPServer
+	 * when kgio_accept and kgio_tryaccept methods are needed.
+	 */
 	cTCPServer = rb_const_get(rb_cObject, rb_intern("TCPServer"));
 	cTCPServer = rb_define_class_under(mKgio, "TCPServer", cTCPServer);
+
 	rb_define_method(cTCPServer, "kgio_tryaccept", tcp_tryaccept, -1);
 	rb_define_method(cTCPServer, "kgio_accept", tcp_accept, -1);
 	init_sock_for_fd();

data/ext/kgio/autopush.c

@@ -78,11 +78,32 @@ static void state_set(VALUE io, enum autopush_state state)
 static enum autopush_state detect_acceptor_state(VALUE io);
 static void push_pending_data(VALUE io);
 
+/*
+ * call-seq:
+ *	Kgio.autopush? -> true or false
+ *
+ * Returns whether or not autopush is enabled.
+ *
+ * Only available on systems with TCP_CORK (Linux) or
+ * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
+ */
 static VALUE s_get_autopush(VALUE self)
 {
 	return enabled ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq:
+ *	Kgio.autopush = true
+ *	Kgio.autopush = false
+ *
+ * Enables or disables autopush for sockets created with kgio_accept
+ * and kgio_tryaccept methods.  Autopush relies on TCP_CORK/TCP_NOPUSH
+ * being enabled on the listen socket.
+ *
+ * Only available on systems with TCP_CORK (Linux) or
+ * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
+ */
 static VALUE s_set_autopush(VALUE self, VALUE val)
 {
 	enabled = RTEST(val);
@@ -90,11 +111,35 @@ static VALUE s_set_autopush(VALUE self, VALUE val)
 	return val;
 }
 
+/*
+ * call-seq:
+ *
+ *	io.kgio_autopush?  -> true or false
+ *
+ * Returns the current autopush state of the Kgio::SocketMethods-enabled
+ * socket.
+ *
+ * Only available on systems with TCP_CORK (Linux) or
+ * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
+ */
 static VALUE autopush_get(VALUE io)
 {
 	return state_get(io) <= 0 ? Qfalse : Qtrue;
 }
 
+/*
+ * call-seq:
+ *
+ *	io.kgio_autopush = true
+ *	io.kgio_autopush = false
+ *
+ * Enables or disables autopush on any given Kgio::SocketMethods-capable
+ * IO object.  This does NOT enable or disable TCP_NOPUSH/TCP_CORK right
+ * away, that must be done with IO.setsockopt
+ *
+ * Only available on systems with TCP_CORK (Linux) or
+ * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
+ */
 static VALUE autopush_set(VALUE io, VALUE vbool)
 {
 	int fd = my_fileno(io);

data/ext/kgio/connect.c

@@ -257,12 +257,24 @@ void init_kgio_connect(void)
 	rb_define_singleton_method(cKgio_Socket, "new", kgio_connect, 1);
 	rb_define_singleton_method(cKgio_Socket, "start", kgio_start, 1);
 
+	/*
+	 * Document-class: Kgio::TCPSocket
+	 *
+	 * Kgio::TCPSocket should be used in place of the plain TCPSocket
+	 * when kgio_* methods are needed.
+	 */
 	cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
 	cTCPSocket = rb_define_class_under(mKgio, "TCPSocket", cTCPSocket);
 	rb_include_module(cTCPSocket, mSocketMethods);
 	rb_define_singleton_method(cTCPSocket, "new", kgio_tcp_connect, 2);
 	rb_define_singleton_method(cTCPSocket, "start", kgio_tcp_start, 2);
 
+	/*
+	 * Document-class: Kgio::UNIXSocket
+	 *
+	 * Kgio::UNIXSocket should be used in place of the plain UNIXSocket
+	 * when kgio_* methods are needed.
+	 */
 	cUNIXSocket = rb_const_get(rb_cObject, rb_intern("UNIXSocket"));
 	cUNIXSocket = rb_define_class_under(mKgio, "UNIXSocket", cUNIXSocket);
 	rb_include_module(cUNIXSocket, mSocketMethods);

data/ext/kgio/extconf.rb

@@ -2,6 +2,7 @@ require 'mkmf'
 $CPPFLAGS << ' -D_GNU_SOURCE'
 $CPPFLAGS << ' -DPOSIX_C_SOURCE=1'
 
+have_func("poll", "poll.h")
 have_func("getaddrinfo", %w(sys/types.h sys/socket.h netdb.h)) or
   abort "getaddrinfo required"
 have_func("getnameinfo", %w(sys/socket.h netdb.h)) or

data/ext/kgio/kgio.h

@@ -35,6 +35,7 @@ void init_kgio_read_write(void);
 void init_kgio_accept(void);
 void init_kgio_connect(void);
 void init_kgio_autopush(void);
+void init_kgio_poll(void);
 
 void kgio_autopush_accept(VALUE, VALUE);
 void kgio_autopush_recv(VALUE);
@@ -42,5 +43,8 @@ void kgio_autopush_send(VALUE);
 
 VALUE kgio_call_wait_writable(VALUE io);
 VALUE kgio_call_wait_readable(VALUE io);
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) && defined(HAVE_POLL)
+#  define USE_KGIO_POLL
+#endif /* USE_KGIO_POLL */
 
 #endif /* KGIO_H */

data/ext/kgio/kgio_ext.c

@@ -7,4 +7,5 @@ void Init_kgio_ext(void)
 	init_kgio_connect();
 	init_kgio_accept();
 	init_kgio_autopush();
+	init_kgio_poll();
 }

data/ext/kgio/poll.c

@@ -0,0 +1,186 @@
+#include "kgio.h"
+#if defined(USE_KGIO_POLL)
+#include <poll.h>
+#ifdef HAVE_RUBY_ST_H
+#  include <ruby/st.h>
+#else
+#  include <st.h>
+#endif
+
+static VALUE sym_wait_readable, sym_wait_writable;
+static ID id_clear;
+
+struct poll_args {
+	struct pollfd *fds;
+	nfds_t nfds;
+	int timeout;
+	VALUE ios;
+	st_table *fd_to_io;
+};
+
+static int num2timeout(VALUE timeout)
+{
+	switch (TYPE(timeout)) {
+	case T_NIL: return -1;
+	case T_FIXNUM: return FIX2INT(timeout);
+	case T_BIGNUM: return NUM2INT(timeout);
+	}
+        rb_raise(rb_eTypeError, "timeout must be integer or nil");
+        return 0;
+}
+
+static VALUE poll_free(VALUE args)
+{
+	struct poll_args *a = (struct poll_args *)args;
+
+	if (a->fds)
+		xfree(a->fds);
+	if (a->fd_to_io)
+		st_free_table(a->fd_to_io);
+
+	return Qnil;
+}
+
+static short value2events(VALUE event)
+{
+	if (event == sym_wait_readable) return POLLIN;
+	if (event == sym_wait_writable) return POLLOUT;
+	if (TYPE(event) == T_FIXNUM) return (short)FIX2INT(event);
+	rb_raise(rb_eArgError, "unrecognized event");
+}
+
+static int io_to_pollfd_i(VALUE key, VALUE value, VALUE args)
+{
+	struct poll_args *a = (struct poll_args *)args;
+	struct pollfd *pollfd = &a->fds[a->nfds++];
+
+	pollfd->fd = my_fileno(key);
+	pollfd->events = value2events(value);
+	st_insert(a->fd_to_io, (st_data_t)pollfd->fd, (st_data_t)key);
+	return ST_CONTINUE;
+}
+
+static void hash2pollfds(struct poll_args *a)
+{
+	a->fds = xmalloc(sizeof(struct poll_args) * RHASH_SIZE(a->ios));
+	a->fd_to_io = st_init_numtable();
+	rb_hash_foreach(a->ios, io_to_pollfd_i, (VALUE)a);
+}
+
+static VALUE nogvl_poll(void *ptr)
+{
+	struct poll_args *a = ptr;
+	return (VALUE)poll(a->fds, a->nfds, a->timeout);
+}
+
+static VALUE poll_result(int nr, struct poll_args *a)
+{
+	struct pollfd *fds = a->fds;
+	VALUE io;
+	int rc;
+
+	if ((nfds_t)nr != a->nfds)
+		rb_funcall(a->ios, id_clear, 0);
+	for (; nr > 0; fds++) {
+		if (fds->revents == 0)
+			continue;
+		--nr;
+		rc = st_lookup(a->fd_to_io, (st_data_t)fds->fd, &io);
+		assert(rc == 1 && "fd => IO mapping failed");
+		rb_hash_aset(a->ios, io, INT2FIX((int)fds->revents));
+	}
+	return a->ios;
+}
+
+static VALUE do_poll(VALUE args)
+{
+	struct poll_args *a = (struct poll_args *)args;
+	int nr;
+
+	Check_Type(a->ios, T_HASH);
+	hash2pollfds(a);
+
+	nr = (int)rb_thread_blocking_region(nogvl_poll, a, RUBY_UBF_IO, NULL);
+	if (nr < 0) rb_sys_fail("poll");
+	if (nr == 0) return Qnil;
+
+	return poll_result(nr, a);
+}
+
+/*
+ * call-seq:
+ *
+ *	Kgio.poll({ $stdin => :wait_readable }, 100)  -> hash or nil
+ *	Kgio.poll({ $stdin => Kgio::POLLIN }, 100)  -> hash or nil
+ *
+ * Accepts an input hash with IO objects to wait for as the key and
+ * the events to wait for as its value.  The events may either be
+ * +:wait_readable+ or +:wait_writable+ symbols or a Fixnum mask of
+ * Kgio::POLL* constants:
+ *
+ *	Kgio::POLLIN      - there is data to read
+ *	Kgio::POLLPRI     - there is urgent data to read
+ *	Kgio::POLLOUT     - writing will not block
+ *	Kgio::POLLRDHUP   - peer has shutdown writes (Linux 2.6.17+ only)
+ *
+ * Timeout is specified in Integer milliseconds just like the underlying
+ * poll(2), not in seconds like IO.select.  A nil timeout means to wait
+ * forever.  It must be an Integer or nil.
+ *
+ * Kgio.poll modifies and returns its input hash on success with the
+ * IO-like object as the key and an Integer mask of events as the hash
+ * value.  It can return any of the events specified in the input
+ * above, along with the following events:
+ *
+ *	Kgio::POLLERR     - error condition occurred on the descriptor
+ *	Kgio::POLLHUP     - hang up
+ *	Kgio::POLLNVAL    - invalid request (bad file descriptor)
+ *
+ * This method is only available under Ruby 1.9 or any other
+ * implementations that uses native threads and rb_thread_blocking_region()
+ */
+static VALUE s_poll(int argc, VALUE *argv, VALUE self)
+{
+	VALUE timeout;
+	struct poll_args a;
+
+	rb_scan_args(argc, argv, "11", &a.ios, &timeout);
+	a.timeout = num2timeout(timeout);
+	a.nfds = 0;
+	a.fds = NULL;
+	a.fd_to_io = NULL;
+
+	return rb_ensure(do_poll, (VALUE)&a, poll_free, (VALUE)&a);
+}
+
+void init_kgio_poll(void)
+{
+	VALUE mKgio = rb_define_module("Kgio");
+	rb_define_singleton_method(mKgio, "poll", s_poll, -1);
+
+	sym_wait_readable = ID2SYM(rb_intern("wait_readable"));
+	sym_wait_writable = ID2SYM(rb_intern("wait_writable"));
+	id_clear = rb_intern("clear");
+
+#define c(x) rb_define_const(mKgio,#x,INT2NUM((int)x))
+
+/* standard types */
+
+	c(POLLIN);
+	c(POLLPRI);
+	c(POLLOUT);
+
+#ifdef POLLRDHUP
+	c(POLLRDHUP);
+#endif
+
+/* outputs */
+	c(POLLERR);
+	c(POLLHUP);
+	c(POLLNVAL);
+}
+#else /* ! USE_KGIO_POLL */
+void init_kgio_poll(void)
+{
+}
+#endif /* ! USE_KGIO_POLL */

data/ext/kgio/read_write.c

@@ -10,6 +10,9 @@ static ID id_set_backtrace;
  */
 #if defined(__linux__) && ! defined(USE_MSG_DONTWAIT)
 #  define USE_MSG_DONTWAIT
+static const int peek_flags = MSG_DONTWAIT|MSG_PEEK;
+#else
+static const int peek_flags = MSG_PEEK;
 #endif
 
 NORETURN(static void raise_empty_bt(VALUE, const char *));
@@ -223,6 +226,72 @@ static VALUE kgio_tryrecv(int argc, VALUE *argv, VALUE io)
 #  define kgio_tryrecv kgio_tryread
 #endif /* USE_MSG_DONTWAIT */
 
+static VALUE my_peek(int io_wait, int argc, VALUE *argv, VALUE io)
+{
+	struct io_args a;
+	long n;
+
+	prepare_read(&a, argc, argv, io);
+	kgio_autopush_recv(io);
+
+	if (a.len > 0) {
+		if (peek_flags == MSG_PEEK)
+			set_nonblocking(a.fd);
+retry:
+		n = (long)recv(a.fd, a.ptr, a.len, peek_flags);
+		if (read_check(&a, n, "recv(MSG_PEEK)", io_wait) != 0)
+			goto retry;
+	}
+	return a.buf;
+}
+
+/*
+ * call-seq:
+ *
+ *	socket.kgio_trypeek(maxlen)           ->  buffer
+ *	socket.kgio_trypeek(maxlen, buffer)   ->  buffer
+ *
+ * Like kgio_tryread, except it uses MSG_PEEK so it does not drain the
+ * socket buffer.  A subsequent read of any type (including another peek)
+ * will return the same data.
+ */
+static VALUE kgio_trypeek(int argc, VALUE *argv, VALUE io)
+{
+	return my_peek(0, argc, argv, io);
+}
+
+/*
+ * call-seq:
+ *
+ *	socket.kgio_peek(maxlen)           ->  buffer
+ *	socket.kgio_peek(maxlen, buffer)   ->  buffer
+ *
+ * Like kgio_read, except it uses MSG_PEEK so it does not drain the
+ * socket buffer.  A subsequent read of any type (including another peek)
+ * will return the same data.
+ */
+static VALUE kgio_peek(int argc, VALUE *argv, VALUE io)
+{
+	return my_peek(1, argc, argv, io);
+}
+
+/*
+ * call-seq:
+ *
+ *	Kgio.trypeek(socket, maxlen)           ->  buffer
+ *	Kgio.trypeek(socket, maxlen, buffer)   ->  buffer
+ *
+ * Like Kgio.tryread, except it uses MSG_PEEK so it does not drain the
+ * socket buffer.  This can only be used on sockets and not pipe objects.
+ * Maybe used in place of SocketMethods#kgio_trypeek for non-Kgio objects
+ */
+static VALUE s_trypeek(int argc, VALUE *argv, VALUE mod)
+{
+	if (argc <= 1)
+		rb_raise(rb_eArgError, "wrong number of arguments");
+	return my_peek(0, argc - 1, &argv[1], argv[0]);
+}
+
 static void prepare_write(struct io_args *a, VALUE io, VALUE str)
 {
 	a->buf = (TYPE(str) == T_STRING) ? str : rb_obj_as_string(str);
@@ -410,6 +479,7 @@ void init_kgio_read_write(void)
 
 	rb_define_singleton_method(mKgio, "tryread", s_tryread, -1);
 	rb_define_singleton_method(mKgio, "trywrite", s_trywrite, 2);
+	rb_define_singleton_method(mKgio, "trypeek", s_trypeek, -1);
 
 	/*
 	 * Document-module: Kgio::PipeMethods
@@ -438,6 +508,8 @@ void init_kgio_read_write(void)
 	rb_define_method(mSocketMethods, "kgio_write", kgio_send, 1);
 	rb_define_method(mSocketMethods, "kgio_tryread", kgio_tryrecv, -1);
 	rb_define_method(mSocketMethods, "kgio_trywrite", kgio_trysend, 1);
+	rb_define_method(mSocketMethods, "kgio_trypeek", kgio_trypeek, -1);
+	rb_define_method(mSocketMethods, "kgio_peek", kgio_peek, -1);
 
 	/*
 	 * Returns the client IPv4 address of the socket in dotted quad

data/lib/kgio.rb

@@ -1,5 +1,7 @@
 # -*- encoding: binary -*-
 require 'socket'
+
+# See the {README}[link:index.html]
 module Kgio
 
   # The IPv4 address of UNIX domain sockets, useful for creating

data/pkg.mk

@@ -7,7 +7,7 @@ GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
 	@./GIT-VERSION-GEN
 -include GIT-VERSION-FILE
 -include local.mk
-DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]')
+DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts RbConfig::CONFIG["DLEXT"]')
 RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
 RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
 lib := lib
@@ -44,24 +44,27 @@ $(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile
 	$(MAKE) -C $(@D)
 lib := $(lib):$(ext_pfx)/$(ext)
 build: $(ext_dl)
+else
+build:
 endif
 
-pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
+pkg_extra += GIT-VERSION-FILE NEWS ChangeLog LATEST
 ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
 	$(WRONGDOC) prepare
+NEWS LATEST: ChangeLog
 
 manifest:
 	$(RM) .manifest
 	$(MAKE) .manifest
 
-.manifest: ChangeLog
+.manifest: $(pkg_extra)
 	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
 		LC_ALL=C sort > $@+
 	cmp $@+ $@ || mv $@+ $@
 	$(RM) $@+
 
-doc:: .document .wrongdoc.yml
-	find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+doc:: .document .wrongdoc.yml $(pkg_extra)
+	-find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
 	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
 	$(RM) -r doc
 	$(WRONGDOC) all
@@ -144,7 +147,7 @@ test_units := $(wildcard test/test_*.rb)
 test: test-unit
 test-unit: $(test_units)
 $(test_units): build
-	$(RUBY) -I $(lib) $@
+	$(RUBY) -I $(lib) $@ $(RUBY_TEST_OPTS)
 
 # this requires GNU coreutils variants
 ifneq ($(RSYNC_DEST),)

data/test/test_peek.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestPeek < Test::Unit::TestCase
+  class EIEIO < Errno::EIO
+  end
+
+  def teardown
+    @rd.close
+    @wr.close
+  end
+
+  def test_peek
+    @rd, @wr = Kgio::UNIXSocket.pair
+    @wr.kgio_write "HELLO"
+    assert_equal "HELLO", @rd.kgio_peek(5)
+    assert_equal "HELLO", @rd.kgio_trypeek(5)
+    assert_equal "HELLO", @rd.kgio_read(5)
+    assert_equal :wait_readable, @rd.kgio_trypeek(5)
+    def @rd.kgio_wait_readable
+      raise EIEIO
+    end
+    assert_raises(EIEIO) { @rd.kgio_peek(5) }
+  end
+
+  def test_peek_singleton
+    @rd, @wr = UNIXSocket.pair
+    @wr.syswrite "HELLO"
+    assert_equal "HELLO", Kgio.trypeek(@rd, 666)
+    assert_equal "HELLO", Kgio.trypeek(@rd, 666)
+    assert_equal "HELLO", Kgio.tryread(@rd, 666)
+    assert_equal :wait_readable, Kgio.trypeek(@rd, 5)
+  end
+end

data/test/test_poll.rb

@@ -0,0 +1,68 @@
+require 'test/unit'
+$-w = true
+require 'kgio'
+
+class TestPoll < Test::Unit::TestCase
+  def teardown
+    [ @rd, @wr ].each { |io| io.close unless io.closed? }
+  end
+
+  def setup
+    @rd, @wr = IO.pipe
+  end
+
+  def test_constants
+    assert_kind_of Integer, Kgio::POLLIN
+    assert_kind_of Integer, Kgio::POLLOUT
+    assert_kind_of Integer, Kgio::POLLPRI
+    assert_kind_of Integer, Kgio::POLLHUP
+    assert_kind_of Integer, Kgio::POLLERR
+    assert_kind_of Integer, Kgio::POLLNVAL
+  end
+
+  def test_poll_symbol
+    set = { @rd => :wait_readable, @wr => :wait_writable }
+    res = Kgio.poll(set)
+    assert_equal({@wr => Kgio::POLLOUT}, res)
+    assert_equal set.object_id, res.object_id
+  end
+
+  def test_poll_integer
+    set = { @wr => Kgio::POLLOUT|Kgio::POLLHUP }
+    res = Kgio.poll(set)
+    assert_equal({@wr => Kgio::POLLOUT}, res)
+    assert_equal set.object_id, res.object_id
+  end
+
+  def test_poll_timeout
+    t0 = Time.now
+    res = Kgio.poll({}, 10)
+    diff = Time.now - t0
+    assert diff >= 0.010, "diff=#{diff}"
+    assert_nil res
+  end
+
+  def test_poll_interrupt
+    foo = nil
+    oldquit = trap(:QUIT) { foo = :bar }
+    thr = Thread.new { sleep 0.100; Process.kill(:QUIT, $$) }
+    t0 = Time.now
+    assert_raises(Errno::EINTR) { Kgio.poll({}) }
+    diff = Time.now - t0
+    thr.join
+    assert diff >= 0.010, "diff=#{diff}"
+    ensure
+      trap(:QUIT, "DEFAULT")
+  end
+
+  def test_poll_close
+    foo = nil
+    thr = Thread.new { sleep 0.100; @wr.close }
+    t0 = Time.now
+    res = Kgio.poll({@rd => Kgio::POLLIN})
+    diff = Time.now - t0
+    thr.join
+    assert_equal([ @rd ], res.keys)
+    assert diff >= 0.010, "diff=#{diff}"
+  end
+end if Kgio.respond_to?(:poll)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kgio
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: false
   segments: 
   - 2
-  - 2
+  - 3
   - 0
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors: 
 - kgio hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-04 00:00:00 +00:00
+date: 2011-02-09 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -69,8 +69,10 @@ extra_rdoc_files:
 - HACKING
 - lib/kgio.rb
 - ext/kgio/accept.c
+- ext/kgio/autopush.c
 - ext/kgio/connect.c
 - ext/kgio/kgio_ext.c
+- ext/kgio/poll.c
 - ext/kgio/read_write.c
 - ext/kgio/wait.c
 files: 
@@ -101,6 +103,7 @@ files:
 - ext/kgio/missing_accept4.h
 - ext/kgio/my_fileno.h
 - ext/kgio/nonblock.h
+- ext/kgio/poll.c
 - ext/kgio/read_write.c
 - ext/kgio/sock_for_fd.h
 - ext/kgio/wait.c
@@ -116,8 +119,10 @@ files:
 - test/test_default_wait.rb
 - test/test_kgio_addr.rb
 - test/test_no_dns_on_tcp_connect.rb
+- test/test_peek.rb
 - test/test_pipe_popen.rb
 - test/test_pipe_read_write.rb
+- test/test_poll.rb
 - test/test_singleton_read_write.rb
 - test/test_socketpair_read_write.rb
 - test/test_tcp6_client_read_server_write.rb
@@ -168,6 +173,8 @@ signing_key:
 specification_version: 3
 summary: kinder, gentler I/O for Ruby
 test_files: 
+- test/test_poll.rb
+- test/test_peek.rb
 - test/test_default_wait.rb
 - test/test_no_dns_on_tcp_connect.rb
 - test/test_unix_connect.rb