GeneralOptions (Asynchronous Game Query Library 1.2.2 API)

java.lang.Object
- com.ibasco.agql.core.util.AbstractOptions
- - com.ibasco.agql.core.util.GeneralOptions

All Implemented Interfaces:: Options, Cloneable, Iterable<Map.Entry<Option<?>,Object>>

public final class GeneralOptions
extends AbstractOptions

A collection of global configuration Options

Sample usage:

  ThreadPoolExecutor executor = new ThreadPoolExecutor(9, Integer.MAX_VALUE,
                                                            60L, TimeUnit.SECONDS,
                                                            new LinkedBlockingQueue<>(),
                                                            new DefaultThreadFactory("agql-query"));
  SourceQueryOptions queryOptions = SourceQueryOptions.builder() //this can be any class that implements the Options interface
                                      .option(GeneralOptions.READ_TIMEOUT, 3000)
                                      .option(GeneralOptions.THREAD_EXECUTOR_SERVICE, executor)
                                      .option(FailsafeOptions.FAILSAFE_ENABLED, true)
                                      .build();

  SourceQueryClient client = new SourceQueryClient(queryOptions);

Author:: Rafael Luis Ibasco
See Also:: Option, OptionBuilder

Field Summary

Fields
Modifier and Type	Field and Description
`static Option<Integer>`	`CLOSE_TIMEOUT` The maximum number of milliseconds to wait before timing out on close channel operation
`static Option<Boolean>`	`CONNECTION_POOLING` Set to `true` to enable channel/connection pooling
`static Option<Integer>`	`POOL_ACQUIRE_MAX` Maximum number of allowed pending acquires.
`static Option<Integer>`	`POOL_ACQUIRE_TIMEOUT` The maximum number of milliseconds to wait before a timeout is triggered during `Channel` acquisition.
`static Option<FixedNettyChannelPool.AcquireTimeoutAction>`	`POOL_ACQUIRE_TIMEOUT_ACTION` The action that will be executed once an acquire timeout is thrown
`static Option<ChannelHealthChecker>`	`POOL_CHANNEL_HEALTH_CHECKER` The `ChannelHealthChecker` that is used by the `ChannelPool` implementation to check if the `Channel` can be acquired.
`static Option<Integer>`	`POOL_MAX_CONNECTIONS` Maximum number of connections to be maintained in the channel/connection pool.
`static Option<ChannelPoolType>`	`POOL_TYPE` The type of `ChannelPool` implementation to use (bounded or unbounded)
`static Option<Integer>`	`READ_TIMEOUT` Number of milliseconds to wait before we throw a ReadTimeoutException (Default: 5 seconds)
`static Option<io.netty.util.ResourceLeakDetector.Level>`	`RESOURCE_LEAK_DETECTOR_LEVEL` Monitor resource usage leaks.
`static Option<Integer>`	`SOCKET_ALLOC_ADAPTIVE_INIT_SIZE` As per netty: the initial buffer size when no feed back was received.
`static Option<Integer>`	`SOCKET_ALLOC_ADAPTIVE_MAX_SIZE` As per netty: the inclusive upper bound of the expected buffer size.
`static Option<Integer>`	`SOCKET_ALLOC_ADAPTIVE_MIN_SIZE` As per netty: the inclusive lower bound of the expected buffer size.
`static Option<Integer>`	`SOCKET_ALLOC_FIXED_SIZE` The fixed receive buffer size to allocate during channel initialization.
`static Option<Integer>`	`SOCKET_CONNECT_TIMEOUT` The connection timeout value
`static Option<Boolean>`	`SOCKET_KEEP_ALIVE` A channel option, when enabled, allows the application to enable keep-alive packets for a socket connection.
`static Option<Integer>`	`SOCKET_RECVBUF` A channel option that specifies the total per-socket buffer space reserved for receives
`static Option<BufferAllocatorType>`	`SOCKET_RECVBUF_ALLOC_TYPE` The strategy for allocating netty's inbound/outbound pooled buffers.
`static Option<Integer>`	`SOCKET_SNDBUF` A channel option that specifies the total per-socket buffer space reserved for sends
`static Option<Integer>`	`THREAD_CORE_SIZE` The number of threads to be used by the internal `EventLoopGroup`.
`static Option<ExecutorService>`	`THREAD_EXECUTOR_SERVICE` A custom `ExecutorService` that will be used by the client.
`static Option<Integer>`	`WRITE_TIMEOUT` Number of milliseconds to wait before we throw a WriteTimeoutException (Default: 5 seconds)

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Options`	`getInstance()` The global `Options` container initially populated with the default values but can be overriden at runtime.

Methods inherited from class com.ibasco.agql.core.util.AbstractOptions
contains, get, get, get, getOrDefault, isLocked, iterator, put, put, putIfAbsent, remove, size

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface com.ibasco.agql.core.util.Options
get, getOrDefault, getOrDefault, isEmpty

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - RESOURCE_LEAK_DETECTOR_LEVEL
```
public static final Option<io.netty.util.ResourceLeakDetector.Level> RESOURCE_LEAK_DETECTOR_LEVEL
```
    Monitor resource usage leaks. Set the desired ResourceLeakDetector
  - READ_TIMEOUT
```
public static final Option<Integer> READ_TIMEOUT
```
    Number of milliseconds to wait before we throw a ReadTimeoutException (Default: 5 seconds)
  - WRITE_TIMEOUT
```
public static final Option<Integer> WRITE_TIMEOUT
```
    Number of milliseconds to wait before we throw a WriteTimeoutException (Default: 5 seconds)
  - CLOSE_TIMEOUT
```
public static final Option<Integer> CLOSE_TIMEOUT
```
    The maximum number of milliseconds to wait before timing out on close channel operation
  - POOL_CHANNEL_HEALTH_CHECKER
```
@ApiStatus.Internal
public static final Option<ChannelHealthChecker> POOL_CHANNEL_HEALTH_CHECKER
```
    The ChannelHealthChecker that is used by the ChannelPool implementation to check if the Channel can be acquired.
  - POOL_ACQUIRE_TIMEOUT_ACTION
```
@ApiStatus.Internal
public static final Option<FixedNettyChannelPool.AcquireTimeoutAction> POOL_ACQUIRE_TIMEOUT_ACTION
```
    The action that will be executed once an acquire timeout is thrown
    
    See Also:
    
    FixedNettyChannelPool.AcquireTimeoutAction
  - POOL_ACQUIRE_TIMEOUT
```
public static final Option<Integer> POOL_ACQUIRE_TIMEOUT
```
    The maximum number of milliseconds to wait before a timeout is triggered during Channel acquisition.
    
    See Also:
    
    FixedChannelPool, ChannelPoolType
  - POOL_ACQUIRE_MAX
```
public static final Option<Integer> POOL_ACQUIRE_MAX
```
    Maximum number of allowed pending acquires. If the limit is reached, an exception is thrown for Channel
    
    See Also:
    
    FixedChannelPool, ChannelPoolType
  - POOL_MAX_CONNECTIONS
```
public static final Option<Integer> POOL_MAX_CONNECTIONS
```
    Maximum number of connections to be maintained in the channel/connection pool. This option is only applicable when POOL_TYPE is set to ChannelPoolType.FIXED
    
    See Also:
    
    FixedChannelPool, ChannelPoolType
  - POOL_TYPE
```
public static final Option<ChannelPoolType> POOL_TYPE
```
    The type of ChannelPool implementation to use (bounded or unbounded)
    
    See Also:
    
    ChannelPoolType.ADAPTIVE, ChannelPoolType.FIXED
  - CONNECTION_POOLING
```
public static final Option<Boolean> CONNECTION_POOLING
```
    Set to true to enable channel/connection pooling
  - THREAD_EXECUTOR_SERVICE
```
public static final Option<ExecutorService> THREAD_EXECUTOR_SERVICE
```
    A custom ExecutorService that will be used by the client. Set to null to use the global executor provided by the library which is shared across all clients by default. (Default: null)
    Note: If you provide a custom ExecutorService, then you are responsible for closing it. Only the default executor is closed automatically.
    
    See Also:
    
    Platform.getDefaultExecutor()
  - THREAD_CORE_SIZE
```
public static final Option<Integer> THREAD_CORE_SIZE
```
    The number of threads to be used by the internal EventLoopGroup. This is usually less than or equals to the core pool size of the ExecutorService provided (Default: null).
    
    See Also:
    
    THREAD_EXECUTOR_SERVICE
  - SOCKET_RECVBUF_ALLOC_TYPE
```
public static final Option<BufferAllocatorType> SOCKET_RECVBUF_ALLOC_TYPE
```
    The strategy for allocating netty's inbound/outbound pooled buffers. If you choose BufferAllocatorType.FIXED, make sure to also set an optimal value for the buffer size (Default is: BufferAllocatorType.FIXED)
    
    See Also:
    
    FixedRecvByteBufAllocator, AdaptiveRecvByteBufAllocator, SOCKET_ALLOC_FIXED_SIZE
  - SOCKET_ALLOC_FIXED_SIZE
```
public static final Option<Integer> SOCKET_ALLOC_FIXED_SIZE
```
    The fixed receive buffer size to allocate during channel initialization. Please note this is only applicable if SOCKET_RECVBUF_ALLOC_TYPE is set to BufferAllocatorType.FIXED (Default is: 9216 bytes)
    
    See Also:
    
    FixedRecvByteBufAllocator, BufferAllocatorType, SOCKET_RECVBUF_ALLOC_TYPE
  - SOCKET_ALLOC_ADAPTIVE_INIT_SIZE
```
public static final Option<Integer> SOCKET_ALLOC_ADAPTIVE_INIT_SIZE
```
    As per netty: the initial buffer size when no feed back was received. Applicable only if SOCKET_RECVBUF_ALLOCATOR_TYPE is set to BufferAllocatorType.ADAPTIVE. (Default is 2048 bytes)
    
    See Also:
    
    SOCKET_RECVBUF_ALLOC_TYPE, BufferAllocatorType
  - SOCKET_ALLOC_ADAPTIVE_MIN_SIZE
```
public static final Option<Integer> SOCKET_ALLOC_ADAPTIVE_MIN_SIZE
```
    As per netty: the inclusive lower bound of the expected buffer size. Applicable only if SOCKET_RECVBUF_ALLOCATOR_TYPE is set to BufferAllocatorType.ADAPTIVE. (Default is 64 bytes)
    
    See Also:
    
    SOCKET_RECVBUF_ALLOC_TYPE, BufferAllocatorType
  - SOCKET_ALLOC_ADAPTIVE_MAX_SIZE
```
public static final Option<Integer> SOCKET_ALLOC_ADAPTIVE_MAX_SIZE
```
    As per netty: the inclusive upper bound of the expected buffer size. Applicable only if SOCKET_RECVBUF_ALLOCATOR_TYPE is set to BufferAllocatorType.ADAPTIVE. (Default is 65536 bytes)
    
    See Also:
    
    SOCKET_RECVBUF_ALLOC_TYPE, BufferAllocatorType
  - SOCKET_SNDBUF
```
public static final Option<Integer> SOCKET_SNDBUF
```
    A channel option that specifies the total per-socket buffer space reserved for sends
  - SOCKET_RECVBUF
```
public static final Option<Integer> SOCKET_RECVBUF
```
    A channel option that specifies the total per-socket buffer space reserved for receives
  - SOCKET_KEEP_ALIVE
```
public static final Option<Boolean> SOCKET_KEEP_ALIVE
```
    A channel option, when enabled, allows the application to enable keep-alive packets for a socket connection.
  - SOCKET_CONNECT_TIMEOUT
```
public static final Option<Integer> SOCKET_CONNECT_TIMEOUT
```
    The connection timeout value
- Method Detail
  - getInstance
```
public static Options getInstance()
```
    The global Options container initially populated with the default values but can be overriden at runtime.
    
    Returns:
    
    The global Options container

Class GeneralOptions

Sample usage:

Field Summary

Method Summary

Methods inherited from class com.ibasco.agql.core.util.AbstractOptions

Methods inherited from class java.lang.Object

Methods inherited from interface com.ibasco.agql.core.util.Options

Methods inherited from interface java.lang.Iterable

Field Detail

RESOURCE_LEAK_DETECTOR_LEVEL

READ_TIMEOUT

WRITE_TIMEOUT

CLOSE_TIMEOUT

POOL_CHANNEL_HEALTH_CHECKER

POOL_ACQUIRE_TIMEOUT_ACTION

POOL_ACQUIRE_TIMEOUT

POOL_ACQUIRE_MAX

POOL_MAX_CONNECTIONS

POOL_TYPE

CONNECTION_POOLING

THREAD_EXECUTOR_SERVICE

THREAD_CORE_SIZE

SOCKET_RECVBUF_ALLOC_TYPE

SOCKET_ALLOC_FIXED_SIZE

SOCKET_ALLOC_ADAPTIVE_INIT_SIZE

SOCKET_ALLOC_ADAPTIVE_MIN_SIZE

SOCKET_ALLOC_ADAPTIVE_MAX_SIZE

SOCKET_SNDBUF

SOCKET_RECVBUF

SOCKET_KEEP_ALIVE

SOCKET_CONNECT_TIMEOUT

Method Detail

getInstance