mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
6a65f2b1e4
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
230 lines
6 KiB
Ruby
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)
|