ruby-changes:37867
From: normal <ko1@a...>
Date: Thu, 12 Mar 2015 12:03:28 +0900 (JST)
Subject: [ruby-changes:37867] normal:r49948 (trunk): accept_nonblock supports "exception: false"
normal 2015-03-12 12:03:04 +0900 (Thu, 12 Mar 2015) New Revision: 49948 http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=49948 Log: 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 Modified files: trunk/ChangeLog trunk/NEWS trunk/ext/openssl/ossl_ssl.c trunk/ext/socket/init.c trunk/ext/socket/rubysocket.h trunk/ext/socket/socket.c trunk/ext/socket/tcpserver.c trunk/ext/socket/unixserver.c trunk/test/openssl/test_pair.rb trunk/test/socket/test_nonblock.rb trunk/test/socket/test_tcp.rb trunk/test/socket/test_unix.rb Index: ChangeLog =================================================================== --- ChangeLog (revision 49947) +++ ChangeLog (revision 49948) @@ -1,3 +1,29 @@ https://github.com/ruby/ruby/blob/trunk/ChangeLog#L1 +Thu Mar 12 05:54:27 2015 Eric Wong <e@8...> + + * 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@a...> * internal.h, node.h: move a definition of `struct rb_global_entry' Index: ext/openssl/ossl_ssl.c =================================================================== --- ext/openssl/ossl_ssl.c (revision 49947) +++ ext/openssl/ossl_ssl.c (revision 49948) @@ -1271,7 +1271,8 @@ read_would_block(int nonblock) https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L1271 } 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)() https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L1296 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 https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L1327 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 https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L1352 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 https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L1366 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) https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L1386 * 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) https://github.com/ruby/ruby/blob/trunk/ext/openssl/ossl_ssl.c#L2235 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); Index: ext/socket/rubysocket.h =================================================================== --- ext/socket/rubysocket.h (revision 49947) +++ ext/socket/rubysocket.h (revision 49948) @@ -343,7 +343,7 @@ VALUE rsock_s_recvfrom(VALUE sock, int a https://github.com/ruby/ruby/blob/trunk/ext/socket/rubysocket.h#L343 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); Index: ext/socket/init.c =================================================================== --- ext/socket/init.c (revision 49947) +++ ext/socket/init.c (revision 49948) @@ -29,6 +29,7 @@ VALUE rb_cSOCKSSocket; https://github.com/ruby/ruby/blob/trunk/ext/socket/init.c#L29 #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 sockad https://github.com/ruby/ruby/blob/trunk/ext/socket/init.c#L506 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_ https://github.com/ruby/ruby/blob/trunk/ext/socket/init.c#L532 #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) https://github.com/ruby/ruby/blob/trunk/ext/socket/init.c#L622 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")); } Index: ext/socket/unixserver.c =================================================================== --- ext/socket/unixserver.c (revision 49947) +++ ext/socket/unixserver.c (revision 49948) @@ -59,7 +59,7 @@ unix_accept(VALUE sock) https://github.com/ruby/ruby/blob/trunk/ext/socket/unixserver.c#L59 /* * 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/unixserver.c#L86 * 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/unixserver.c#L103 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/unixserver.c#L152 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 Index: ext/socket/tcpserver.c =================================================================== --- ext/socket/tcpserver.c (revision 49947) +++ ext/socket/tcpserver.c (revision 49948) @@ -66,7 +66,7 @@ tcp_accept(VALUE sock) https://github.com/ruby/ruby/blob/trunk/ext/socket/tcpserver.c#L66 /* * 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/tcpserver.c#L93 * 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/tcpserver.c#L110 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/tcpserver.c#L175 */ 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 */ Index: ext/socket/socket.c =================================================================== --- ext/socket/socket.c (revision 49947) +++ ext/socket/socket.c (revision 49948) @@ -894,7 +894,7 @@ sock_accept(VALUE sock) https://github.com/ruby/ruby/blob/trunk/ext/socket/socket.c#L894 /* * 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/socket.c#L940 * 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) https://github.com/ruby/ruby/blob/trunk/ext/socket/socket.c#L2162 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); Index: NEWS =================================================================== --- NEWS (revision 49947) +++ NEWS (revision 49948) @@ -30,6 +30,14 @@ with all sufficient information, see the https://github.com/ruby/ruby/blob/trunk/NEWS#L30 === 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 Index: test/openssl/test_pair.rb =================================================================== --- test/openssl/test_pair.rb (revision 49947) +++ test/openssl/test_pair.rb (revision 49948) @@ -283,6 +283,33 @@ module OpenSSL::TestPairM https://github.com/ruby/ruby/blob/trunk/test/openssl/test_pair.rb#L283 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" Index: test/socket/test_unix.rb =================================================================== --- test/socket/test_unix.rb (revision 49947) +++ test/socket/test_unix.rb (revision 49948) @@ -663,4 +663,11 @@ class TestSocket_UNIXSocket < Test::Unit https://github.com/ruby/ruby/blob/trunk/test/socket/test_unix.rb#L663 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 Index: test/socket/test_nonblock.rb =================================================================== --- test/socket/test_nonblock.rb (revision 49947) +++ test/socket/test_nonblock.rb (revision 49948) @@ -13,6 +13,8 @@ class TestSocketNonblock < Test::Unit::T https://github.com/ruby/ruby/blob/trunk/test/socket/test_nonblock.rb#L13 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 Index: test/socket/test_tcp.rb =================================================================== --- test/socket/test_tcp.rb (revision 49947) +++ test/socket/test_tcp.rb (revision 49948) @@ -76,4 +76,12 @@ class TestSocket_TCPSocket < Test::Unit: https://github.com/ruby/ruby/blob/trunk/test/socket/test_tcp.rb#L76 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) -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/