Class: Libuv::TCP
- Inherits:
-
Handle
- Object
- Q::Promise
- Q::DeferredPromise
- Handle
- Libuv::TCP
- Defined in:
- lib/libuv/tcp.rb
Defined Under Namespace
Classes: Socket4, Socket6, SocketBase
Constant Summary collapse
- TLS_ERROR =
"TLS write failed".freeze
Constants included from Stream
Stream::BACKLOG_ERROR, Stream::CLOSED_HANDLE_ERROR, Stream::STREAM_CLOSED_ERROR, Stream::WRITE_ERROR
Constants included from Net
Net::INET6_ADDRSTRLEN, Net::INET_ADDRSTRLEN, Net::IP_ARGUMENT_ERROR, Net::PORT_ARGUMENT_ERROR
Constants included from Assertions
Constants inherited from Q::Promise
Instance Attribute Summary collapse
-
#connected ⇒ Object
readonly
Returns the value of attribute connected.
-
#protocol ⇒ Object
readonly
Returns the value of attribute protocol.
Attributes inherited from Handle
Instance Method Summary collapse
-
#bind(ip, port, callback = nil, &blk) ⇒ Object
END TLS Abstraction —————— ————————————–.
-
#close ⇒ Object
overwrite the default close to ensure pending writes are rejected.
-
#close_cb ⇒ Object
Close can be called multiple times.
- #connect(ip, port, callback = nil, &blk) ⇒ Object
- #direct_write ⇒ Object
- #disable_keepalive ⇒ Object
- #disable_nodelay ⇒ Object
- #disable_simultaneous_accepts ⇒ Object
-
#dispatch_cb(data) ⇒ Object
This is clear text data that has been decrypted Same as stream.rb on_read for clear text.
- #do_shutdown ⇒ Object
- #enable_keepalive(delay) ⇒ Object
- #enable_nodelay ⇒ Object
- #enable_simultaneous_accepts ⇒ Object
-
#handshake_cb(protocol = nil) ⇒ Object
Push through any pending writes when handshake has completed.
-
#initialize(loop, acceptor = nil) ⇒ TCP
constructor
A new instance of TCP.
-
#on_handshake(callback = nil, &blk) ⇒ Object
Provide a callback once the TLS handshake has completed.
- #open(fd, binding = true, callback = nil, &blk) ⇒ Object
- #peername ⇒ Object
- #shutdown ⇒ Object
- #sockname ⇒ Object
-
#start_tls(args = {}) ⇒ Object
TLS Abstraction ———————- ————————————–.
-
#tls? ⇒ Boolean
Check if tls active on the socket.
-
#transmit_cb(data) ⇒ Object
We resolve the existing tls write promise with a the real writes promise (a close may have occurred).
- #verify_cb(cert) ⇒ Object
-
#verify_peer(callback = nil, &blk) ⇒ Object
Verify peers will be called for each cert in the chain.
- #write(data) ⇒ Object
Methods included from Stream
included, #listen, #progress, #readable?, #start_read, #stop_read, #try_write, #writable?
Methods inherited from Handle
#active?, #closing?, #ref, #unref
Methods included from Assertions
#assert_block, #assert_boolean, #assert_type
Methods included from Resource
#check_result, #check_result!, #resolve, #to_ptr
Methods inherited from Q::DeferredPromise
Methods inherited from Q::Promise
Constructor Details
#initialize(loop, acceptor = nil) ⇒ TCP
Returns a new instance of TCP.
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
# File 'lib/libuv/tcp.rb', line 23 def initialize(loop, acceptor = nil) @loop = loop tcp_ptr = ::Libuv::Ext.allocate_handle_tcp error = check_result(::Libuv::Ext.tcp_init(loop.handle, tcp_ptr)) if acceptor && error.nil? error = check_result(::Libuv::Ext.accept(acceptor, tcp_ptr)) @connected = true else @connected = false end super(tcp_ptr, error) end |
Instance Attribute Details
#connected ⇒ Object (readonly)
Returns the value of attribute connected.
16 17 18 |
# File 'lib/libuv/tcp.rb', line 16 def connected @connected end |
#protocol ⇒ Object (readonly)
Returns the value of attribute protocol.
17 18 19 |
# File 'lib/libuv/tcp.rb', line 17 def protocol @protocol end |
Instance Method Details
#bind(ip, port, callback = nil, &blk) ⇒ Object
END TLS Abstraction ——————
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 |
# File 'lib/libuv/tcp.rb', line 184 def bind(ip, port, callback = nil, &blk) return if @closed @on_accept = callback || blk @on_listen = method(:accept) assert_type(String, ip, IP_ARGUMENT_ERROR) assert_type(Integer, port, PORT_ARGUMENT_ERROR) begin @tcp_socket = create_socket(IPAddr.new(ip), port) @tcp_socket.bind rescue Exception => e reject(e) end end |
#close ⇒ Object
overwrite the default close to ensure pending writes are rejected
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
# File 'lib/libuv/tcp.rb', line 126 def close return if @closed # Free tls memory # Next tick as may recieve data after closing if @tls @loop.next_tick do @tls.cleanup end end @connected = false if @pending_writes @pending_writes.each do |deferred, data| deferred.reject(TLS_ERROR) end @pending_writes = nil end super end |
#close_cb ⇒ Object
Close can be called multiple times
101 102 103 104 105 106 107 108 109 |
# File 'lib/libuv/tcp.rb', line 101 def close_cb if @pending_write @pending_write.reject(TLS_ERROR) @pending_write = nil end # Shutdown the stream close end |
#connect(ip, port, callback = nil, &blk) ⇒ Object
212 213 214 215 216 217 218 219 220 221 222 223 224 |
# File 'lib/libuv/tcp.rb', line 212 def connect(ip, port, callback = nil, &blk) return if @closed @callback = callback || blk assert_type(String, ip, IP_ARGUMENT_ERROR) assert_type(Integer, port, PORT_ARGUMENT_ERROR) begin @tcp_socket = create_socket(IPAddr.new(ip), port) @tcp_socket.connect(callback(:on_connect, @tcp_socket.connect_req.address)) rescue Exception => e reject(e) end end |
#direct_write ⇒ Object
153 |
# File 'lib/libuv/tcp.rb', line 153 alias_method :direct_write, :write |
#disable_keepalive ⇒ Object
255 256 257 258 |
# File 'lib/libuv/tcp.rb', line 255 def disable_keepalive return if @closed check_result ::Libuv::Ext.tcp_keepalive(handle, 0, 0) end |
#disable_nodelay ⇒ Object
245 246 247 248 |
# File 'lib/libuv/tcp.rb', line 245 def disable_nodelay return if @closed check_result ::Libuv::Ext.tcp_nodelay(handle, 0) end |
#disable_simultaneous_accepts ⇒ Object
265 266 267 268 |
# File 'lib/libuv/tcp.rb', line 265 def disable_simultaneous_accepts return if @closed check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 0) end |
#dispatch_cb(data) ⇒ Object
This is clear text data that has been decrypted Same as stream.rb on_read for clear text
81 82 83 84 85 86 87 |
# File 'lib/libuv/tcp.rb', line 81 def dispatch_cb(data) begin @progress.call data, self rescue Exception => e @loop.log :error, :stream_progress_cb, e end end |
#do_shutdown ⇒ Object
171 |
# File 'lib/libuv/tcp.rb', line 171 alias_method :do_shutdown, :shutdown |
#enable_keepalive(delay) ⇒ Object
250 251 252 253 |
# File 'lib/libuv/tcp.rb', line 250 def enable_keepalive(delay) return if @closed # The to_i asserts integer check_result ::Libuv::Ext.tcp_keepalive(handle, 1, delay.to_i) end |
#enable_nodelay ⇒ Object
240 241 242 243 |
# File 'lib/libuv/tcp.rb', line 240 def enable_nodelay return if @closed check_result ::Libuv::Ext.tcp_nodelay(handle, 1) end |
#enable_simultaneous_accepts ⇒ Object
260 261 262 263 |
# File 'lib/libuv/tcp.rb', line 260 def enable_simultaneous_accepts return if @closed check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 1) end |
#handshake_cb(protocol = nil) ⇒ Object
Push through any pending writes when handshake has completed
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
# File 'lib/libuv/tcp.rb', line 56 def handshake_cb(protocol = nil) @handshake = true @protocol = protocol writes = @pending_writes @pending_writes = nil writes.each do |deferred, data| @pending_write = deferred @tls.encrypt(data) end begin @on_handshake.call(self, protocol) if @on_handshake rescue => e @loop.log :warn, :tls_handshake_callback_error, e end end |
#on_handshake(callback = nil, &blk) ⇒ Object
Provide a callback once the TLS handshake has completed
75 76 77 |
# File 'lib/libuv/tcp.rb', line 75 def on_handshake(callback = nil, &blk) @on_handshake = callback || blk end |
#open(fd, binding = true, callback = nil, &blk) ⇒ Object
200 201 202 203 204 205 206 207 208 209 210 |
# File 'lib/libuv/tcp.rb', line 200 def open(fd, binding = true, callback = nil, &blk) return if @closed if binding @on_listen = method(:accept) @on_accept = callback || blk else @callback = callback || blk end error = check_result UV.tcp_open(handle, fd) reject(error) if error end |
#peername ⇒ Object
233 234 235 236 237 238 |
# File 'lib/libuv/tcp.rb', line 233 def peername return [] if @closed sockaddr, len = get_sockaddr_and_len check_result! ::Libuv::Ext.tcp_getpeername(handle, sockaddr, len) get_ip_and_port(::Libuv::Ext::Sockaddr.new(sockaddr), len.get_int(0)) end |
#shutdown ⇒ Object
172 173 174 175 176 177 178 |
# File 'lib/libuv/tcp.rb', line 172 def shutdown if @pending_writes && @pending_writes.length > 0 @pending_writes[-1][0].finally method(:do_shutdown) else do_shutdown end end |
#sockname ⇒ Object
226 227 228 229 230 231 |
# File 'lib/libuv/tcp.rb', line 226 def sockname return [] if @closed sockaddr, len = get_sockaddr_and_len check_result! ::Libuv::Ext.tcp_getsockname(handle, sockaddr, len) get_ip_and_port(::Libuv::Ext::Sockaddr.new(sockaddr), len.get_int(0)) end |
#start_tls(args = {}) ⇒ Object
TLS Abstraction ———————-
44 45 46 47 48 49 50 51 52 53 |
# File 'lib/libuv/tcp.rb', line 44 def start_tls(args = {}) return unless @connected && @tls.nil? args[:verify_peer] = true if @on_verify @handshake = false @pending_writes = [] @tls = ::RubyTls::SSL::Box.new(args[:server], self, args) @tls.start end |
#tls? ⇒ Boolean
Check if tls active on the socket
20 |
# File 'lib/libuv/tcp.rb', line 20 def tls?; !@tls.nil?; end |
#transmit_cb(data) ⇒ Object
We resolve the existing tls write promise with a the
real writes promise (a close may have occurred)
91 92 93 94 95 96 97 98 |
# File 'lib/libuv/tcp.rb', line 91 def transmit_cb(data) if @pending_write @pending_write.resolve(direct_write(data)) @pending_write = nil else direct_write(data) end end |
#verify_cb(cert) ⇒ Object
111 112 113 114 115 116 117 118 119 120 121 122 |
# File 'lib/libuv/tcp.rb', line 111 def verify_cb(cert) if @on_verify begin return @on_verify.call cert rescue => e @loop.log :warn, :tls_verify_callback_failed, e return false end end true end |
#verify_peer(callback = nil, &blk) ⇒ Object
Verify peers will be called for each cert in the chain
149 150 151 |
# File 'lib/libuv/tcp.rb', line 149 def verify_peer(callback = nil, &blk) @on_verify = callback || blk end |
#write(data) ⇒ Object
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 |
# File 'lib/libuv/tcp.rb', line 154 def write(data) if @tls deferred = @loop.defer if @handshake @pending_write = deferred @tls.encrypt(data) else @pending_writes << [deferred, data] end deferred.promise else direct_write(data) end end |