mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
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
This commit is contained in:
parent
724012a23d
commit
aaf2d070a8
12 changed files with 146 additions and 23 deletions
26
ChangeLog
26
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'
|
||||
|
|
8
NEWS
8
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
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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"));
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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 */
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
|
|
Loading…
Reference in a new issue