[ruby-core:55168] [ruby-trunk - Bug #8442] sendmesg (blocking) of class BasicSocket is repeatably sent by the ruby kernel

Issue #8442 has been updated by m_josenhans (Michael Josenhans).


Similar bugs have been reported to Jruby & Rubinius:
   https://github.com/rubinius/rubinius/issues/2362
   http://jira.codehaus.org/browse/JRUBY-7169
----------------------------------------
Bug #8442: sendmesg (blocking) of class BasicSocket is repeatably sent by the ruby kernel
https://bugs.ruby-lang.org/issues/8442#change-39533

Author: m_josenhans (Michael Josenhans)
Status: Open
Priority: Normal
Assignee: 
Category: core
Target version: next minor
ruby -v: ruby 2.0.0p0 (2013-02-24 revision 39474) [x86_64-linux]
Backport: 1.9.3: UNKNOWN, 2.0.0: UNKNOWN


=begin
 
(1) The error occurs with the method "sendmesg" (blocking) of class BasicSocket on Ruby 2.0.0-p0 (rvm), but does not occur on Ruby 1.9.3-p392 (rvm).
(2) The error does not occur with the method "send" (non-blocking) of class BasicSocket on Ruby 1.9.3-p392 (rvm) and Ruby 2.0.0-p0 (rvm).

The bug can be reproduced with the code attached.

* For (1) use the code as attached. The send message occurs at line 50 & 51.
* For (2) comment out line 50 & 51 and uncomment line 52 & 53.

How to reproduce the error:

run:
* (({ruby halfsync_halfasync.rb})) 

on second terminal (unix):
* (({telnet localhost 10001}))


on Windows use telnet client e.g. putty and make sure to configure putty as passive ("Connection->Telnet->Telnet negotiation mode: Passive")


What the code does: 
It implements the halfsync_halfasync design-pattern (see references in the code).
* An (({EchoAcceptor})) is registered with the reactor to accept connection setup.
* A thread pool is started waiting for tasks to be retrieved from a shared queue
* Upon connection-setup of the telnet the (({EchoAcceptor})) is called and registers an (({EchoServerHandler})) with the Reactor to handle data received via the connection from the telnet client.
* Upon reception of data via the telent connection, the (({EchoServerHandler})) assembles data until a newline (\n or \r\n) is received. When that is received, the whole line is put into the shared queue.
* The first thread from the thread pool waiting grabs the received data and the socket from the shared queue and in line 50/51 adds the thread-ID, the number of messages handled by that thread and sends it as a reply to the sender using the received socket.
  
What to expect as output:
* Upon entering e.g. text "!1234" and pressing return
On Ruby 1.9.3-p392 on Linux:
* See the as response the thread ID, the number of messages within the thread and the text.

On Ruby 2.0.0-p0 on Linux:
* See same as with Ruby 1.9.3-p392 , but when pressing very fast return after entering no text,
the message of thread-id and number of messages sent will be repeatedly received by the server. 
* As the number of messages is not increased with each sending, it will be repeatedly sent by the ruby kernel (c-code)

On Ruby 2.0.0-p0 on Windows: 
* Nothing is is sent back to the the telnet server, despite the fact that the message had been received at the servers of the thread pool.

* Everything works file, if instead of blocking send (line 50/51) the non-blocking send (line 52/53) is used. However correct implementation of the halfsync-halfasync pattern, requires reasonably the usage of blocking "send" in thread pool. 
  
I have to apologize that the program to reproduce the error is slightly large and complicated, but I believe that there is value, when ruby is able to run  well known design patterns correctly.  

Note:
The code does not run with ruby 1.8.7 and Jruby and Rubinius.
=end



-- 
http://bugs.ruby-lang.org/