reactor.io.net

Class NetStreams

java.lang.Object

reactor.rx.Streams

reactor.io.net.NetStreams

public class NetStreams
extends reactor.rx.Streams

A Streams add-on to work with network facilities from reactor-net, e.g.:

 
 //echo server
 NetStreams.tcpServer(1234).pipeline( connection -> connection );

 NetStreams.tcpClient(1234).pipeline( connection ->
    connection
      //Listen for any incoming data on that connection, they will be Buffer an IOStream can easily decode
      .nest()
      .flatMap(self -> IOStreams.decode(new StringCodec('\n'), self))
      .consume(log::info);

    //Push anything from the publisher returned, here a simple Reactor Stream. By default a Buffer is expected
    return Streams.just(Buffer.wrap("hello\n"));
 );

 //We can also preconfigure global codecs and other custom client/server parameter with the Function signature:
 NetStreams.tcpServer(spec -> spec.codec(kryoCodec).listen(1235)).pipeline( intput -> {
      input.consume(log::info);
      return Streams.period(1l);
 });

 //Assigning the same codec to a client and a server greatly improve readability and provide for extended type safety.
 NetStreams.tcpClient(spec -> spec.connect("localhost", 1235).codec(kryoCodec)).pipeline( input -> {
   input.consume(log::info);
   return Streams.just("hello");
 });

 }
 

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	DEFAULT_BIND_ADDRESS
static java.lang.Class<? extends HttpClient>	DEFAULT_HTTP_CLIENT_TYPE
static java.lang.Class<? extends HttpServer>	DEFAULT_HTTP_SERVER_TYPE
static int	DEFAULT_PORT
static java.lang.Class<? extends TcpClient>	DEFAULT_TCP_CLIENT_TYPE
static java.lang.Class<? extends TcpServer>	DEFAULT_TCP_SERVER_TYPE
static java.lang.Class<? extends DatagramServer>	DEFAULT_UDP_SERVER_TYPE

Method Summary

Modifier and Type	Method and Description
static Spec.IncrementalBackoffReconnect	backoffReconnect()
static <E,IN,OUT> E	delegate(ChannelStream<IN,OUT> channelStream) Utils to read the ChannelStream underlying channel
static <E,IN,OUT> E	delegate(ChannelStream<IN,OUT> channelStream, java.lang.Class<E> clazz)
static HttpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	httpClient()
static <IN,OUT> HttpClient<IN,OUT>	httpClient(java.lang.Class<? extends HttpClient> clientFactory, reactor.fn.Function<? super Spec.HttpClient<IN,OUT>,? extends Spec.HttpClient<IN,OUT>> configuringFunction) Bind a new HTTP client to the specified connect address and port.
static <IN,OUT> HttpClient<IN,OUT>	httpClient(reactor.fn.Function<? super Spec.HttpClient<IN,OUT>,? extends Spec.HttpClient<IN,OUT>> configuringFunction) Bind a new HTTP client to the specified connect address and port.
static HttpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	httpServer()
static <IN,OUT> HttpServer<IN,OUT>	httpServer(java.lang.Class<? extends HttpServer> serverFactory, reactor.fn.Function<? super Spec.HttpServer<IN,OUT>,? extends Spec.HttpServer<IN,OUT>> configuringFunction)
static <IN,OUT> HttpServer<IN,OUT>	httpServer(reactor.fn.Function<? super Spec.HttpServer<IN,OUT>,? extends Spec.HttpServer<IN,OUT>> configuringFunction)
static <IN,OUT> HttpServer<IN,OUT>	httpServer(int port)
static <IN,OUT> HttpServer<IN,OUT>	httpServer(java.lang.String bindAddress)
static <IN,OUT> HttpServer<IN,OUT>	httpServer(java.lang.String bindAddress, int port)
static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpClient() Bind a new TCP client to the localhost on port 12012.
static <IN,OUT> TcpClient<IN,OUT>	tcpClient(java.lang.Class<? extends TcpClient> clientFactory, reactor.fn.Function<? super Spec.TcpClient<IN,OUT>,? extends Spec.TcpClient<IN,OUT>> configuringFunction) Bind a new TCP client to the specified connect address and port.
static <IN,OUT> TcpClient<IN,OUT>	tcpClient(reactor.fn.Function<? super Spec.TcpClient<IN,OUT>,? extends Spec.TcpClient<IN,OUT>> configuringFunction) Bind a new TCP client to the specified connect address and port.
static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpClient(int port) Bind a new TCP client to "loopback" on the the specified port.
static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpClient(java.lang.String bindAddress) Bind a new TCP client to the specified connect address and port 12012.
static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpClient(java.lang.String bindAddress, int port) Bind a new TCP client to the specified connect address and port.
static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpServer() Bind a new TCP server to "loopback" on port 12012.
static <IN,OUT> TcpServer<IN,OUT>	tcpServer(java.lang.Class<? extends TcpServer> serverFactory, reactor.fn.Function<? super Spec.TcpServer<IN,OUT>,? extends Spec.TcpServer<IN,OUT>> configuringFunction) Bind a new TCP server to the specified bind address and port.
static <IN,OUT> TcpServer<IN,OUT>	tcpServer(reactor.fn.Function<? super Spec.TcpServer<IN,OUT>,? extends Spec.TcpServer<IN,OUT>> configuringFunction) Bind a new TCP server to the specified bind address and port.
static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpServer(int port) Bind a new TCP server to "loopback" on the given port.
static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpServer(java.lang.String bindAddress) Bind a new TCP server to the given bind address on port 12012.
static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	tcpServer(java.lang.String bindAddress, int port) Bind a new TCP server to the given bind address and port.
static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	udpServer() Bind a new UDP server to the "loopback" address.
static <IN,OUT> DatagramServer<IN,OUT>	udpServer(java.lang.Class<? extends DatagramServer> serverFactory, reactor.fn.Function<? super Spec.DatagramServer<IN,OUT>,? extends Spec.DatagramServer<IN,OUT>> configuringFunction) Bind a new UDP server to the specified bind address and port.
static <IN,OUT> DatagramServer<IN,OUT>	udpServer(reactor.fn.Function<? super Spec.DatagramServer<IN,OUT>,? extends Spec.DatagramServer<IN,OUT>> configuringFunction) Bind a new UDP server to the specified bind address and port.
static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	udpServer(int port) Bind a new UDP server to the "loopback" address and specified port.
static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	udpServer(java.lang.String bindAddress) Bind a new UDP server to the given bind address.
static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer>	udpServer(java.lang.String bindAddress, int port) Bind a new UDP server to the given bind address and port.

Methods inherited from class reactor.rx.Streams

await, await, await, await, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, concat, concat, concat, concat, concat, concat, concat, concat, concat, create, defer, empty, fail, from, from, from, from, generate, join, join, join, join, join, join, join, join, join, just, just, just, just, just, just, just, just, merge, merge, merge, merge, merge, merge, merge, merge, merge, on, period, period, period, period, period, period, period, period, range, switchOnNext, switchOnNext, switchOnNext, switchOnNext, timer, timer, timer, timer, wrap, zip, zip, zip, zip, zip, zip, zip, zip, zip

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_PORT

public static final int DEFAULT_PORT

See Also:

Constant Field Values

DEFAULT_BIND_ADDRESS

public static final java.lang.String DEFAULT_BIND_ADDRESS

See Also:

Constant Field Values

DEFAULT_TCP_SERVER_TYPE

public static final java.lang.Class<? extends TcpServer> DEFAULT_TCP_SERVER_TYPE

DEFAULT_TCP_CLIENT_TYPE

public static final java.lang.Class<? extends TcpClient> DEFAULT_TCP_CLIENT_TYPE

DEFAULT_HTTP_SERVER_TYPE

public static final java.lang.Class<? extends HttpServer> DEFAULT_HTTP_SERVER_TYPE

DEFAULT_HTTP_CLIENT_TYPE

public static final java.lang.Class<? extends HttpClient> DEFAULT_HTTP_CLIENT_TYPE

DEFAULT_UDP_SERVER_TYPE

public static final java.lang.Class<? extends DatagramServer> DEFAULT_UDP_SERVER_TYPE

Method Detail

tcpServer

public static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpServer()

Bind a new TCP server to "loopback" on port 12012. By default the default server implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpServer

public static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpServer(int port)

Bind a new TCP server to "loopback" on the given port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

port - the port to listen on loopback

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpServer

public static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpServer(java.lang.String bindAddress)

Bind a new TCP server to the given bind address on port 12012. By default the default server implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

bindAddress - bind address (e.g. "127.0.0.1") to create the server on the default port 12012

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpServer

public static TcpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpServer(java.lang.String bindAddress,
                                                                                     int port)

Bind a new TCP server to the given bind address and port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

port - the port to listen on the passed bind address

bindAddress - bind address (e.g. "127.0.0.1") to create the server on the passed port

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpServer

public static <IN,OUT> TcpServer<IN,OUT> tcpServer(reactor.fn.Function<? super Spec.TcpServer<IN,OUT>,? extends Spec.TcpServer<IN,OUT>> configuringFunction)

Bind a new TCP server to the specified bind address and port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpServer

public static <IN,OUT> TcpServer<IN,OUT> tcpServer(java.lang.Class<? extends TcpServer> serverFactory,
                                                   reactor.fn.Function<? super Spec.TcpServer<IN,OUT>,? extends Spec.TcpServer<IN,OUT>> configuringFunction)

Bind a new TCP server to the specified bind address and port. A TcpServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

serverFactory - the given implementation class for this peer

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpClient

public static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpClient()

Bind a new TCP client to the localhost on port 12012. By default the default client implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpClient.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpClient

public static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpClient(java.lang.String bindAddress)

Bind a new TCP client to the specified connect address and port 12012. By default the default client implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpClient.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

bindAddress - the address to connect to on port 12012

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpClient

public static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpClient(int port)

Bind a new TCP client to "loopback" on the the specified port. By default the default client implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpClient.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

port - the port to connect to on "loopback"

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpClient

public static TcpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> tcpClient(java.lang.String bindAddress,
                                                                                     int port)

Bind a new TCP client to the specified connect address and port. By default the default client implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpClient.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

bindAddress - the address to connect to

port - the port to connect to

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpClient

public static <IN,OUT> TcpClient<IN,OUT> tcpClient(reactor.fn.Function<? super Spec.TcpClient<IN,OUT>,? extends Spec.TcpClient<IN,OUT>> configuringFunction)

Bind a new TCP client to the specified connect address and port. By default the default client implementation is scanned from the classpath on Class init. Support for Netty first and ZeroMQ then is provided as long as the relevant library dependencies are on the classpath. A TcpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpClient.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

tcpClient

public static <IN,OUT> TcpClient<IN,OUT> tcpClient(java.lang.Class<? extends TcpClient> clientFactory,
                                                   reactor.fn.Function<? super Spec.TcpClient<IN,OUT>,? extends Spec.TcpClient<IN,OUT>> configuringFunction)

Bind a new TCP client to the specified connect address and port. A TcpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use TcpClient.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

clientFactory - the given implementation class for this peer

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

httpServer

public static HttpServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> httpServer()

Returns:

httpServer

public static <IN,OUT> HttpServer<IN,OUT> httpServer(java.lang.String bindAddress)

Parameters:

bindAddress -

Returns:

httpServer

public static <IN,OUT> HttpServer<IN,OUT> httpServer(int port)

Parameters:

port -

Returns:

httpServer

public static <IN,OUT> HttpServer<IN,OUT> httpServer(java.lang.String bindAddress,
                                                     int port)

Parameters:

bindAddress -

port -

Returns:

httpServer

public static <IN,OUT> HttpServer<IN,OUT> httpServer(reactor.fn.Function<? super Spec.HttpServer<IN,OUT>,? extends Spec.HttpServer<IN,OUT>> configuringFunction)

Type Parameters:

IN -

OUT -

Parameters:

configuringFunction -

Returns:

httpServer

public static <IN,OUT> HttpServer<IN,OUT> httpServer(java.lang.Class<? extends HttpServer> serverFactory,
                                                     reactor.fn.Function<? super Spec.HttpServer<IN,OUT>,? extends Spec.HttpServer<IN,OUT>> configuringFunction)

Type Parameters:

IN -

OUT -

Parameters:

serverFactory -

configuringFunction -

Returns:

httpClient

public static HttpClient<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> httpClient()

Returns:

httpClient

public static <IN,OUT> HttpClient<IN,OUT> httpClient(reactor.fn.Function<? super Spec.HttpClient<IN,OUT>,? extends Spec.HttpClient<IN,OUT>> configuringFunction)

Bind a new HTTP client to the specified connect address and port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A HttpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use HttpClient.pipeline(reactor.fn.Function<reactor.io.net.http.HttpChannel<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

httpClient

public static <IN,OUT> HttpClient<IN,OUT> httpClient(java.lang.Class<? extends HttpClient> clientFactory,
                                                     reactor.fn.Function<? super Spec.HttpClient<IN,OUT>,? extends Spec.HttpClient<IN,OUT>> configuringFunction)

Bind a new HTTP client to the specified connect address and port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A HttpClient is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when client is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use HttpClient.pipeline(reactor.fn.Function<reactor.io.net.http.HttpChannel<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

clientFactory - the given implementation class for this peer

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

udpServer

public static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> udpServer()

Bind a new UDP server to the "loopback" address. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A DatagramServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use DatagramServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

udpServer

public static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> udpServer(java.lang.String bindAddress)

Bind a new UDP server to the given bind address. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A DatagramServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use DatagramServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

bindAddress - bind address (e.g. "127.0.0.1") to create the server on the passed port

Returns:

a new Stream of ChannelStream, typically a peer of connections.

udpServer

public static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> udpServer(int port)

Bind a new UDP server to the "loopback" address and specified port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A DatagramServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use DatagramServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

port - the port to listen on the passed bind address

Returns:

a new Stream of ChannelStream, typically a peer of connections.

udpServer

public static DatagramServer<reactor.io.buffer.Buffer,reactor.io.buffer.Buffer> udpServer(java.lang.String bindAddress,
                                                                                          int port)

Bind a new UDP server to the given bind address and port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A DatagramServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use DatagramServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Parameters:

port - the port to listen on the passed bind address

bindAddress - bind address (e.g. "127.0.0.1") to create the server on the passed port

Returns:

a new Stream of ChannelStream, typically a peer of connections.

udpServer

public static <IN,OUT> DatagramServer<IN,OUT> udpServer(reactor.fn.Function<? super Spec.DatagramServer<IN,OUT>,? extends Spec.DatagramServer<IN,OUT>> configuringFunction)

Bind a new UDP server to the specified bind address and port. By default the default server implementation is scanned from the classpath on Class init. Support for Netty is provided as long as the relevant library dependencies are on the classpath. A DatagramServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use DatagramServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

udpServer

public static <IN,OUT> DatagramServer<IN,OUT> udpServer(java.lang.Class<? extends DatagramServer> serverFactory,
                                                        reactor.fn.Function<? super Spec.DatagramServer<IN,OUT>,? extends Spec.DatagramServer<IN,OUT>> configuringFunction)

Bind a new UDP server to the specified bind address and port. A DatagramServer is a specific kind of Publisher that will emit: - onNext ChannelStream to consume data from - onComplete when server is shutdown - onError when any exception (more specifically IO exception) occurs From the emitted Channel, one can decide to add in-channel consumers to read any incoming data. To reply data on the active connection, Channel.sink(org.reactivestreams.Publisher<? extends OUT>) can subscribe to any passed Publisher. An alternative is to use DatagramServer.pipeline(reactor.fn.Function<reactor.io.net.ChannelStream<IN, OUT>, ? extends org.reactivestreams.Publisher<? extends OUT>>) to both define the input consumers and the output producers in a single call; Note that Stream.getCapacity() will be used to switch on/off a channel in auto-read / flush on write mode. If the capacity is Long.MAX_Value, write on flush and auto read will apply. Otherwise, data will be flushed every capacity batch size and read will pause when capacity number of elements have been dispatched. Emitted channels will run on the same thread they have beem receiving IO events. Apart from dispatching the write, it is possible to use Stream.dispatchOn(reactor.Environment) to process requests asynchronously. By default the type of emitted data or received data is Buffer

Type Parameters:

IN - the given input type received by this peer. Any configured codec decoder must match this type.

OUT - the given output type received by this peer. Any configured codec encoder must match this type.

Parameters:

serverFactory - the given implementation class for this peer

configuringFunction - a function will apply and return a Spec to customize the peer

Returns:

a new Stream of ChannelStream, typically a peer of connections.

delegate

public static <E,IN,OUT> E delegate(ChannelStream<IN,OUT> channelStream)

Utils to read the ChannelStream underlying channel

delegate

public static <E,IN,OUT> E delegate(ChannelStream<IN,OUT> channelStream,
                                    java.lang.Class<E> clazz)

backoffReconnect

public static Spec.IncrementalBackoffReconnect backoffReconnect()

Returns:

a Specification to configure and supply a Reconnect handler