Package io.vertx.mutiny.core.http

Class ServerWebSocket

java.lang.Object

io.vertx.mutiny.core.http.ServerWebSocket

All Implemented Interfaces:

MutinyDelegate, WebSocketBase, ReadStream<Buffer>, StreamBase, WriteStream<Buffer>

public class ServerWebSocket
extends Object
implements MutinyDelegate, WebSocketBase

Represents a server side WebSocket.

Instances of this class are passed into a HttpServer.webSocketHandler(java.util.function.Consumer<io.vertx.mutiny.core.http.ServerWebSocket>) or provided when a WebSocket handshake is manually HttpServerRequest.toWebSocket()ed.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field	Description
static final TypeArg<ServerWebSocket>	__TYPE_ARG

Constructor Summary

Constructors

Constructor	Description
ServerWebSocket(io.vertx.core.http.ServerWebSocket delegate)
ServerWebSocket(Object delegate)

Method Summary

Modifier and Type	Method	Description
void	accept()	Deprecated. instead use ServerWebSocketHandshake.accept()
HostAndPort	authority()
String	binaryHandlerID()
WebSocketBase	binaryMessageHandler(Consumer<Buffer> handler)
io.smallrye.mutiny.Uni<Void>	close()	Same as close() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	close(short statusCode)	Same as WebSocketBase.close() but with an handler called when the operation completes
io.smallrye.mutiny.Uni<Void>	close(short statusCode, String reason)	Same as WebSocketBase.close() but with an handler called when the operation completes
Void	closeAndAwait()	Blocking variant of WebSocketBase.close().
Void	closeAndAwait(short statusCode)	Blocking variant of WebSocketBase.close(short).
Void	closeAndAwait(short statusCode, String reason)	Blocking variant of WebSocketBase.close(short,String).
void	closeAndForget()	Variant of WebSocketBase.close() that ignores the result of the operation.
void	closeAndForget(short statusCode)	Variant of WebSocketBase.close(short) that ignores the result of the operation.
void	closeAndForget(short statusCode, String reason)	Variant of WebSocketBase.close(short,String) that ignores the result of the operation.
ServerWebSocket	closeHandler(Runnable handler)
String	closeReason()
Short	closeStatusCode()
ServerWebSocket	drainHandler(Runnable handler)
io.smallrye.mutiny.Uni<Void>	end()	Calls WebSocketBase.close()
io.smallrye.mutiny.Uni<Void>	end(Buffer data)	Same as but with an handler called when the operation completes
Void	endAndAwait()	Blocking variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer).
Void	endAndAwait(Buffer data)	Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer).
void	endAndForget()	Variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
void	endAndForget(Buffer data)	Variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
ServerWebSocket	endHandler(Runnable endHandler)
boolean	equals(Object o)
ServerWebSocket	exceptionHandler(Consumer<Throwable> handler)
ServerWebSocket	fetch(long amount)
ServerWebSocket	frameHandler(Consumer<WebSocketFrame> handler)
io.vertx.core.http.ServerWebSocket	getDelegate()
ServerWebSocket	handler(Consumer<Buffer> handler)
int	hashCode()
MultiMap	headers()
String	host()	Deprecated. use authority() instead
boolean	isClosed()
boolean	isSsl()
SocketAddress	localAddress()
static ServerWebSocket	newInstance(io.vertx.core.http.ServerWebSocket arg)
String	path()
ServerWebSocket	pause()
Pipe<Buffer>	pipe()
io.smallrye.mutiny.Uni<Void>	pipeTo(WriteStream<Buffer> dst)	Pipe this ReadStream to the WriteStream.
Void	pipeToAndAwait(WriteStream<Buffer> dst)	Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).
void	pipeToAndForget(WriteStream<Buffer> dst)	Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.
WebSocketBase	pongHandler(Consumer<Buffer> handler)
String	query()
void	reject()	Deprecated. instead use ServerWebSocketHandshake.reject()
void	reject(int status)	Deprecated. instead use ServerWebSocketHandshake.reject(int)
SocketAddress	remoteAddress()
ServerWebSocket	resume()
String	scheme()
io.smallrye.mutiny.Uni<Integer>	setHandshake(io.smallrye.mutiny.Uni<Integer> future)	Deprecated. instead use ServerWebSocketHandshake
Integer	setHandshakeAndAwait(io.smallrye.mutiny.Uni<Integer> future)	Deprecated. instead use ServerWebSocketHandshake
void	setHandshakeAndForget(io.smallrye.mutiny.Uni<Integer> future)	Deprecated. instead use ServerWebSocketHandshake
ServerWebSocket	setWriteQueueMaxSize(int maxSize)
SSLSession	sslSession()
String	subProtocol()
String	textHandlerID()
WebSocketBase	textMessageHandler(Consumer<String> handler)
Iterable<Buffer>	toBlockingIterable()
Stream<Buffer>	toBlockingStream()
io.smallrye.mutiny.Multi<Buffer>	toMulti()
String	toString()
WriteStreamSubscriber<Buffer>	toSubscriber()
String	uri()
io.smallrye.mutiny.Uni<Void>	write(Buffer data)	Same as but with an handler called when the operation completes
Void	writeAndAwait(Buffer data)	Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer).
void	writeAndForget(Buffer data)	Variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writeBinaryMessage(Buffer data)	Same as WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
Void	writeBinaryMessageAndAwait(Buffer data)	Blocking variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer).
ServerWebSocket	writeBinaryMessageAndForget(Buffer data)	Variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writeFinalBinaryFrame(Buffer data)	Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes
Void	writeFinalBinaryFrameAndAwait(Buffer data)	Blocking variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer).
ServerWebSocket	writeFinalBinaryFrameAndForget(Buffer data)	Variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writeFinalTextFrame(String text)	Same as WebSocketBase.writeFinalTextFrame(java.lang.String) but with an handler called when the operation completes
Void	writeFinalTextFrameAndAwait(String text)	Blocking variant of WebSocketBase.writeFinalTextFrame(String).
ServerWebSocket	writeFinalTextFrameAndForget(String text)	Variant of WebSocketBase.writeFinalTextFrame(String) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writeFrame(WebSocketFrame frame)	Same as WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) but with an handler called when the operation completes
Void	writeFrameAndAwait(WebSocketFrame frame)	Blocking variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame).
ServerWebSocket	writeFrameAndForget(WebSocketFrame frame)	Variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writePing(Buffer data)	Writes a ping frame to the connection.
Void	writePingAndAwait(Buffer data)	Blocking variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer).
ServerWebSocket	writePingAndForget(Buffer data)	Variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
io.smallrye.mutiny.Uni<Void>	writePong(Buffer data)	Writes a pong frame to the connection.
Void	writePongAndAwait(Buffer data)	Blocking variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer).
ServerWebSocket	writePongAndForget(Buffer data)	Variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.
boolean	writeQueueFull()
io.smallrye.mutiny.Uni<Void>	writeTextMessage(String text)	Same as WebSocketBase.writeTextMessage(java.lang.String) but with an handler called when the operation completes
Void	writeTextMessageAndAwait(String text)	Blocking variant of WebSocketBase.writeTextMessage(String).
ServerWebSocket	writeTextMessageAndForget(String text)	Variant of WebSocketBase.writeTextMessage(String) that ignores the result of the operation.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Details

__TYPE_ARG

public static final TypeArg<ServerWebSocket> __TYPE_ARG

Constructor Details

ServerWebSocket

public ServerWebSocket(io.vertx.core.http.ServerWebSocket delegate)

ServerWebSocket

public ServerWebSocket(Object delegate)

Method Details

getDelegate

public io.vertx.core.http.ServerWebSocket getDelegate()

Specified by:

getDelegate in interface MutinyDelegate

Specified by:

getDelegate in interface ReadStream<Buffer>

Specified by:

getDelegate in interface StreamBase

Specified by:

getDelegate in interface WebSocketBase

Specified by:

getDelegate in interface WriteStream<Buffer>

Returns:

the delegate used by this Mutiny object of generated type

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toSubscriber

@CheckReturnValue
public WriteStreamSubscriber<Buffer> toSubscriber()

write

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(Buffer data)

Same as but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

write in interface WebSocketBase

Specified by:

write in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeAndAwait

public Void writeAndAwait(Buffer data)

Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeAndAwait in interface WebSocketBase

Specified by:

writeAndAwait in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the Void instance produced by the operation.

writeAndForget

public void writeAndForget(Buffer data)

Variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writeAndForget in interface WebSocketBase

Specified by:

writeAndForget in interface WriteStream<Buffer>

Parameters:

data -

end

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end(Buffer data)

Same as but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

end in interface WebSocketBase

Specified by:

end in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

endAndAwait

public Void endAndAwait(Buffer data)

Blocking variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

endAndAwait in interface WebSocketBase

Specified by:

endAndAwait in interface WriteStream<Buffer>

Parameters:

data -

Returns:

the Void instance produced by the operation.

endAndForget

public void endAndForget(Buffer data)

Variant of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.streams.WriteStream#end(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

endAndForget in interface WebSocketBase

Specified by:

endAndForget in interface WriteStream<Buffer>

Parameters:

data -

writeQueueFull

public boolean writeQueueFull()

Specified by:

writeQueueFull in interface WebSocketBase

Specified by:

writeQueueFull in interface WriteStream<Buffer>

Returns:

true if write queue is full

pipe

public Pipe<Buffer> pipe()

Specified by:

pipe in interface ReadStream<Buffer>

Specified by:

pipe in interface WebSocketBase

Returns:

a pipe

pipeTo

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> pipeTo(WriteStream<Buffer> dst)

Pipe this 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.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

pipeTo in interface ReadStream<Buffer>

Specified by:

pipeTo in interface WebSocketBase

Parameters:

dst - the destination write stream

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

pipeToAndAwait

public Void pipeToAndAwait(WriteStream<Buffer> dst)

Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

pipeToAndAwait in interface ReadStream<Buffer>

Specified by:

pipeToAndAwait in interface WebSocketBase

Parameters:

dst - the destination write stream

Returns:

the Void instance produced by the operation.

pipeToAndForget

public void pipeToAndForget(WriteStream<Buffer> dst)

Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

This method subscribes on the result of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) but you don't need to compose it with other operations.

Specified by:

pipeToAndForget in interface ReadStream<Buffer>

Specified by:

pipeToAndForget in interface WebSocketBase

Parameters:

dst - the destination write stream

binaryHandlerID

public String binaryHandlerID()

Specified by:

binaryHandlerID in interface WebSocketBase

Returns:

the binary handler id

textHandlerID

public String textHandlerID()

Specified by:

textHandlerID in interface WebSocketBase

Returns:

the text handler id

subProtocol

public String subProtocol()

Specified by:

subProtocol in interface WebSocketBase

Returns:

closeStatusCode

public Short closeStatusCode()

Specified by:

closeStatusCode in interface WebSocketBase

Returns:

closeReason

public String closeReason()

Specified by:

closeReason in interface WebSocketBase

Returns:

headers

public MultiMap headers()

Specified by:

headers in interface WebSocketBase

Returns:

the headers

textMessageHandler

public WebSocketBase textMessageHandler(Consumer<String> handler)

Specified by:

textMessageHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

binaryMessageHandler

public WebSocketBase binaryMessageHandler(Consumer<Buffer> handler)

Specified by:

binaryMessageHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

pongHandler

public WebSocketBase pongHandler(Consumer<Buffer> handler)

Specified by:

pongHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

end

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end()

Calls WebSocketBase.close()

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

end in interface WebSocketBase

Specified by:

end in interface WriteStream<Buffer>

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

endAndAwait

public Void endAndAwait()

Blocking variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

endAndAwait in interface WebSocketBase

Specified by:

endAndAwait in interface WriteStream<Buffer>

Returns:

the Void instance produced by the operation.

endAndForget

public void endAndForget()

Variant of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.end(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

endAndForget in interface WebSocketBase

Specified by:

endAndForget in interface WriteStream<Buffer>

close

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close()

Same as close() but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

close in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait()

Blocking variant of WebSocketBase.close().

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

closeAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

closeAndForget

public void closeAndForget()

Variant of WebSocketBase.close() that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.close(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.close() but you don't need to compose it with other operations.

Specified by:

closeAndForget in interface WebSocketBase

close

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close(short statusCode)

Same as WebSocketBase.close() but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

close in interface WebSocketBase

Parameters:

statusCode -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait(short statusCode)

Blocking variant of WebSocketBase.close(short).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

closeAndAwait in interface WebSocketBase

Parameters:

statusCode -

Returns:

the Void instance produced by the operation.

closeAndForget

public void closeAndForget(short statusCode)

Variant of WebSocketBase.close(short) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.close(short), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.close(short) but you don't need to compose it with other operations.

Specified by:

closeAndForget in interface WebSocketBase

Parameters:

statusCode -

close

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> close(short statusCode,
 String reason)

Same as WebSocketBase.close() but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

close in interface WebSocketBase

Parameters:

statusCode -

reason -

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

closeAndAwait

public Void closeAndAwait(short statusCode,
 String reason)

Blocking variant of WebSocketBase.close(short,String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

closeAndAwait in interface WebSocketBase

Parameters:

statusCode -

reason -

Returns:

the Void instance produced by the operation.

closeAndForget

public void closeAndForget(short statusCode,
 String reason)

Variant of WebSocketBase.close(short,String) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.close(short,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.close(short,String) but you don't need to compose it with other operations.

Specified by:

closeAndForget in interface WebSocketBase

Parameters:

statusCode -

reason -

remoteAddress

public SocketAddress remoteAddress()

Specified by:

remoteAddress in interface WebSocketBase

Returns:

the remote address for this connection, possibly null (e.g a server bound on a domain socket). If useProxyProtocol is set to true, the address returned will be of the actual connecting client.

localAddress

public SocketAddress localAddress()

Specified by:

localAddress in interface WebSocketBase

Returns:

the local address for this connection, possibly null (e.g a server bound on a domain socket) If useProxyProtocol is set to true, the address returned will be of the proxy.

isSsl

public boolean isSsl()

Specified by:

isSsl in interface WebSocketBase

Returns:

true if this HttpConnection is encrypted via SSL/TLS.

isClosed

public boolean isClosed()

Specified by:

isClosed in interface WebSocketBase

Returns:

true if the WebSocket is closed

exceptionHandler

public ServerWebSocket exceptionHandler(Consumer<Throwable> handler)

Specified by:

exceptionHandler in interface ReadStream<Buffer>

Specified by:

exceptionHandler in interface StreamBase

Specified by:

exceptionHandler in interface WebSocketBase

Specified by:

exceptionHandler in interface WriteStream<Buffer>

Parameters:

handler - the exception handler

Returns:

handler

public ServerWebSocket handler(Consumer<Buffer> handler)

Specified by:

handler in interface ReadStream<Buffer>

Specified by:

handler in interface WebSocketBase

Returns:

pause

public ServerWebSocket pause()

Specified by:

pause in interface ReadStream<Buffer>

Specified by:

pause in interface WebSocketBase

Returns:

a reference to this, so the API can be used fluently

resume

public ServerWebSocket resume()

Specified by:

resume in interface ReadStream<Buffer>

Specified by:

resume in interface WebSocketBase

Returns:

a reference to this, so the API can be used fluently

fetch

public ServerWebSocket fetch(long amount)

Specified by:

fetch in interface ReadStream<Buffer>

Specified by:

fetch in interface WebSocketBase

Returns:

a reference to this, so the API can be used fluently

endHandler

public ServerWebSocket endHandler(Runnable endHandler)

Specified by:

endHandler in interface ReadStream<Buffer>

Specified by:

endHandler in interface WebSocketBase

Returns:

setWriteQueueMaxSize

public ServerWebSocket setWriteQueueMaxSize(int maxSize)

Specified by:

setWriteQueueMaxSize in interface WebSocketBase

Specified by:

setWriteQueueMaxSize in interface WriteStream<Buffer>

Parameters:

maxSize - the max size of the write stream

Returns:

a reference to this, so the API can be used fluently

drainHandler

public ServerWebSocket drainHandler(Runnable handler)

Specified by:

drainHandler in interface WebSocketBase

Specified by:

drainHandler in interface WriteStream<Buffer>

Parameters:

handler - the handler

Returns:

writeFrame

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeFrame(WebSocketFrame frame)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeFrame in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeFrameAndAwait

public Void writeFrameAndAwait(WebSocketFrame frame)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeFrameAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeFrameAndForget

public ServerWebSocket writeFrameAndForget(WebSocketFrame frame)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeFrame(io.vertx.mutiny.core.http.WebSocketFrame) but you don't need to compose it with other operations.

Specified by:

writeFrameAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeFinalTextFrame

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeFinalTextFrame(String text)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeFinalTextFrame(java.lang.String) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeFinalTextFrame in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeFinalTextFrameAndAwait

public Void writeFinalTextFrameAndAwait(String text)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeFinalTextFrame(String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeFinalTextFrameAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeFinalTextFrameAndForget

public ServerWebSocket writeFinalTextFrameAndForget(String text)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeFinalTextFrame(String) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeFinalTextFrame(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeFinalTextFrame(String) but you don't need to compose it with other operations.

Specified by:

writeFinalTextFrameAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeFinalBinaryFrame

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeFinalBinaryFrame(Buffer data)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeFinalBinaryFrame in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeFinalBinaryFrameAndAwait

public Void writeFinalBinaryFrameAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeFinalBinaryFrameAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeFinalBinaryFrameAndForget

public ServerWebSocket writeFinalBinaryFrameAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeFinalBinaryFrame(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writeFinalBinaryFrameAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeBinaryMessage

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeBinaryMessage(Buffer data)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeBinaryMessage in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeBinaryMessageAndAwait

public Void writeBinaryMessageAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeBinaryMessageAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeBinaryMessageAndForget

public ServerWebSocket writeBinaryMessageAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeBinaryMessage(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writeBinaryMessageAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writeTextMessage

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writeTextMessage(String text)

Description copied from interface: WebSocketBase

Same as WebSocketBase.writeTextMessage(java.lang.String) but with an handler called when the operation completes

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writeTextMessage in interface WebSocketBase

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writeTextMessageAndAwait

public Void writeTextMessageAndAwait(String text)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writeTextMessage(String).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writeTextMessageAndAwait in interface WebSocketBase

Returns:

the Void instance produced by the operation.

writeTextMessageAndForget

public ServerWebSocket writeTextMessageAndForget(String text)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writeTextMessage(String) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writeTextMessage(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writeTextMessage(String) but you don't need to compose it with other operations.

Specified by:

writeTextMessageAndForget in interface WebSocketBase

Returns:

the instance of WebSocketBase to chain method calls.

writePing

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writePing(Buffer data)

Description copied from interface: WebSocketBase

Writes a ping frame to the connection. This will be written in a single frame. Ping frames may be at most 125 bytes (octets).

This method should not be used to write application data and should only be used for implementing a keep alive or to ensure the client is still responsive, see RFC 6455 Section section 5.5.2.

There is no handler for ping frames because RFC 6455 clearly states that the only response to a ping frame is a pong frame with identical contents.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writePing in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writePingAndAwait

public Void writePingAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writePingAndAwait in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the Void instance produced by the operation.

writePingAndForget

public ServerWebSocket writePingAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writePing(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writePingAndForget in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the instance of WebSocketBase to chain method calls.

writePong

@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> writePong(Buffer data)

Description copied from interface: WebSocketBase

Writes a pong frame to the connection. This will be written in a single frame. Pong frames may be at most 125 bytes (octets).

This method should not be used to write application data and should only be used for implementing a keep alive or to ensure the client is still responsive, see RFC 6455 section 5.5.2.

There is no need to manually write a pong frame, as the server and client both handle responding to a ping from with a pong from automatically and this is exposed to users. RFC 6455 section 5.5.3 states that pongs may be sent unsolicited in order to implement a one way heartbeat.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Specified by:

writePong in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

writePongAndAwait

public Void writePongAndAwait(Buffer data)

Description copied from interface: WebSocketBase

Blocking variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Specified by:

writePongAndAwait in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the Void instance produced by the operation.

writePongAndForget

public ServerWebSocket writePongAndForget(Buffer data)

Description copied from interface: WebSocketBase

Variant of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

This method subscribes on the result of WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from WebSocketBase.writePong(io.vertx.mutiny.core.buffer.Buffer) but you don't need to compose it with other operations.

Specified by:

writePongAndForget in interface WebSocketBase

Parameters:

data - the data to write, may be at most 125 bytes

Returns:

the instance of WebSocketBase to chain method calls.

closeHandler

public ServerWebSocket closeHandler(Runnable handler)

Specified by:

closeHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

frameHandler

public ServerWebSocket frameHandler(Consumer<WebSocketFrame> handler)

Specified by:

frameHandler in interface WebSocketBase

Parameters:

handler - the handler

Returns:

scheme

public String scheme()

Returns:

the WebSocket handshake scheme

host

@Deprecated
public String host()

Deprecated.

use authority() instead

Returns:

the WebSocket handshake host

authority

public HostAndPort authority()

Returns:

the WebSocket handshake authority

uri

public String uri()

path

public String path()

Returns:

the WebSocket handshake path.

query

public String query()

Returns:

the WebSocket handshake query string.

accept

@Deprecated
public void accept()

Deprecated.

instead use ServerWebSocketHandshake.accept()

reject

@Deprecated
public void reject()

Deprecated.

instead use ServerWebSocketHandshake.reject()

reject

@Deprecated
public void reject(int status)

Deprecated.

instead use ServerWebSocketHandshake.reject(int)

Parameters:

status -

setHandshake

@CheckReturnValue
@Deprecated
public io.smallrye.mutiny.Uni<Integer> setHandshake(io.smallrye.mutiny.Uni<Integer> future)

Deprecated.

instead use ServerWebSocketHandshake

Set an asynchronous result for the handshake, upon completion of the specified future, the WebSocket will either be

• accepted when the future succeeds with the HTTP status code
• rejected when the future is succeeds with an HTTP status code different than
• rejected when the future fails with the HTTP status code 500

The provided future might be completed by the WebSocket itself, e.g calling the close() method will try to accept the handshake and close the WebSocket afterward. Thus it is advised to try to complete the future with or .

This method should be called from the WebSocket handler to explicitly set an asynchronous handshake.

Calling this method will override the future completion handler.

Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

Parameters:

future - the future to complete with

Returns:

the uni firing the result of the operation when completed, or a failure if the operation failed.

setHandshakeAndAwait

@Deprecated
public Integer setHandshakeAndAwait(io.smallrye.mutiny.Uni<Integer> future)

Deprecated.

instead use ServerWebSocketHandshake

Blocking variant of io.vertx.mutiny.core.http.ServerWebSocket#setHandshake(Future).

This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

Parameters:

future - the future to complete with

Returns:

the Integer instance produced by the operation.

setHandshakeAndForget

@Deprecated
public void setHandshakeAndForget(io.smallrye.mutiny.Uni<Integer> future)

Deprecated.

instead use ServerWebSocketHandshake

Variant of io.vertx.mutiny.core.http.ServerWebSocket#setHandshake(Future) that ignores the result of the operation.

This method subscribes on the result of io.vertx.mutiny.core.http.ServerWebSocket#setHandshake(Future), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.core.http.ServerWebSocket#setHandshake(Future) but you don't need to compose it with other operations.

Parameters:

future - the future to complete with

sslSession

public SSLSession sslSession()

Specified by:

sslSession in interface WebSocketBase

Returns:

SSLSession associated with the underlying socket. Returns null if connection is not SSL.

toMulti

@CheckReturnValue
public io.smallrye.mutiny.Multi<Buffer> toMulti()

Specified by:

toMulti in interface ReadStream<Buffer>

toBlockingIterable

public Iterable<Buffer> toBlockingIterable()

toBlockingStream

public Stream<Buffer> toBlockingStream()

newInstance

public static ServerWebSocket newInstance(io.vertx.core.http.ServerWebSocket arg)