From aaf2d070a8351dc3118422bae478978f3d3e3966 Mon Sep 17 00:00:00 2001 From: normal Date: Thu, 12 Mar 2015 03:03:04 +0000 Subject: 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 --- ext/socket/init.c | 18 ++++++++++++++++-- ext/socket/rubysocket.h | 2 +- ext/socket/socket.c | 16 ++++++++++++---- ext/socket/tcpserver.c | 12 ++++++++---- ext/socket/unixserver.c | 12 ++++++++---- 5 files changed, 45 insertions(+), 15 deletions(-) (limited to 'ext/socket') diff --git a/ext/socket/init.c b/ext/socket/init.c index c3f33964a8..b94b25098c 100644 --- a/ext/socket/init.c +++ b/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")); } diff --git a/ext/socket/rubysocket.h b/ext/socket/rubysocket.h index 8beffd2e76..689a7a8219 100644 --- a/ext/socket/rubysocket.h +++ b/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); diff --git a/ext/socket/socket.c b/ext/socket/socket.c index eeee571036..bb18409489 100644 --- a/ext/socket/socket.c +++ b/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); diff --git a/ext/socket/tcpserver.c b/ext/socket/tcpserver.c index 2245a0600d..578377b4f9 100644 --- a/ext/socket/tcpserver.c +++ b/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 */ diff --git a/ext/socket/unixserver.c b/ext/socket/unixserver.c index df9849703b..a38d0cb5f5 100644 --- a/ext/socket/unixserver.c +++ b/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 -- cgit v1.2.3