From: Zachary Scott <e@...>
Date: 2015-01-08T19:03:06-08:00
Subject: [ruby-core:67451] Re: [ruby-trunk - Feature #10718] [Open] IO#close should not raise IOError on closed IO objects.

--047d7bfd012a4f439c050c2f65ec
Content-Type: text/plain; charset=UTF-8

I think the API is improved but I'm not sure we need to find & replace
every occurrence in the stdlib

On Thursday, January 8, 2015, <normalperson@yhbt.net> wrote:

> Issue #10718 has been updated by Eric Wong.
>
>
>  Thank you for proposing this.  I think this will simplify working with
>  Ruby IO and make me happier since I work with a lot of IO-related code.
>  Outside of test cases, I don't forsee compatibility problems either.
>
> ----------------------------------------
> Feature #10718: IO#close should not raise IOError on closed IO objects.
> https://bugs.ruby-lang.org/issues/10718#change-50875
>
> * Author: Akira Tanaka
> * Status: Open
> * Priority: Normal
> * Assignee:
> * Category:
> * Target version:
> ----------------------------------------
> I'd like to change IO#close.
> It should not raise IOError on closed IO objects.
>
> We sometimes invoke IO#close only when the IO object is not closed as:
>
> ```
> f.close if !f.closed?
> ```
>
> If this issue is accepted, we can write it simply as follows.
>
> ```
> f.close
> ```
>
> Simple grep finds many examples.
> Following examples are just a little excerpt.
>
> ```
> lib/webrick/server.rb:          sock.close unless sock.closed?
> lib/pstore.rb:          file.close if !file.closed?
> lib/mkmf.rb:          @log.close if @log and not @log.closed?
> lib/cgi/session.rb:          f.close if f and !f.closed?
> lib/open-uri.rb:          io.close if !io.closed?
> lib/net/pop.rb:        s.close if s and not s.closed?
> lib/net/http.rb:          @socket.close if @socket and not @socket.closed?
> lib/net/smtp.rb:        s.close if s and not s.closed?
> lib/shell/process-controller.rb:                io.close unless io.closed?
> test/ruby/test_io.rb:    w.close unless !w || w.closed?
> ...
> ```
>
> I think there is no problem with the behavior which IO#close doesn't raise
> an exception on closed IO object.
> Because the closed state fulfils the postcondition of the method.
>
> Moreover raising IOError can smash other exceptions if it is called in
> ensure clause.
> It makes debugging difficult and the proposed behavior ease it.
>
> It also useful to close IO object asynchronously.
> Asynchronous close can be used for graceful shutdown.
> This issue can eliminate "rescue IOError".
> See lib/webrick/server.rb and lib/drb/drb.rb for example.
>
> Note that "double close" is a bad idea in C.
> But it is not applicable to Ruby.
> A FILE structure is freed on fclose().
> But Ruby's IO object is not freed until GC.
> So method invocation on closed object doesn't cause invalid memory access.
> A file descriptor (FD) can be reused any time because a signal handler or
> another thread may allocate a FD.
> But Ruby's IO object is not reused after close.
> So it is impossible to close an IO object unintentionally.
>
>
> ---Files--------------------------------
> io-close.patch (1.97 KB)
>
>
> --
> https://bugs.ruby-lang.org/
>

--047d7bfd012a4f439c050c2f65ec
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

I think the API is improved but I&#39;m not sure we need to find &amp; repl=
ace every occurrence in the stdlib<span></span><br><br>On Thursday, January=
 8, 2015,  &lt;<a href=3D"mailto:normalperson@yhbt.net">normalperson@yhbt.n=
et</a>&gt; wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0 0 =
0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Issue #10718 has been u=
pdated by Eric Wong.<br>
<br>
<br>
=C2=A0Thank you for proposing this.=C2=A0 I think this will simplify workin=
g with<br>
=C2=A0Ruby IO and make me happier since I work with a lot of IO-related cod=
e.<br>
=C2=A0Outside of test cases, I don&#39;t forsee compatibility problems eith=
er.<br>
<br>
----------------------------------------<br>
Feature #10718: IO#close should not raise IOError on closed IO objects.<br>
<a href=3D"https://bugs.ruby-lang.org/issues/10718#change-50875" target=3D"=
_blank">https://bugs.ruby-lang.org/issues/10718#change-50875</a><br>
<br>
* Author: Akira Tanaka<br>
* Status: Open<br>
* Priority: Normal<br>
* Assignee:<br>
* Category:<br>
* Target version:<br>
----------------------------------------<br>
I&#39;d like to change IO#close.<br>
It should not raise IOError on closed IO objects.<br>
<br>
We sometimes invoke IO#close only when the IO object is not closed as:<br>
<br>
```<br>
f.close if !f.closed?<br>
```<br>
<br>
If this issue is accepted, we can write it simply as follows.<br>
<br>
```<br>
f.close<br>
```<br>
<br>
Simple grep finds many examples.<br>
Following examples are just a little excerpt.<br>
<br>
```<br>
lib/webrick/server.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 sock.close unless =
sock.closed?<br>
lib/pstore.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 file.close if !file.closed=
?<br>
lib/mkmf.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 @log.close if @log and not @=
log.closed?<br>
lib/cgi/session.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 f.close if f and !f.c=
losed?<br>
lib/open-uri.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 io.close if !io.closed?<=
br>
lib/net/pop.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 s.close if s and not s.closed?<b=
r>
lib/net/http.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 @socket.close if @socket=
 and not @socket.closed?<br>
lib/net/smtp.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 s.close if s and not s.closed?<=
br>
lib/shell/process-controller.rb:=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 io.close unless io.closed?<br>
test/ruby/test_io.rb:=C2=A0 =C2=A0 w.close unless !w || w.closed?<br>
...<br>
```<br>
<br>
I think there is no problem with the behavior which IO#close doesn&#39;t ra=
ise an exception on closed IO object.<br>
Because the closed state fulfils the postcondition of the method.<br>
<br>
Moreover raising IOError can smash other exceptions if it is called in ensu=
re clause.<br>
It makes debugging difficult and the proposed behavior ease it.<br>
<br>
It also useful to close IO object asynchronously.<br>
Asynchronous close can be used for graceful shutdown.<br>
This issue can eliminate &quot;rescue IOError&quot;.<br>
See lib/webrick/server.rb and lib/drb/drb.rb for example.<br>
<br>
Note that &quot;double close&quot; is a bad idea in C.<br>
But it is not applicable to Ruby.<br>
A FILE structure is freed on fclose().<br>
But Ruby&#39;s IO object is not freed until GC.<br>
So method invocation on closed object doesn&#39;t cause invalid memory acce=
ss.<br>
A file descriptor (FD) can be reused any time because a signal handler or a=
nother thread may allocate a FD.<br>
But Ruby&#39;s IO object is not reused after close.<br>
So it is impossible to close an IO object unintentionally.<br>
<br>
<br>
---Files--------------------------------<br>
io-close.patch (1.97 KB)<br>
<br>
<br>
--<br>
<a href=3D"https://bugs.ruby-lang.org/" target=3D"_blank">https://bugs.ruby=
-lang.org/</a><br>
</blockquote>

--047d7bfd012a4f439c050c2f65ec--