* This parameter isn't used when using SSL/TLS, where {@link java.nio.ByteBuffer} * size is set up according to the {@link javax.net.ssl.SSLSession} packet size. * @param readByteBufferSize size of the {#link java.nio.ByteBuffer} for inbound data * @return this {#link NioParams} instance */ // @ts-ignore public setReadByteBufferSize(readByteBufferSize: number /*int*/): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getWriteByteBufferSize(): number /*int*/ /** * Sets the size in byte of the write {@link java.nio.ByteBuffer} used in the NIO loop. * Default is 32768. *
* This parameter isn't used when using SSL/TLS, where {@link java.nio.ByteBuffer} * size is set up according to the {@link javax.net.ssl.SSLSession} packet size. * @param writeByteBufferSize size of the {#link java.nio.ByteBuffer} used for outbound data * @return this {#link NioParams} instance */ // @ts-ignore public setWriteByteBufferSize(writeByteBufferSize: number /*int*/): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getNbIoThreads(): number /*int*/ /** * Sets the max number of threads/tasks used for NIO. Default is 1. * Set this number according to the number of simultaneous connections * and their activity. * Threads/tasks are created as necessary (e.g. with 10 threads, when * 10 connections have been created). * Once a connection is created, it's assigned to a thread/task and * all its IO activity is handled by this thread/task. *
* When idle for a few seconds (i.e. without any connection to perform IO for), * a thread/task stops and is recreated if necessary. * @param nbIoThreads * @return this {#link NioParams} instance */ // @ts-ignore public setNbIoThreads(nbIoThreads: number /*int*/): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getWriteEnqueuingTimeoutInMs(): number /*int*/ /** * Sets the timeout for queuing outbound frames. Default is 10,000 ms. * Every requests to the server is divided into frames * that are then queued in a {@link java.util.concurrent.BlockingQueue} before * being sent on the network by a IO thread. *
* If the IO thread cannot cope with the frames dispatch, the * {@link java.util.concurrent.BlockingQueue} gets filled up and blocks * (blocking the calling thread by the same occasion). This timeout is the * time the {@link java.util.concurrent.BlockingQueue} will wait before * rejecting the outbound frame. The calling thread will then received * an exception. *
* The appropriate value depends on the application scenarios: * rate of outbound data (published messages, acknowledgment, etc), network speed... * @param writeEnqueuingTimeoutInMs * @return this {#link NioParams} instance * @see NioParams#setWriteQueueCapacity(int) */ // @ts-ignore public setWriteEnqueuingTimeoutInMs(writeEnqueuingTimeoutInMs: number /*int*/): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getNioExecutor(): java.util.concurrent.ExecutorService /** * Sets the {@link ExecutorService} to use for NIO threads/tasks. * Default is to use the thread factory. *
* The {@link ExecutorService} should be able to run the * number of requested IO threads, plus a few more, as it's also * used to dispatch the shutdown of connections. *
* Connection shutdown can also be handled by a dedicated {@link ExecutorService}, * see {@link #setConnectionShutdownExecutor(ExecutorService)}. *
* It's developer's responsibility to shut down the executor * when it is no longer needed. *
* The thread factory isn't used if an executor service is set up. * @param nioExecutor {#link ExecutorService} used for IO threads and connection shutdown * @return this {#link NioParams} instance * @see NioParams#setNbIoThreads(int) * @see NioParams#setThreadFactory(ThreadFactory) * @see NioParams#setConnectionShutdownExecutor(ExecutorService) */ // @ts-ignore public setNioExecutor(nioExecutor: java.util.concurrent.ExecutorService): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getThreadFactory(): java.util.concurrent.ThreadFactory /** * Sets the {@link ThreadFactory} to use for NIO threads/tasks. * Default is to use the {@link com.rabbitmq.client.ConnectionFactory}'s * {@link ThreadFactory}. *
* The {@link ThreadFactory} is used to spawn the IO threads * and dispatch the shutdown of connections. * @param threadFactory {#link ThreadFactory} used for IO threads and connection shutdown * @return this {#link NioParams} instance * @see NioParams#setNbIoThreads(int) * @see NioParams#setNioExecutor(ExecutorService) */ // @ts-ignore public setThreadFactory(threadFactory: java.util.concurrent.ThreadFactory): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getWriteQueueCapacity(): number /*int*/ /** * Set the capacity of the queue used for outbound frames. * Default capacity is 10,000. * @param writeQueueCapacity * @return this {#link NioParams} instance * @see NioParams#setWriteEnqueuingTimeoutInMs(int) */ // @ts-ignore public setWriteQueueCapacity(writeQueueCapacity: number /*int*/): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getSocketChannelConfigurator(): com.rabbitmq.client.SocketChannelConfigurator /** * Set the {@link java.nio.channels.SocketChannel} configurator. * This gets a chance to "configure" a socket channel * before it has been opened. The default implementation disables * Nagle's algorithm. * @param configurator the configurator to use */ // @ts-ignore public setSocketChannelConfigurator(configurator: com.rabbitmq.client.SocketChannelConfigurator): void // @ts-ignore public getSslEngineConfigurator(): com.rabbitmq.client.SslEngineConfigurator /** * Set the {@link SSLEngine} configurator. * This gets a change to "configure" the SSL engine * before the connection has been opened. This can be * used e.g. to set {@link javax.net.ssl.SSLParameters}. * The default implementation doesn't do anything. * @param configurator the configurator to use */ // @ts-ignore public setSslEngineConfigurator(configurator: com.rabbitmq.client.SslEngineConfigurator): void // @ts-ignore public getConnectionShutdownExecutor(): java.util.concurrent.ExecutorService /** * Set the {@link ExecutorService} used for connection shutdown. * If not set, falls back to the NIO executor and then the thread factory. * This executor service is useful when strict control of the number of threads * is necessary, the application can experience the closing of several connections * at once, and automatic recovery is enabled. In such cases, the connection recovery * can take place in the same pool of threads as the NIO operations, which can * create deadlocks (all the threads of the pool are busy recovering, and there's no * thread left for NIO, so connections never recover). *
* Note it's developer's responsibility to shut down the executor * when it is no longer needed. *
* Using the thread factory for such scenarios avoid the deadlocks, at the price * of potentially creating many short-lived threads in case of massive connection lost. *
* With both the NIO and connection shutdown executor services set and configured * accordingly, the application can control reliably the number of threads used. * @param connectionShutdownExecutor the executor service to use * @return this {#link NioParams} instance * @see NioParams#setNioExecutor(ExecutorService) * @since 5.4.0 */ // @ts-ignore public setConnectionShutdownExecutor(connectionShutdownExecutor: java.util.concurrent.ExecutorService): com.rabbitmq.client.impl.nio.NioParams /** * Set the factory to create {@link java.nio.ByteBuffer}s. *
* The default implementation creates heap-based {@link java.nio.ByteBuffer}s. * @param byteBufferFactory the factory to use * @return this {#link NioParams} instance * @see ByteBufferFactory * @see DefaultByteBufferFactory * @since 5.5.0 */ // @ts-ignore public setByteBufferFactory(byteBufferFactory: com.rabbitmq.client.impl.nio.ByteBufferFactory): com.rabbitmq.client.impl.nio.NioParams // @ts-ignore public getByteBufferFactory(): com.rabbitmq.client.impl.nio.ByteBufferFactory /** * Set the factory to create {@link NioQueue}s. *
* The default uses a {@link ArrayBlockingQueue}.
* @param writeQueueFactory the factory to use
* @return this {#link NioParams} instance
* @see NioQueue
* @since 5.5.0
*/
// @ts-ignore
public setWriteQueueFactory(writeQueueFactory: java.util.function$.Function