Issue #20215 has been updated by ioquatix (Samuel Williams).
Would io.wait_readable(0) work instead? If not, why not?
(1) I don't think it makes sense to add `wait_*` to `StringIO` but it does make sense to add `readable?` to `StringIO`. (2) `wait_readable(0)` is impossible to replicate the desired behaviour: ```
r, w = Socket.pair(:UNIX, :STREAM) => [#<Socket:fd 5>, #<Socket:fd 6>] irb(main):003> r.wait_readable(0) => nil # Not readable (no data available right now within the timeout specified) irb(main):004> r.readable? => true # It's possible to read from this socket. irb(main):005> w.close => nil irb(main):006> r.wait_readable(0) => #<Socket:fd 5> # It's possible to read the "close" (zero-size). irb(main):007> r.readable? => false # The socket is not readable (call to `#read` will not give data).
----------------------------------------
Feature #20215: Introduce `IO#readable?`
https://bugs.ruby-lang.org/issues/20215#change-107910
* Author: ioquatix (Samuel Williams)
* Status: Open
----------------------------------------
There are some cases where, as an optimisation, it's useful to know whether more data is potentially available.
We already have `IO#eof?` but the problem with using `IO#eof?` is that it can block indefinitely for sockets.
Therefore, code which uses `IO#eof?` to determine if there is potentially more data, may hang.
```ruby
def make_request(path = "/")
client = connect_remote_host
# HTTP/1.0 request:
client.write("GET #{path} HTTP/1.0\r\n\r\n")
# Read response
client.gets("\r\n") # => "HTTP/1.0 200 OK\r\n"
# Assuming connection close, there are two things the server can do:
# 1. peer.close
# 2. peer.write(...); peer.close
if client.eof? # <--- Can hang here!
puts "Connection closed"
# Avoid yielding as we know there definitely won't be any data.
else
puts "Connection open, data may be available..."
# There might be data available, so yield.
yield(client)
end
ensure
client&.close
end
make_request do |client|
puts client.read # <--- Prefer to wait here.
end
The proposed `IO#readable?` is similar to `IO#eof?` but rather than blocking, would simply return false. The expectation is the user will subsequently call `read` which may then wait. The proposed implementation would look something like this: ```ruby class IO def readable? !self.closed? end end class BasicSocket # Is it likely that the socket is still connected? # May return false positive, but won't return false negative. def readable? return false unless super # If we can wait for the socket to become readable, we know that the socket may still be open. result = self.recv_nonblock(1, MSG_PEEK, exception: false) # No data was available - newer Ruby can return nil instead of empty string: return false if result.nil? # Either there was some data available, or we can wait to see if there is data avaialble. return !result.empty? || result == :wait_readable rescue Errno::ECONNRESET # This might be thrown by recv_nonblock. return false end end ``` For `IO` itself, when there is buffered data, `readable?` would also return true immediately, similar to `eof?`. This is not shown in the above implementation as I'm not sure if there is any Ruby method which exposes "there is buffered data". -- https://bugs.ruby-lang.org/