module EventMachine
module Synchrony
class TCPSocket < Connection
class << self
alias_method :_old_new, :new
def new(*args)
if args.size == 1
_old_new(*args)
else
# In TCPSocket, new against an unknown hostname raises SocketError with
# a message "getaddrinfo: nodename nor servname provided, or not known".
# In EM, connect against an unknown hostname raises EM::ConnectionError
# with a message of "unable to resolve server address"
begin
socket = EventMachine::connect(*args[0..1], self)
rescue EventMachine::ConnectionError => e
raise SocketError, e.message
end
# In TCPSocket, new against a closed port raises Errno::ECONNREFUSED.
# In EM, connect against a closed port result in a call to unbind with
# a reason param of Errno::ECONNREFUSED as a class, not an instance.
unless socket.sync(:in) # wait for connection
raise socket.unbind_reason.new if socket.unbind_reason.is_a? Class
raise SocketError
end
socket
end
end
alias :open :new
end
def post_init
@in_buff, @out_buff = '', ''
@in_req = @out_req = @unbind_reason = @read_type = nil
@opening = true
@closed = @remote_closed = false
end
def closed?
# In TCPSocket,
# closed? on a remotely closed socket, when we've not yet read EOF, returns false
# closed? on a remotely closed socket, when we've read EOF, returns false
# closed? on a socket after #close, returns true
# Therefore, we set @close to true when #close is called, but not when unbind is.
@closed
end
# direction must be one of :in or :out
def sync(direction)
req = self.instance_variable_set "@#{direction.to_s}_req", EventMachine::DefaultDeferrable.new
EventMachine::Synchrony.sync req
ensure
self.instance_variable_set "@#{direction.to_s}_req", nil
end
# TCPSocket interface
def setsockopt(level, name, value); end
def send(msg, flags)
raise "Unknown flags in send(): #{flags}" if flags.nonzero?
# write(X) on a socket after #close, raises IOError with message "closed stream"
# send(X,0) on a socket after #close, raises IOError with message "closed stream"
raise IOError, "closed stream" if @closed
# the first write(X) on a remotely closed socket, <= than some buffer size, generates no error
# the first write(X) on a remotely closed socket, > than some buffer size, generates no error
# (on my box this buffer appears to be 80KB)
# further write(X) on a remotely closed socket, raises Errno::EPIPE
# the first send(X,0) on a remotely closed socket, <= than some buffer size, generates no error
# the first send(X,0) on a remotely closed socket, > than some buffer size, generates no error
# (on my box this buffer appears to be 80KB)
# further send(X,0) on a remotely closed socket, raises Errno::EPIPE
raise Errno::EPIPE if @remote_closed
len = msg.bytesize
# write(X) on an open socket, where the remote end closes during the write, raises Errno::EPIPE
# send(X,0) on an open socket, where the remote end closes during the write, raises Errno::EPIPE
write_data(msg) or sync(:out) or raise(Errno::EPIPE)
len
end
def write(msg)
send(msg,0)
end
def read(num_bytes = nil, dest = nil)
handle_read(:read, num_bytes, dest)
end
def read_nonblock(maxlen, dest = nil)
raise ArgumentError, "maxlen must be > 0" if !maxlen || maxlen <= 0
read_bytes = handle_read(:read_nonblock, maxlen, dest)
raise EOFError if read_bytes.nil?
read_bytes
end
def recv(num_bytes, flags = 0)
raise "Unknown flags in recv(): #{flags}" if flags.nonzero?
handle_read(:recv, num_bytes)
end
def close
# close on a closed socket raises IOError with a message of "closed stream"
raise IOError, "closed stream" if @closed
@closed = true
close_connection true
@in_req = @out_req = nil
# close on an open socket returns nil
nil
end
# EventMachine interface
def connection_completed
@opening = false
@in_req.succeed self
end
attr_reader :unbind_reason
# Can't set a default value for reason (e.g. reason=nil), as in that case
# EM fails to pass in the reason argument and you'll always get the default
# value.
def unbind(reason)
@unbind_reason = reason
@remote_closed = true unless @closed
if @opening
@in_req.fail nil if @in_req
else
@in_req.succeed read_data if @in_req
end
@out_req.fail nil if @out_req
@in_req = @out_req = nil
end
def receive_data(data)
@in_buff << data
if @in_req && (data = read_data)
@in_req.succeed data unless data == :block
end
end
protected
def handle_read(type, num_bytes, dest=nil)
# read(-n) always raises ArgumentError
# recv(-n) always raises ArgumentError
raise ArgumentError, "negative length #{num_bytes} given" if num_bytes != nil and num_bytes < 0
# read(n) on a socket after #close, raises IOError with message "closed stream"
# read(0) on a socket after #close, raises IOError with message "closed stream"
# read() on a socket after #close, raises IOError with message "closed stream"
# recv(n) on a socket after #close, raises IOError with message "closed stream"
# recv(0) on a socket after #close, raises IOError with message "closed stream"
raise IOError, "closed stream" if @closed
# read(0) on an open socket, return ""
# read(0) on a remotely closed socket, with buffered data, returns ""
# read(0) on a remotely closed socket, with no buffered data, returns ""
# recv(0) on an open socket, return ""
# recv(0) on a remotely closed socket, with buffered data, returns ""
# recv(0) on a remotely closed socket, with no buffered data, returns ""
return "" if num_bytes == 0
@read_type = type
@read_bytes = num_bytes
@read_dest = dest if dest
(data = read_data) != :block ? data : sync(:in)
end
def try_read_data
if @read_type == :read || @read_type == :read_nonblock
nonblocking = @read_type == :read_nonblock
unless @remote_closed
if @read_bytes
# read(n) on an open socket, with >= than n buffered data, returns n data
if (@in_buff.size >= @read_bytes ||
(nonblocking && @in_buff.size > 0)) then
@in_buff.slice!(0, @read_bytes)
# read(n) on an open socket, with < than n buffered data, blocks
else :block end
else
# read() on an open socket, blocks until a remote close and returns all the data sent
:block
end
else
if @read_bytes
# read(n) on a remotely closed socket, with no buffered data, returns nil
if @in_buff.empty? then nil
# read(n) on a remotely closed socket, with buffered data, returns the buffered data up to n
else @in_buff.slice!(0, @read_bytes) end
else
# read() on a remotely closed socket, with no buffered data, returns ""
if @in_buff.empty? then ""
# read() on a remotely closed socket, with buffered data, returns the buffered data
else @in_buff.slice!(0, @in_buff.size) end
end
end
else #recv
unless @remote_closed
# recv(n) on an open socket, with no buffered data, blocks
if @in_buff.empty? then :block
# recv(n) on an open socket, with < than n buffered data, return the buffered data
# recv(n) on an open socket, with >= than n buffered data, returns n data
else @in_buff.slice!(0, @read_bytes) end
else
# recv(n) on a remotely closed socket, with no buffered data, returns ""
if @in_buff.empty? then ""
# recv(n) on a remotely closed socket, with < than n buffered data, return the buffered data
# recv(n) on a remotely closed socket, with >= than n buffered data, returns n data
else @in_buff.slice!(0, @read_bytes) end
end
end
end
def read_data
data = try_read_data
unless data == :block
@read_bytes = 0
# read(n,buffer) returns the buffer when it does not return nil or raise an exception
data = @read_dest.replace(data) if @read_dest and not data.nil?
@read_dest = nil
end
data
end
def write_data(data = nil)
@out_buff += data if data
loop do
if @out_buff.empty?
@out_req.succeed true if @out_req
return true
end
if self.get_outbound_data_size > EventMachine::FileStreamer::BackpressureLevel
# write(X) on an open socket, where the remote end is not reading, > than some buffer size, blocks
# send(X,0) on an open socket, where the remote end is not reading, > than some buffer size, blocks
# where that buffer size is EventMachine::FileStreamer::BackpressureLevel, returning false will
# cause write/send to block
EventMachine::next_tick { write_data }
return false
else
# write(X) on an open socket, where the remote end is not reading, <= than some buffer size, sends and returns
# send(X,0) on an open socket, where the remote end is not reading, <= than some buffer size, sends returns
len = [@out_buff.bytesize, EventMachine::FileStreamer::ChunkSize].min
self.send_data @out_buff.slice!( 0, len )
end
end
end
end
end
end