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
Attributes inherited from Q::Promise
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(reactor, acceptor = nil, progress: 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, wait: false) ⇒ Object
Methods included from Stream
#close_write, #flush, included, #listen, #progress, #read, #readable?, #start_read, #stop_read, #try_write, #writable?
Methods inherited from Handle
#active?, #closed?, #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
#catch, #finally, #progress, #ruby_catch, #value
Constructor Details
#initialize(reactor, acceptor = nil, progress: nil) ⇒ TCP
Returns a new instance of TCP.
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
# File 'lib/libuv/tcp.rb', line 25 def initialize(reactor, acceptor = nil, progress: nil) @reactor = reactor @progress = progress tcp_ptr = ::Libuv::Ext.allocate_handle_tcp error = check_result(::Libuv::Ext.tcp_init(reactor.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.
18 19 20 |
# File 'lib/libuv/tcp.rb', line 18 def connected @connected end |
#protocol ⇒ Object (readonly)
Returns the value of attribute protocol.
19 20 21 |
# File 'lib/libuv/tcp.rb', line 19 def protocol @protocol end |
Instance Method Details
#bind(ip, port, callback = nil, &blk) ⇒ Object
END TLS Abstraction ——————
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 |
# File 'lib/libuv/tcp.rb', line 196 def bind(ip, port, callback = nil, &blk) return self 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 self end |
#close ⇒ Object
overwrite the default close to ensure pending writes are rejected
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 |
# File 'lib/libuv/tcp.rb', line 131 def close return self if @closed # Free tls memory # Next tick as may recieve data after closing if @tls @reactor.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
106 107 108 109 110 111 112 113 114 |
# File 'lib/libuv/tcp.rb', line 106 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
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 |
# File 'lib/libuv/tcp.rb', line 232 def connect(ip, port, callback = nil, &blk) return self 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 if @callback.nil? @coroutine = @reactor.defer co @coroutine.promise end self end |
#direct_write ⇒ Object
159 |
# File 'lib/libuv/tcp.rb', line 159 alias_method :direct_write, :write |
#disable_keepalive ⇒ Object
286 287 288 289 290 |
# File 'lib/libuv/tcp.rb', line 286 def disable_keepalive return self if @closed check_result ::Libuv::Ext.tcp_keepalive(handle, 0, 0) self end |
#disable_nodelay ⇒ Object
274 275 276 277 278 |
# File 'lib/libuv/tcp.rb', line 274 def disable_nodelay return self if @closed check_result ::Libuv::Ext.tcp_nodelay(handle, 0) self end |
#disable_simultaneous_accepts ⇒ Object
298 299 300 301 302 |
# File 'lib/libuv/tcp.rb', line 298 def disable_simultaneous_accepts return self if @closed check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 0) self end |
#dispatch_cb(data) ⇒ Object
This is clear text data that has been decrypted Same as stream.rb on_read for clear text
86 87 88 89 90 91 92 |
# File 'lib/libuv/tcp.rb', line 86 def dispatch_cb(data) begin @progress.call data, self rescue Exception => e @reactor.log e, 'performing TLS read data callback' end end |
#do_shutdown ⇒ Object
182 |
# File 'lib/libuv/tcp.rb', line 182 alias_method :do_shutdown, :shutdown |
#enable_keepalive(delay) ⇒ Object
280 281 282 283 284 |
# File 'lib/libuv/tcp.rb', line 280 def enable_keepalive(delay) return self if @closed # The to_i asserts integer check_result ::Libuv::Ext.tcp_keepalive(handle, 1, delay.to_i) self end |
#enable_nodelay ⇒ Object
268 269 270 271 272 |
# File 'lib/libuv/tcp.rb', line 268 def enable_nodelay return self if @closed check_result ::Libuv::Ext.tcp_nodelay(handle, 1) self end |
#enable_simultaneous_accepts ⇒ Object
292 293 294 295 296 |
# File 'lib/libuv/tcp.rb', line 292 def enable_simultaneous_accepts return self if @closed check_result ::Libuv::Ext.tcp_simultaneous_accepts(handle, 1) self end |
#handshake_cb(protocol = nil) ⇒ Object
Push through any pending writes when handshake has completed
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
# File 'lib/libuv/tcp.rb', line 60 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 @reactor.log e, 'performing TLS handshake callback' end end |
#on_handshake(callback = nil, &blk) ⇒ Object
Provide a callback once the TLS handshake has completed
79 80 81 82 |
# File 'lib/libuv/tcp.rb', line 79 def on_handshake(callback = nil, &blk) @on_handshake = callback || blk self end |
#open(fd, binding = true, callback = nil, &blk) ⇒ Object
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 |
# File 'lib/libuv/tcp.rb', line 215 def open(fd, binding = true, callback = nil, &blk) return self if @closed if binding @on_listen = method(:accept) @on_accept = callback || blk else @callback = callback || blk @coroutine = @reactor.defer if @callback.nil? end error = check_result UV.tcp_open(handle, fd) reject(error) if error co @coroutine.promise if @coroutine self end |
#peername ⇒ Object
261 262 263 264 265 266 |
# File 'lib/libuv/tcp.rb', line 261 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
183 184 185 186 187 188 189 190 |
# File 'lib/libuv/tcp.rb', line 183 def shutdown if @pending_writes && @pending_writes.length > 0 @pending_writes[-1][0].finally method(:do_shutdown) else do_shutdown end self end |
#sockname ⇒ Object
254 255 256 257 258 259 |
# File 'lib/libuv/tcp.rb', line 254 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 ———————-
47 48 49 50 51 52 53 54 55 56 57 |
# File 'lib/libuv/tcp.rb', line 47 def start_tls(args = {}) return self 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 self end |
#tls? ⇒ Boolean
Check if tls active on the socket
22 |
# File 'lib/libuv/tcp.rb', line 22 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)
96 97 98 99 100 101 102 103 |
# File 'lib/libuv/tcp.rb', line 96 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
116 117 118 119 120 121 122 123 124 125 126 127 |
# File 'lib/libuv/tcp.rb', line 116 def verify_cb(cert) if @on_verify begin return @on_verify.call cert rescue => e @reactor.log e, 'performing TLS verify callback' return false end end true end |
#verify_peer(callback = nil, &blk) ⇒ Object
Verify peers will be called for each cert in the chain
154 155 156 157 |
# File 'lib/libuv/tcp.rb', line 154 def verify_peer(callback = nil, &blk) @on_verify = callback || blk self end |
#write(data, wait: false) ⇒ Object
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 |
# File 'lib/libuv/tcp.rb', line 160 def write(data, wait: false) if @tls deferred = @reactor.defer if @handshake @pending_write = deferred @tls.encrypt(data) else @pending_writes << [deferred, data] end if wait return deferred.promise if wait == :promise co deferred.promise end self else direct_write(data, wait: wait) end end |