public class NetSocket extends Object implements ReadStream<Buffer>, WriteStream<Buffer>
Instances of this class are created on the client side by an NetClient
when a connection to a server is made, or on the server side by a NetServer
when a server accepts a connection.
It implements both and so it can be used with
Pump
to pump data with flow control.
original
non RX-ified interface using Vert.x codegen.Modifier and Type | Field and Description |
---|---|
static io.vertx.lang.rx.TypeArg<NetSocket> |
__TYPE_ARG |
Constructor and Description |
---|
NetSocket(NetSocket delegate) |
NetSocket(Object delegate) |
Modifier and Type | Method and Description |
---|---|
void |
close()
Close the NetSocket
|
void |
close(Handler<AsyncResult<Void>> handler)
Close the NetSocket and notify the
handler when the operation completes. |
NetSocket |
closeHandler(Handler<Void> handler)
Set a handler that will be called when the NetSocket is closed
|
Observable<Void> |
closeObservable()
Deprecated.
use
rxClose() instead |
NetSocket |
drainHandler(Handler<Void> handler)
Set a drain handler on the stream.
|
void |
end()
Calls
close() |
void |
end(Buffer data)
Same as
end(io.vertx.rxjava.core.buffer.Buffer) but writes some data to the stream before ending. |
void |
end(Buffer data,
Handler<AsyncResult<Void>> handler)
Same as but with an
handler called when the operation completes |
void |
end(Handler<AsyncResult<Void>> handler)
|
NetSocket |
endHandler(Handler<Void> endHandler)
This handler might be called after the close handler when the socket is paused and there are still
buffers to deliver.
|
Observable<Void> |
endObservable()
Deprecated.
use
rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead |
Observable<Void> |
endObservable(Buffer data)
Deprecated.
use
rxEnd(io.vertx.rxjava.core.buffer.Buffer) instead |
boolean |
equals(Object o) |
NetSocket |
exceptionHandler(Handler<Throwable> handler)
Set an exception handler on the read stream.
|
NetSocket |
fetch(long amount)
Fetch the specified
amount of elements. |
NetSocket |
getDelegate() |
NetSocket |
handler(Handler<Buffer> handler)
Set a data handler.
|
int |
hashCode() |
String |
indicatedServerName()
Returns the SNI server name presented during the SSL handshake by the client.
|
boolean |
isSsl() |
SocketAddress |
localAddress() |
static NetSocket |
newInstance(NetSocket arg) |
NetSocket |
pause()
Pause the
ReadStream , it sets the buffer in fetch mode and clears the actual demand. |
Pipe<Buffer> |
pipe()
Pause this stream and return a to transfer the elements of this stream to a destination .
|
void |
pipeTo(WriteStream<Buffer> dst)
Like
ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>) but with no completion handler. |
void |
pipeTo(WriteStream<Buffer> dst,
Handler<AsyncResult<Void>> handler)
Pipe this
ReadStream to the WriteStream . |
Observable<Void> |
pipeToObservable(WriteStream<Buffer> dst)
Deprecated.
|
SocketAddress |
remoteAddress() |
NetSocket |
resume()
Resume reading, and sets the buffer in
flowing mode. |
Single<Void> |
rxClose()
Close the NetSocket and notify the
handler when the operation completes. |
Single<Void> |
rxEnd()
|
Single<Void> |
rxEnd(Buffer data)
Same as but with an
handler called when the operation completes |
Single<Void> |
rxPipeTo(WriteStream<Buffer> dst)
Pipe this
ReadStream to the WriteStream . |
Single<Void> |
rxSendFile(String filename)
Same as
sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
Single<Void> |
rxSendFile(String filename,
long offset)
Same as
sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
Single<Void> |
rxSendFile(String filename,
long offset,
long length)
Same as
sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
Single<Void> |
rxWrite(Buffer message)
Like but with an
handler called when the message has been written
or failed to be written. |
Single<Void> |
rxWrite(String str)
Same as
write(io.vertx.rxjava.core.buffer.Buffer) but with an handler called when the operation completes |
Single<Void> |
rxWrite(String str,
String enc)
Same as
write(io.vertx.rxjava.core.buffer.Buffer) but with an handler called when the operation completes |
NetSocket |
sendFile(String filename)
Tell the operating system to stream a file as specified by
filename directly from disk to the outgoing connection,
bypassing userspace altogether (where supported by the underlying operating system. |
NetSocket |
sendFile(String filename,
Handler<AsyncResult<Void>> resultHandler)
Same as
sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
sendFile(String filename,
long offset)
Tell the operating system to stream a file as specified by
filename directly from disk to the outgoing connection,
bypassing userspace altogether (where supported by the underlying operating system. |
NetSocket |
sendFile(String filename,
long offset,
Handler<AsyncResult<Void>> resultHandler)
Same as
sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
NetSocket |
sendFile(String filename,
long offset,
long length)
Tell the operating system to stream a file as specified by
filename directly from disk to the outgoing connection,
bypassing userspace altogether (where supported by the underlying operating system. |
NetSocket |
sendFile(String filename,
long offset,
long length,
Handler<AsyncResult<Void>> resultHandler)
Same as
sendFile(java.lang.String) but also takes a handler that will be called when the send has completed or
a failure has occurred |
Observable<Void> |
sendFileObservable(String filename)
Deprecated.
use
rxSendFile(java.lang.String) instead |
Observable<Void> |
sendFileObservable(String filename,
long offset)
Deprecated.
use
rxSendFile(java.lang.String) instead |
Observable<Void> |
sendFileObservable(String filename,
long offset,
long length)
Deprecated.
use
rxSendFile(java.lang.String) instead |
NetSocket |
setWriteQueueMaxSize(int maxSize)
Set the maximum size of the write queue to
maxSize . |
SSLSession |
sslSession() |
Observable<Buffer> |
toObservable() |
String |
toString() |
io.vertx.rx.java.WriteStreamSubscriber<Buffer> |
toSubscriber() |
NetSocket |
upgradeToSsl(Handler<Void> handler)
Upgrade channel to use SSL/TLS.
|
NetSocket |
upgradeToSsl(String serverName,
Handler<Void> handler)
Upgrade channel to use SSL/TLS.
|
NetSocket |
write(Buffer data)
Write some data to the stream.
|
NetSocket |
write(Buffer message,
Handler<AsyncResult<Void>> handler)
Like but with an
handler called when the message has been written
or failed to be written. |
NetSocket |
write(String str)
Write a
String to the connection, encoded in UTF-8. |
NetSocket |
write(String str,
Handler<AsyncResult<Void>> handler)
Same as
write(io.vertx.rxjava.core.buffer.Buffer) but with an handler called when the operation completes |
NetSocket |
write(String str,
String enc)
Write a
String to the connection, encoded using the encoding enc . |
NetSocket |
write(String str,
String enc,
Handler<AsyncResult<Void>> handler)
Same as
write(io.vertx.rxjava.core.buffer.Buffer) but with an handler called when the operation completes |
String |
writeHandlerID()
When a
NetSocket is created it automatically registers an event handler with the event bus, the ID of that
handler is given by writeHandlerID . |
Observable<Void> |
writeObservable(Buffer message)
Deprecated.
use
rxWrite(java.lang.String) instead |
Observable<Void> |
writeObservable(String str)
Deprecated.
use
rxWrite(java.lang.String) instead |
Observable<Void> |
writeObservable(String str,
String enc)
Deprecated.
use
rxWrite(java.lang.String) instead |
boolean |
writeQueueFull()
This will return
true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int) |
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
newInstance, newInstance
newInstance, newInstance
newInstance
public static final io.vertx.lang.rx.TypeArg<NetSocket> __TYPE_ARG
public NetSocket(NetSocket delegate)
public NetSocket(Object delegate)
public NetSocket getDelegate()
getDelegate
in interface ReadStream<Buffer>
getDelegate
in interface StreamBase
getDelegate
in interface WriteStream<Buffer>
public Observable<Buffer> toObservable()
toObservable
in interface ReadStream<Buffer>
public io.vertx.rx.java.WriteStreamSubscriber<Buffer> toSubscriber()
public void end(Buffer data)
end(io.vertx.rxjava.core.buffer.Buffer)
but writes some data to the stream before ending.end
in interface WriteStream<Buffer>
data
- the data to writepublic void end(Buffer data, Handler<AsyncResult<Void>> handler)
handler
called when the operation completesend
in interface WriteStream<Buffer>
data
- handler
- @Deprecated public Observable<Void> endObservable(Buffer data)
rxEnd(io.vertx.rxjava.core.buffer.Buffer)
insteadhandler
called when the operation completesdata
- public Single<Void> rxEnd(Buffer data)
handler
called when the operation completesdata
- public boolean writeQueueFull()
true
if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int)
writeQueueFull
in interface WriteStream<Buffer>
public Pipe<Buffer> pipe()
WriteStream
.pipe
in interface ReadStream<Buffer>
public void pipeTo(WriteStream<Buffer> dst)
ReadStream.pipeTo(io.vertx.rxjava.core.streams.WriteStream<T>)
but with no completion handler.pipeTo
in interface ReadStream<Buffer>
dst
- public void pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler)
ReadStream
to the WriteStream
.
Elements emitted by this stream will be written to the write stream until this stream ends or fails.
Once this stream has ended or failed, the write stream will be ended and the handler
will be
called with the result.
pipeTo
in interface ReadStream<Buffer>
dst
- the destination write streamhandler
- @Deprecated public Observable<Void> pipeToObservable(WriteStream<Buffer> dst)
rxPipeTo(io.vertx.rxjava.core.streams.WriteStream<io.vertx.rxjava.core.buffer.Buffer>)
insteadReadStream
to the WriteStream
.
Elements emitted by this stream will be written to the write stream until this stream ends or fails.
Once this stream has ended or failed, the write stream will be ended and the handler
will be
called with the result.
dst
- the destination write streampublic Single<Void> rxPipeTo(WriteStream<Buffer> dst)
ReadStream
to the WriteStream
.
Elements emitted by this stream will be written to the write stream until this stream ends or fails.
Once this stream has ended or failed, the write stream will be ended and the handler
will be
called with the result.
dst
- the destination write streampublic NetSocket exceptionHandler(Handler<Throwable> handler)
ReadStream
exceptionHandler
in interface ReadStream<Buffer>
exceptionHandler
in interface StreamBase
exceptionHandler
in interface WriteStream<Buffer>
handler
- the exception handlerpublic NetSocket handler(Handler<Buffer> handler)
ReadStream
handler
in interface ReadStream<Buffer>
public NetSocket pause()
ReadStream
ReadStream
, it sets the buffer in fetch
mode and clears the actual demand.
While it's paused, no data will be sent to the data handler
.
pause
in interface ReadStream<Buffer>
public NetSocket resume()
ReadStream
flowing
mode.
If the ReadStream
has been paused, reading will recommence on it.resume
in interface ReadStream<Buffer>
public NetSocket fetch(long amount)
ReadStream
amount
of elements. If the ReadStream
has been paused, reading will
recommence with the specified amount
of items, otherwise the specified amount
will
be added to the current stream demand.fetch
in interface ReadStream<Buffer>
public NetSocket endHandler(Handler<Void> endHandler)
This handler might be called after the close handler when the socket is paused and there are still buffers to deliver.
endHandler
in interface ReadStream<Buffer>
endHandler
- public NetSocket write(Buffer data)
WriteStream
WriteStream.writeQueueFull()
method before writing. This is done automatically if using a Pump
.write
in interface WriteStream<Buffer>
data
- the data to writepublic NetSocket setWriteQueueMaxSize(int maxSize)
WriteStream
maxSize
. You will still be able to write to the stream even
if there is more than maxSize
items in the write queue. This is used as an indicator by classes such as
Pump
to provide flow control.
The value is defined by the implementation of the stream, e.g in bytes for a
NetSocket
, the number of Message
for a
MessageProducer
, etc...setWriteQueueMaxSize
in interface WriteStream<Buffer>
maxSize
- the max size of the write streampublic NetSocket drainHandler(Handler<Void> handler)
WriteStream
Pump
for an example of this being used.
The stream implementation defines when the drain handler, for example it could be when the queue size has been
reduced to maxSize / 2
.drainHandler
in interface WriteStream<Buffer>
handler
- the handlerpublic String writeHandlerID()
NetSocket
is created it automatically registers an event handler with the event bus, the ID of that
handler is given by writeHandlerID
.
Given this ID, a different event loop can send a buffer to that event handler using the event bus and that buffer will be received by this instance in its own event loop and written to the underlying connection. This allows you to write data to other connections which are owned by different event loops.
public NetSocket write(String str, Handler<AsyncResult<Void>> handler)
write(io.vertx.rxjava.core.buffer.Buffer)
but with an handler
called when the operation completesstr
- handler
- @Deprecated public Observable<Void> writeObservable(String str)
rxWrite(java.lang.String)
insteadwrite(io.vertx.rxjava.core.buffer.Buffer)
but with an handler
called when the operation completesstr
- public Single<Void> rxWrite(String str)
write(io.vertx.rxjava.core.buffer.Buffer)
but with an handler
called when the operation completesstr
- public NetSocket write(String str)
String
to the connection, encoded in UTF-8.str
- the string to writepublic NetSocket write(String str, String enc, Handler<AsyncResult<Void>> handler)
write(io.vertx.rxjava.core.buffer.Buffer)
but with an handler
called when the operation completesstr
- enc
- handler
- @Deprecated public Observable<Void> writeObservable(String str, String enc)
rxWrite(java.lang.String)
insteadwrite(io.vertx.rxjava.core.buffer.Buffer)
but with an handler
called when the operation completesstr
- enc
- public Single<Void> rxWrite(String str, String enc)
write(io.vertx.rxjava.core.buffer.Buffer)
but with an handler
called when the operation completesstr
- enc
- public NetSocket write(String str, String enc)
String
to the connection, encoded using the encoding enc
.str
- the string to writeenc
- the encoding to usepublic NetSocket write(Buffer message, Handler<AsyncResult<Void>> handler)
handler
called when the message has been written
or failed to be written.write
in interface WriteStream<Buffer>
message
- handler
- @Deprecated public Observable<Void> writeObservable(Buffer message)
rxWrite(java.lang.String)
insteadhandler
called when the message has been written
or failed to be written.message
- public Single<Void> rxWrite(Buffer message)
handler
called when the message has been written
or failed to be written.message
- public NetSocket sendFile(String filename)
filename
directly from disk to the outgoing connection,
bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.filename
- file name of the file to sendpublic NetSocket sendFile(String filename, long offset)
filename
directly from disk to the outgoing connection,
bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.filename
- file name of the file to sendoffset
- offsetpublic NetSocket sendFile(String filename, long offset, long length)
filename
directly from disk to the outgoing connection,
bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to stream files.filename
- file name of the file to sendoffset
- offsetlength
- lengthpublic NetSocket sendFile(String filename, Handler<AsyncResult<Void>> resultHandler)
sendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendresultHandler
- handler@Deprecated public Observable<Void> sendFileObservable(String filename)
rxSendFile(java.lang.String)
insteadsendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendpublic Single<Void> rxSendFile(String filename)
sendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendpublic NetSocket sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler)
sendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendoffset
- offsetresultHandler
- handler@Deprecated public Observable<Void> sendFileObservable(String filename, long offset)
rxSendFile(java.lang.String)
insteadsendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendoffset
- offsetpublic Single<Void> rxSendFile(String filename, long offset)
sendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendoffset
- offsetpublic NetSocket sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler)
sendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendoffset
- offsetlength
- lengthresultHandler
- handler@Deprecated public Observable<Void> sendFileObservable(String filename, long offset, long length)
rxSendFile(java.lang.String)
insteadsendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendoffset
- offsetlength
- lengthpublic Single<Void> rxSendFile(String filename, long offset, long length)
sendFile(java.lang.String)
but also takes a handler that will be called when the send has completed or
a failure has occurredfilename
- file name of the file to sendoffset
- offsetlength
- lengthpublic SocketAddress remoteAddress()
null
(e.g a server bound on a domain socket)public SocketAddress localAddress()
null
(e.g a server bound on a domain socket)public void end()
close()
end
in interface WriteStream<Buffer>
public void end(Handler<AsyncResult<Void>> handler)
end
in interface WriteStream<Buffer>
handler
- @Deprecated public Observable<Void> endObservable()
rxEnd(io.vertx.rxjava.core.buffer.Buffer)
insteadpublic void close()
public void close(Handler<AsyncResult<Void>> handler)
handler
when the operation completes.handler
- @Deprecated public Observable<Void> closeObservable()
rxClose()
insteadhandler
when the operation completes.public Single<Void> rxClose()
handler
when the operation completes.public NetSocket closeHandler(Handler<Void> handler)
handler
- the handlerpublic NetSocket upgradeToSsl(Handler<Void> handler)
handler
- the handler will be notified when it's upgradedpublic NetSocket upgradeToSsl(String serverName, Handler<Void> handler)
serverName
- the server namehandler
- the handler will be notified when it's upgradedpublic boolean isSsl()
NetSocket
is encrypted via SSL/TLS.public String indicatedServerName()
public SSLSession sslSession()
Copyright © 2023 Eclipse. All rights reserved.