1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
ruby--ruby/test/socket/test_basicsocket.rb
normal 6a65f2b1e4 io + socket: make pipes and sockets nonblocking by default
All normal Ruby IO methods (IO#read, IO#gets, IO#write, ...) are
all capable of appearing to be "blocking" when presented with a
file description with the O_NONBLOCK flag set; so there is
little risk of incompatibility within Ruby-using programs.

The biggest compatibility risk is when spawning external
programs.  As a result, stdin, stdout, and stderr are now always
made blocking before exec-family calls.

This change will make an event-oriented MJIT usable if it is
waiting on pipes on POSIX_like platforms.

It is ALSO necessary to take advantage of (proposed lightweight
concurrency (aka "auto-Fiber") or any similar proposal for
network concurrency: https://bugs.ruby-lang.org/issues/13618

Named-pipe (FIFO) are NOT yet non-blocking by default since
they are rarely-used and may introduce compatibility problems
and extra syscall overhead for a common path.

Please revert this commit if there are problems and if I am afk
since I am afk a lot, lately.

[ruby-core:89950] [Bug #14968]

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@65922 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2018-11-22 08:46:51 +00:00

230 lines
6 KiB
Ruby

# frozen_string_literal: true
begin
require "socket"
require "test/unit"
require "io/nonblock"
rescue LoadError
end
class TestSocket_BasicSocket < Test::Unit::TestCase
def inet_stream
sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
yield sock
ensure
assert(sock.closed?)
end
def test_getsockopt
inet_stream do |s|
begin
n = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_TYPE)
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
n = s.getsockopt("SOL_SOCKET", "SO_TYPE")
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
n = s.getsockopt(:SOL_SOCKET, :SO_TYPE)
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
n = s.getsockopt(:SOCKET, :TYPE)
assert_equal([Socket::SOCK_STREAM].pack("i"), n.data)
n = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
assert_equal([0].pack("i"), n.data)
rescue Minitest::Assertion
s.close
if /aix/ =~ RUBY_PLATFORM
skip "Known bug in getsockopt(2) on AIX"
end
raise $!
end
val = Object.new
class << val; self end.send(:define_method, :to_int) {
s.close
Socket::SO_TYPE
}
assert_raise(IOError) {
n = s.getsockopt(Socket::SOL_SOCKET, val)
}
end
end
def test_setsockopt
s = nil
linger = [0, 0].pack("ii")
val = Object.new
class << val; self end.send(:define_method, :to_str) {
s.close
linger
}
inet_stream do |sock|
s = sock
assert_equal(0, s.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, linger))
assert_raise(IOError, "[ruby-dev:25039]") {
s.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, val)
}
end
val = Object.new
class << val; self end.send(:define_method, :to_int) {
s.close
Socket::SO_LINGER
}
inet_stream do |sock|
s = sock
assert_raise(IOError) {
s.setsockopt(Socket::SOL_SOCKET, val, linger)
}
end
end
def test_listen
s = nil
log = Object.new
class << log; self end.send(:define_method, :to_int) {
s.close
2
}
inet_stream do |sock|
s = sock
assert_raise(IOError) {
s.listen(log)
}
end
end
def socks
sserv = TCPServer.new('localhost', 0)
ssock = nil
t = Thread.new { ssock = sserv.accept }
csock = TCPSocket.new('localhost', sserv.addr[1])
t.join
yield sserv, ssock, csock
ensure
ssock.close rescue nil
csock.close rescue nil
sserv.close rescue nil
end
def test_close_read
socks do |sserv, ssock, csock|
# close_read makes subsequent reads raise IOError
csock.close_read
assert_raise(IOError) { csock.read(5) }
# close_read ignores any error from shutting down half of still-open socket
assert_nothing_raised { csock.close_read }
# close_read raises if socket is not open
assert_nothing_raised { csock.close }
assert_raise(IOError) { csock.close_read }
end
end
def test_close_write
socks do |sserv, ssock, csock|
# close_write makes subsequent writes raise IOError
csock.close_write
assert_raise(IOError) { csock.write(5) }
# close_write ignores any error from shutting down half of still-open socket
assert_nothing_raised { csock.close_write }
# close_write raises if socket is not open
assert_nothing_raised { csock.close }
assert_raise(IOError) { csock.close_write }
end
end
def test_for_fd
assert_raise(Errno::EBADF, '[ruby-core:72418] [Bug #11854]') do
BasicSocket.for_fd(-1)
end
inet_stream do |sock|
s = BasicSocket.for_fd(sock.fileno)
assert_instance_of BasicSocket, s
s.autoclose = false
sock.close
end
end
def test_read_write_nonblock
socks do |sserv, ssock, csock|
set_nb = true
buf = String.new
if ssock.respond_to?(:nonblock?)
assert_predicate(ssock, :nonblock?)
assert_predicate(csock, :nonblock?)
csock.nonblock = ssock.nonblock = false
# Linux may use MSG_DONTWAIT to avoid setting O_NONBLOCK
if RUBY_PLATFORM.match?(/linux/) && Socket.const_defined?(:MSG_DONTWAIT)
set_nb = false
end
end
assert_equal :wait_readable, ssock.read_nonblock(1, buf, exception: false)
assert_equal 5, csock.write_nonblock('hello')
IO.select([ssock])
assert_same buf, ssock.read_nonblock(5, buf, exception: false)
assert_equal 'hello', buf
buf = '*' * 16384
n = 0
case w = csock.write_nonblock(buf, exception: false)
when Integer
n += w
when :wait_writable
break
end while true
assert_equal :wait_writable, w
assert_raise(IO::WaitWritable) { loop { csock.write_nonblock(buf) } }
assert_operator n, :>, 0
assert_not_predicate(csock, :nonblock?, '[Feature #13362]') unless set_nb
csock.close
case r = ssock.read_nonblock(16384, buf, exception: false)
when String
next
when nil
break
when :wait_readable
IO.select([ssock], nil, nil, 10) or
flunk 'socket did not become readable'
else
flunk "unexpected read_nonblock return: #{r.inspect}"
end while true
assert_raise(EOFError) { ssock.read_nonblock(1) }
assert_not_predicate(ssock, :nonblock?) unless set_nb
end
end
def test_read_nonblock_mix_buffered
socks do |sserv, ssock, csock|
ssock.write("hello\nworld\n")
assert_equal "hello\n", csock.gets
IO.select([csock], nil, nil, 10) or
flunk 'socket did not become readable'
assert_equal "world\n", csock.read_nonblock(8)
end
end
def test_write_nonblock_buffered
socks do |sserv, ssock, csock|
ssock.sync = false
ssock.write("h")
assert_equal :wait_readable, csock.read_nonblock(1, exception: false)
assert_equal 4, ssock.write_nonblock("ello")
ssock.close
assert_equal "hello", csock.read(5)
end
end
end if defined?(BasicSocket)