accept_nonblock supports "exception: false"

This is analogous to functionality found in IO#read_nonblock and
IO#wait_nonblock.  Raising exceptions for common failures on
non-blocking servers is expensive and makes $DEBUG too noisy.

Benchmark results:
                                    user     system      total        real
default                         2.790000   0.870000   3.660000 (  3.671597)
exception: false                1.120000   0.800000   1.920000 (  1.922032)
exception: false (cached arg)   0.820000   0.770000   1.590000 (  1.589267)
--------------------- benchmark script ------------------------
require 'socket'
require 'benchmark'
require 'tmpdir'
nr = 1000000
Dir.mktmpdir('nb_bench') do |path|
  sock_path = "#{path}/test.sock"
  s = UNIXServer.new(sock_path)
  Benchmark.bmbm do |x|
    x.report("default") do
      nr.times do
        begin
          s.accept_nonblock
        rescue IO::WaitReadable
        end
      end
    end
    x.report("exception: false") do
      nr.times do
        begin
          s.accept_nonblock(exception: false)
        rescue IO::WaitReadable
          abort "should not raise"
        end
      end
    end
    x.report("exception: false (cached arg)") do
      arg = { exception: false }
      nr.times do
        begin
          s.accept_nonblock(arg)
        rescue IO::WaitReadable
          abort "should not raise"
        end
      end
    end
  end
end

* ext/socket/init.c (rsock_s_accept_nonblock):
  support exception: false
  [ruby-core:66385] [Feature #10532]
* ext/socket/init.c (rsock_init_socket_init): define new symbols
* ext/socket/rubysocket.h: adjust prototype
* ext/socket/socket.c (sock_accept_nonblock): support exception: false
* ext/openssl/ossl_ssl.c (ossl_ssl_accept_nonblock): ditto
* ext/socket/socket.c (Init_socket): adjust accept_nonblock definition
* ext/openssl/ossl_ssl.c (Init_ossl_ssl): ditto
* ext/socket/tcpserver.c (rsock_init_tcpserver): ditto
* ext/socket/unixserver.c (rsock_init_unixserver): ditto
* ext/socket/tcpserver.c (tcp_accept_nonblock): adjust
  rsock_s_accept_nonblock call
* ext/socket/unixserver.c (unix_accept_nonblock): ditto
* ext/openssl/ossl_ssl.c (ossl_start_ssl): support no_exception
* ext/openssl/ossl_ssl.c (ossl_ssl_connect): adjust ossl_start_ssl call
* ext/openssl/ossl_ssl.c (ossl_ssl_connect_nonblock): ditto
* ext/openssl/ossl_ssl.c (ossl_ssl_accept): ditto
* test/socket/test_nonblock.rb (test_accept_nonblock): test for
  "exception :false"
* test/socket/test_tcp.rb (test_accept_nonblock): new test
* test/socket/test_unix.rb (test_accept_nonblock): ditto
* test/openssl/test_pair.rb (test_accept_nonblock_no_exception): ditto

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@49948 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,29 @@
+Thu Mar 12 05:54:27 2015  Eric Wong  <e@80x24.org>
+
+	* ext/socket/init.c (rsock_s_accept_nonblock):
+	  support exception: false
+	  [ruby-core:66385] [Feature #10532]
+	* ext/socket/init.c (rsock_init_socket_init): define new symbols
+	* ext/socket/rubysocket.h: adjust prototype
+	* ext/socket/socket.c (sock_accept_nonblock): support exception: false
+	* ext/openssl/ossl_ssl.c (ossl_ssl_accept_nonblock): ditto
+	* ext/socket/socket.c (Init_socket): adjust accept_nonblock definition
+	* ext/openssl/ossl_ssl.c (Init_ossl_ssl): ditto
+	* ext/socket/tcpserver.c (rsock_init_tcpserver): ditto
+	* ext/socket/unixserver.c (rsock_init_unixserver): ditto
+	* ext/socket/tcpserver.c (tcp_accept_nonblock): adjust
+	  rsock_s_accept_nonblock call
+	* ext/socket/unixserver.c (unix_accept_nonblock): ditto
+	* ext/openssl/ossl_ssl.c (ossl_start_ssl): support no_exception
+	* ext/openssl/ossl_ssl.c (ossl_ssl_connect): adjust ossl_start_ssl call
+	* ext/openssl/ossl_ssl.c (ossl_ssl_connect_nonblock): ditto
+	* ext/openssl/ossl_ssl.c (ossl_ssl_accept): ditto
+	* test/socket/test_nonblock.rb (test_accept_nonblock): test for
+	  "exception :false"
+	* test/socket/test_tcp.rb (test_accept_nonblock): new test
+	* test/socket/test_unix.rb (test_accept_nonblock): ditto
+	* test/openssl/test_pair.rb (test_accept_nonblock_no_exception): ditto
+
 Thu Mar 12 10:53:06 2015  Koichi Sasada  <ko1@atdot.net>
 
 	* internal.h, node.h: move a definition of `struct rb_global_entry'

NEWS

@@ -30,6 +30,14 @@ with all sufficient information, see the ChangeLog file.
 
 === Stdlib updates (outstanding ones only)
 
+* Socket
+  * Socket#accept_nonblock supports `exception :false` to return symbols
+    Ditto for TCPServer#accept_nonblock, UNIXServer#accept_nonblock
+
+* OpenSSL
+  * OpenSSL::SSL::SSLSocket#accept_nonblock supports `exception: false`
+    to return symbols
+
 === Stdlib compatibility issues (excluding feature bug fixes)
 
 * lib/webrick/utils.rb

ext/openssl/ossl_ssl.c

@@ -1271,7 +1271,8 @@ read_would_block(int nonblock)
 }
 
 static VALUE
-ossl_start_ssl(VALUE self, int (*func)(), const char *funcname, int nonblock)
+ossl_start_ssl(VALUE self, int (*func)(), const char *funcname,
+		int nonblock, int no_exception)
 {
     SSL *ssl;
     rb_io_t *fptr;
@@ -1295,10 +1296,12 @@ ossl_start_ssl(VALUE self, int (*func)(), const char *funcname, int nonblock)
 
 	switch((ret2 = ssl_get_error(ssl, ret))){
 	case SSL_ERROR_WANT_WRITE:
+            if (no_exception) { return ID2SYM(rb_intern("wait_writable")); }
             write_would_block(nonblock);
             rb_io_wait_writable(FPTR_TO_FD(fptr));
             continue;
 	case SSL_ERROR_WANT_READ:
+            if (no_exception) { return ID2SYM(rb_intern("wait_readable")); }
             read_would_block(nonblock);
             rb_io_wait_readable(FPTR_TO_FD(fptr));
             continue;
@@ -1324,7 +1327,7 @@ static VALUE
 ossl_ssl_connect(VALUE self)
 {
     ossl_ssl_setup(self);
-    return ossl_start_ssl(self, SSL_connect, "SSL_connect", 0);
+    return ossl_start_ssl(self, SSL_connect, "SSL_connect", 0, 0);
 }
 
 /*
@@ -1349,7 +1352,7 @@ static VALUE
 ossl_ssl_connect_nonblock(VALUE self)
 {
     ossl_ssl_setup(self);
-    return ossl_start_ssl(self, SSL_connect, "SSL_connect", 1);
+    return ossl_start_ssl(self, SSL_connect, "SSL_connect", 1, 0);
 }
 
 /*
@@ -1363,12 +1366,12 @@ static VALUE
 ossl_ssl_accept(VALUE self)
 {
     ossl_ssl_setup(self);
-    return ossl_start_ssl(self, SSL_accept, "SSL_accept", 0);
+    return ossl_start_ssl(self, SSL_accept, "SSL_accept", 0, 0);
 }
 
 /*
  * call-seq:
- *    ssl.accept_nonblock => self
+ *    ssl.accept_nonblock([options]) => self
  *
  * Initiates the SSL/TLS handshake as a server in non-blocking manner.
  *
@@ -1383,12 +1386,24 @@ ossl_ssl_accept(VALUE self)
  *     retry
  *   end
  *
+ * By specifying `exception: false`, the options hash allows you to indicate
+ * that accept_nonblock should not raise an IO::WaitReadable or
+ * IO::WaitWritable exception, but return the symbol :wait_readable or
+ * :wait_writable instead.
  */
 static VALUE
-ossl_ssl_accept_nonblock(VALUE self)
+ossl_ssl_accept_nonblock(int argc, VALUE *argv, VALUE self)
 {
+    int no_exception = 0;
+    VALUE opts = Qnil;
+
+    rb_scan_args(argc, argv, "0:", &opts);
+
+    if (!NIL_P(opts) && Qfalse == rb_hash_aref(opts, sym_exception))
+	no_exception = 1;
+
     ossl_ssl_setup(self);
-    return ossl_start_ssl(self, SSL_accept, "SSL_accept", 1);
+    return ossl_start_ssl(self, SSL_accept, "SSL_accept", 1, no_exception);
 }
 
 static VALUE
@@ -2220,7 +2235,7 @@ Init_ossl_ssl(void)
     rb_define_method(cSSLSocket, "connect",    ossl_ssl_connect, 0);
     rb_define_method(cSSLSocket, "connect_nonblock",    ossl_ssl_connect_nonblock, 0);
     rb_define_method(cSSLSocket, "accept",     ossl_ssl_accept, 0);
-    rb_define_method(cSSLSocket, "accept_nonblock",     ossl_ssl_accept_nonblock, 0);
+    rb_define_method(cSSLSocket, "accept_nonblock", ossl_ssl_accept_nonblock, -1);
     rb_define_method(cSSLSocket, "sysread",    ossl_ssl_read, -1);
     rb_define_private_method(cSSLSocket, "sysread_nonblock",    ossl_ssl_read_nonblock, -1);
     rb_define_method(cSSLSocket, "syswrite",   ossl_ssl_write, 1);

ext/socket/init.c

@@ -29,6 +29,7 @@ VALUE rb_cSOCKSSocket;
 #endif
 
 int rsock_do_not_reverse_lookup = 1;
+static VALUE sym_exception, sym_wait_readable;
 
 void
 rsock_raise_socket_error(const char *reason, int error)
@@ -505,11 +506,18 @@ cloexec_accept(int socket, struct sockaddr *address, socklen_t *address_len)
     return ret;
 }
 
-
 VALUE
-rsock_s_accept_nonblock(VALUE klass, rb_io_t *fptr, struct sockaddr *sockaddr, socklen_t *len)
+rsock_s_accept_nonblock(int argc, VALUE *argv, VALUE klass, rb_io_t *fptr,
+			struct sockaddr *sockaddr, socklen_t *len)
 {
     int fd2;
+    int ex = 1;
+    VALUE opts = Qnil;
+
+    rb_scan_args(argc, argv, "0:", &opts);
+
+    if (!NIL_P(opts) && Qfalse == rb_hash_aref(opts, sym_exception))
+	ex = 0;
 
     rb_secure(3);
     rb_io_set_nonblock(fptr);
@@ -524,6 +532,8 @@ rsock_s_accept_nonblock(VALUE klass, rb_io_t *fptr, struct sockaddr *sockaddr, s
 #if defined EPROTO
 	  case EPROTO:
 #endif
+            if (!ex)
+		return sym_wait_readable;
             rb_readwrite_sys_fail(RB_IO_WAIT_READABLE, "accept(2) would block");
 	}
         rb_sys_fail("accept(2)");
@@ -612,4 +622,8 @@ rsock_init_socket_init(void)
     rsock_init_addrinfo();
     rsock_init_sockifaddr();
     rsock_init_socket_constants();
+
+#undef rb_intern
+    sym_exception = ID2SYM(rb_intern("exception"));
+    sym_wait_readable = ID2SYM(rb_intern("wait_readable"));
 }

ext/socket/rubysocket.h

@@ -343,7 +343,7 @@ VALUE rsock_s_recvfrom(VALUE sock, int argc, VALUE *argv, enum sock_recv_type fr
 int rsock_connect(int fd, const struct sockaddr *sockaddr, int len, int socks);
 
 VALUE rsock_s_accept(VALUE klass, int fd, struct sockaddr *sockaddr, socklen_t *len);
-VALUE rsock_s_accept_nonblock(VALUE klass, rb_io_t *fptr, struct sockaddr *sockaddr, socklen_t *len);
+VALUE rsock_s_accept_nonblock(int argc, VALUE *argv, VALUE klass, rb_io_t *fptr, struct sockaddr *sockaddr, socklen_t *len);
 VALUE rsock_sock_listen(VALUE sock, VALUE log);
 
 VALUE rsock_sockopt_new(int family, int level, int optname, VALUE data);

ext/socket/socket.c

@@ -894,7 +894,7 @@ sock_accept(VALUE sock)
 
 /*
  * call-seq:
- *   socket.accept_nonblock => [client_socket, client_addrinfo]
+ *   socket.accept_nonblock([options]) => [client_socket, client_addrinfo]
  *
  * Accepts an incoming connection using accept(2) after
  * O_NONBLOCK is set for the underlying file descriptor.
@@ -940,19 +940,27 @@ sock_accept(VALUE sock)
  * it is extended by IO::WaitReadable.
  * So IO::WaitReadable can be used to rescue the exceptions for retrying accept_nonblock.
  *
+ * By specifying `exception: false`, the options hash allows you to indicate
+ * that accept_nonblock should not raise an IO::WaitReadable exception, but
+ * return the symbol :wait_readable instead.
+ *
  * === See
  * * Socket#accept
  */
 static VALUE
-sock_accept_nonblock(VALUE sock)
+sock_accept_nonblock(int argc, VALUE *argv, VALUE sock)
 {
     rb_io_t *fptr;
     VALUE sock2;
     union_sockaddr buf;
+    struct sockaddr *addr = &buf.addr;
     socklen_t len = (socklen_t)sizeof buf;
 
     GetOpenFile(sock, fptr);
-    sock2 = rsock_s_accept_nonblock(rb_cSocket, fptr, &buf.addr, &len);
+    sock2 = rsock_s_accept_nonblock(argc, argv, rb_cSocket, fptr, addr, &len);
+
+    if (SYMBOL_P(sock2)) /* :wait_readable */
+	return sock2;
     return rb_assoc_new(sock2, rsock_io_socket_addrinfo(sock2, &buf.addr, len));
 }
 
@@ -2154,7 +2162,7 @@ Init_socket(void)
     rb_define_method(rb_cSocket, "bind", sock_bind, 1);
     rb_define_method(rb_cSocket, "listen", rsock_sock_listen, 1);
     rb_define_method(rb_cSocket, "accept", sock_accept, 0);
-    rb_define_method(rb_cSocket, "accept_nonblock", sock_accept_nonblock, 0);
+    rb_define_method(rb_cSocket, "accept_nonblock", sock_accept_nonblock, -1);
     rb_define_method(rb_cSocket, "sysaccept", sock_sysaccept, 0);
 
     rb_define_method(rb_cSocket, "recvfrom", sock_recvfrom, -1);

ext/socket/tcpserver.c

@@ -66,7 +66,7 @@ tcp_accept(VALUE sock)
 
 /*
  * call-seq:
- *   tcpserver.accept_nonblock => tcpsocket
+ *   tcpserver.accept_nonblock([options]) => tcpsocket
  *
  * Accepts an incoming connection using accept(2) after
  * O_NONBLOCK is set for the underlying file descriptor.
@@ -93,12 +93,16 @@ tcp_accept(VALUE sock)
  * it is extended by IO::WaitReadable.
  * So IO::WaitReadable can be used to rescue the exceptions for retrying accept_nonblock.
  *
+ * By specifying `exception: false`, the options hash allows you to indicate
+ * that accept_nonblock should not raise an IO::WaitReadable exception, but
+ * return the symbol :wait_readable instead.
+ *
  * === See
  * * TCPServer#accept
  * * Socket#accept
  */
 static VALUE
-tcp_accept_nonblock(VALUE sock)
+tcp_accept_nonblock(int argc, VALUE *argv, VALUE sock)
 {
     rb_io_t *fptr;
     union_sockaddr from;
@@ -106,7 +110,7 @@ tcp_accept_nonblock(VALUE sock)
 
     GetOpenFile(sock, fptr);
     fromlen = (socklen_t)sizeof(from);
-    return rsock_s_accept_nonblock(rb_cTCPSocket, fptr, &from.addr, &fromlen);
+    return rsock_s_accept_nonblock(argc, argv, rb_cTCPSocket, fptr, &from.addr, &fromlen);
 }
 
 /*
@@ -171,7 +175,7 @@ rsock_init_tcpserver(void)
      */
     rb_cTCPServer = rb_define_class("TCPServer", rb_cTCPSocket);
     rb_define_method(rb_cTCPServer, "accept", tcp_accept, 0);
-    rb_define_method(rb_cTCPServer, "accept_nonblock", tcp_accept_nonblock, 0);
+    rb_define_method(rb_cTCPServer, "accept_nonblock", tcp_accept_nonblock, -1);
     rb_define_method(rb_cTCPServer, "sysaccept", tcp_sysaccept, 0);
     rb_define_method(rb_cTCPServer, "initialize", tcp_svr_init, -1);
     rb_define_method(rb_cTCPServer, "listen", rsock_sock_listen, 1); /* in socket.c */

ext/socket/unixserver.c

@@ -59,7 +59,7 @@ unix_accept(VALUE sock)
 
 /*
  * call-seq:
- *   unixserver.accept_nonblock => unixsocket
+ *   unixserver.accept_nonblock([options]) => unixsocket
  *
  * Accepts an incoming connection using accept(2) after
  * O_NONBLOCK is set for the underlying file descriptor.
@@ -86,12 +86,16 @@ unix_accept(VALUE sock)
  * it is extended by IO::WaitReadable.
  * So IO::WaitReadable can be used to rescue the exceptions for retrying accept_nonblock.
  *
+ * By specifying `exception: false`, the options hash allows you to indicate
+ * that accept_nonblock should not raise an IO::WaitReadable exception, but
+ * return the symbol :wait_readable instead.
+ *
  * === See
  * * UNIXServer#accept
  * * Socket#accept
  */
 static VALUE
-unix_accept_nonblock(VALUE sock)
+unix_accept_nonblock(int argc, VALUE *argv, VALUE sock)
 {
     rb_io_t *fptr;
     struct sockaddr_un from;
@@ -99,7 +103,7 @@ unix_accept_nonblock(VALUE sock)
 
     GetOpenFile(sock, fptr);
     fromlen = (socklen_t)sizeof(from);
-    return rsock_s_accept_nonblock(rb_cUNIXSocket, fptr,
+    return rsock_s_accept_nonblock(argc, argv, rb_cUNIXSocket, fptr,
 			           (struct sockaddr *)&from, &fromlen);
 }
 
@@ -148,7 +152,7 @@ rsock_init_unixserver(void)
     rb_cUNIXServer = rb_define_class("UNIXServer", rb_cUNIXSocket);
     rb_define_method(rb_cUNIXServer, "initialize", unix_svr_init, 1);
     rb_define_method(rb_cUNIXServer, "accept", unix_accept, 0);
-    rb_define_method(rb_cUNIXServer, "accept_nonblock", unix_accept_nonblock, 0);
+    rb_define_method(rb_cUNIXServer, "accept_nonblock", unix_accept_nonblock, -1);
     rb_define_method(rb_cUNIXServer, "sysaccept", unix_sysaccept, 0);
     rb_define_method(rb_cUNIXServer, "listen", rsock_sock_listen, 1); /* in socket.c */
 #endif

test/openssl/test_pair.rb

@@ -283,6 +283,33 @@ module OpenSSL::TestPairM
     serv.close if serv && !serv.closed?
   end
 
+  def test_accept_nonblock_no_exception
+    ctx2 = OpenSSL::SSL::SSLContext.new
+    ctx2.ciphers = "ADH"
+    ctx2.tmp_dh_callback = proc { OpenSSL::TestUtils::TEST_KEY_DH1024 }
+
+    sock1, sock2 = tcp_pair
+
+    s2 = OpenSSL::SSL::SSLSocket.new(sock2, ctx2)
+    accepted = s2.accept_nonblock(exception: false)
+    assert_equal :wait_readable, accepted
+
+    ctx1 = OpenSSL::SSL::SSLContext.new
+    ctx1.ciphers = "ADH"
+    s1 = OpenSSL::SSL::SSLSocket.new(sock1, ctx1)
+    th = Thread.new { s1.connect }
+    until th.join(0.01)
+      accepted = s2.accept_nonblock(exception: false)
+      assert_includes([s2, :wait_readable, :wait_writable ], accepted)
+    end
+  ensure
+    s1.close if s1
+    s2.close if s2
+    sock1.close if sock1
+    sock2.close if sock2
+    accepted.close if accepted.respond_to?(:close)
+  end
+
   def test_connect_accept_nonblock
     ctx = OpenSSL::SSL::SSLContext.new()
     ctx.ciphers = "ADH"

test/socket/test_nonblock.rb

@@ -13,6 +13,8 @@ class TestSocketNonblock < Test::Unit::TestCase
     serv.bind(Socket.sockaddr_in(0, "127.0.0.1"))
     serv.listen(5)
     assert_raise(IO::WaitReadable) { serv.accept_nonblock }
+    assert_equal :wait_readable, serv.accept_nonblock(exception: false)
+    assert_raise(IO::WaitReadable) { serv.accept_nonblock(exception: true) }
     c = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
     c.connect(serv.getsockname)
     begin

test/socket/test_tcp.rb

@@ -76,4 +76,12 @@ class TestSocket_TCPSocket < Test::Unit::TestCase
       th.join
     }
   end
+
+  def test_accept_nonblock
+    TCPServer.open("localhost", 0) {|svr|
+      assert_raises(IO::WaitReadable) { svr.accept_nonblock }
+      assert_equal :wait_readable, svr.accept_nonblock(exception: false)
+      assert_raises(IO::WaitReadable) { svr.accept_nonblock(exception: true) }
+    }
+  end
 end if defined?(TCPSocket)

test/socket/test_unix.rb

@@ -663,4 +663,11 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
     assert(s0.closed?)
   end
 
+  def test_accept_nonblock
+    bound_unix_socket(UNIXServer) {|serv, path|
+      assert_raises(IO::WaitReadable) { serv.accept_nonblock }
+      assert_raises(IO::WaitReadable) { serv.accept_nonblock(exception: true) }
+      assert_equal :wait_readable, serv.accept_nonblock(exception: false)
+    }
+  end
 end if defined?(UNIXSocket) && /cygwin/ !~ RUBY_PLATFORM