Use sync socket write to ensure that full message is written

[danhermann]

This replaces the select call on the socket with a simple sync write since the async write call was not properly verifying that the entire payload was written to the socket and there wasn't really a performance benefit with the existing async write. The failure to verify that the entire payload was written to the socket is the suspected cause of truncated messages in situations where unusually long messages were sent via TCP.

May relate to #30 and #33.

[yaauie]

I don't think that this directly solves the truncation issues, but have suggested an improvement that should.

See in-line comments.

[yaauie]

I believe the cause of truncated messages is likely caused by our failure to check the return value of IO#syswrite; if a payload is partially written at this level, we make no attempt to continue writing from where we left off.

We can fix that by performing a byteslice and repeating the IO#syswrite call with the remainder until the remaining payload is empty:

Suggested change

	client_socket.syswrite(payload)
	while payload && payload.bytesize > 0
	written = client_socket.syswrite(payload)
	payload = payload.byteslice(written..-1)
	end

---

Separately, the code that this removes gives us an opportunity to have an EOFError be raised before we send data if the remote end closes the socket on us, while the replacement will raise a SystemCallError when IO#syswrite is sent to a closed socket. I have not thought through all of the ramifications of changing the error being raised.

I think there is definitely a bug in the implementation, in which a socket that is readable (e.g., the remote end has sent bytes that are not EOF) and not writable (e.g., has a zero window) would cause the payload to be dropped instead of written.

I believe this secondary issue can be solved by retrying the IO::select until we have a writable client_socket:

            begin
              r,w,_ = IO.select([client_socket],[client_socket])
              # don't expect any reads, but a readable socket might	
              # mean the remote end closed, so read it and throw it away.	
              # we'll get an EOFError if it happens.
              r.each { |readable| readable.sysread(16384) }
              retry unless w.any?
            end

There may be dragons here, if the socket never becomes writable or readable with an EOF, but these dragons also exist in the current implementation and are not a new addition.

[roaksoax]

This PR was superseded by #49, as such, I'm closing this PR.