Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* JBoss, Home of Professional Open Source
*
* Copyright 2013 Red Hat, Inc. and/or its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.xnio;
import org.xnio.channels.ReadTimeoutException;
import org.xnio.channels.SuspendableWriteChannel;
import org.xnio.channels.WriteTimeoutException;
import org.xnio.sasl.SaslQop;
import org.xnio.sasl.SaslStrength;
import javax.net.ssl.KeyManager;
import javax.net.ssl.TrustManager;
import javax.security.sasl.Sasl;
import org.xnio.ssl.SslConnection;
/**
* Common channel options.
*
* @apiviz.exclude
*/
public final class Options {
private Options() {}
/**
* Enable or disable blocking I/O for a newly created channel thread.
*/
public static final Option ALLOW_BLOCKING = Option.simple(Options.class, "ALLOW_BLOCKING", Boolean.class);
/**
* Enable multicast support for a socket. The value type for this option is {@code boolean}. Note that some
* implementations may add overhead when multicast sockets are in use.
*/
public static final Option MULTICAST = Option.simple(Options.class, "MULTICAST", Boolean.class);
/**
* Enable broadcast support for IP datagram sockets. The value type for this option is {@code boolean}. If you
* intend to send datagrams to a broadcast address, this option must be enabled.
*/
public static final Option BROADCAST = Option.simple(Options.class, "BROADCAST", Boolean.class);
/**
* Configure a TCP socket to send an {@code RST} packet on close. The value type for this option is {@code boolean}.
*/
public static final Option CLOSE_ABORT = Option.simple(Options.class, "CLOSE_ABORT", Boolean.class);
/**
* The receive buffer size. The value type for this option is {@code int}. This may be used by an XNIO provider
* directly, or it may be passed to the underlying operating system, depending on the channel type. Buffer
* sizes must always be greater than 0. Note that this value is just a hint; if the application needs to know
* what value was actually stored for this option, it must call {@code getOption(Options.RECEIVE_BUFFER)} on the
* channel to verify. On most operating systems, the receive buffer size may not be changed on a socket after
* it is connected; in these cases, calling {@code setOption(Options.RECEIVE_BUFFER, val)} will return {@code null}.
*/
public static final Option RECEIVE_BUFFER = Option.simple(Options.class, "RECEIVE_BUFFER", Integer.class);
/**
* Configure an IP socket to reuse addresses. The value type for this option is {@code boolean}.
*/
public static final Option REUSE_ADDRESSES = Option.simple(Options.class, "REUSE_ADDRESSES", Boolean.class);
/**
* The send buffer size. The value type for this option is {@code int}. This may be used by an XNIO provider
* directly, or it may be passed to the underlying operating system, depending on the channel type. Buffer
* sizes must always be greater than 0. Note that this value is just a hint; if the application needs to know
* what value was actually stored for this option, it must call {@code getOption(Options.SEND_BUFFER)} on the
* channel to verify.
*/
public static final Option SEND_BUFFER = Option.simple(Options.class, "SEND_BUFFER", Integer.class);
/**
* Configure a TCP socket to disable Nagle's algorithm. The value type for this option is {@code boolean}.
*/
public static final Option TCP_NODELAY = Option.simple(Options.class, "TCP_NODELAY", Boolean.class);
/**
* Set the multicast time-to-live field for datagram sockets. The value type for this option is {@code int}.
*/
public static final Option MULTICAST_TTL = Option.simple(Options.class, "MULTICAST_TTL", Integer.class);
/**
* Set the IP traffic class/type-of-service for the channel. The value type for this option is {@code int}.
*/
public static final Option IP_TRAFFIC_CLASS = Option.simple(Options.class, "IP_TRAFFIC_CLASS", Integer.class);
/**
* Configure a TCP socket to receive out-of-band data alongside regular data. The value type for this option is
* {@code boolean}.
*/
public static final Option TCP_OOB_INLINE = Option.simple(Options.class, "TCP_OOB_INLINE", Boolean.class);
/**
* Configure a channel to send TCP keep-alive messages in an implementation-dependent manner. The value type for
* this option is {@code boolean}.
*/
public static final Option KEEP_ALIVE = Option.simple(Options.class, "KEEP_ALIVE", Boolean.class);
/**
* Configure a server with the specified backlog. The value type for this option is {@code int}.
*/
public static final Option BACKLOG = Option.simple(Options.class, "BACKLOG", Integer.class);
/**
* Configure a read timeout for a socket, in milliseconds. If the given amount of time elapses without
* a successful read taking place, the socket's next read will throw a {@link ReadTimeoutException}.
*/
public static final Option READ_TIMEOUT = Option.simple(Options.class, "READ_TIMEOUT", Integer.class);
/**
* Configure a write timeout for a socket, in milliseconds. If the given amount of time elapses without
* a successful write taking place, the socket's next write will throw a {@link WriteTimeoutException}.
*/
public static final Option WRITE_TIMEOUT = Option.simple(Options.class, "WRITE_TIMEOUT", Integer.class);
/**
* The maximum inbound message size.
*
* @since 2.0
*/
public static final Option MAX_INBOUND_MESSAGE_SIZE = Option.simple(Options.class, "MAX_INBOUND_MESSAGE_SIZE", Integer.class);
/**
* The maximum outbound message size.
*
* @since 2.0
*/
public static final Option MAX_OUTBOUND_MESSAGE_SIZE = Option.simple(Options.class, "MAX_OUTBOUND_MESSAGE_SIZE", Integer.class);
/**
* Specify whether SSL should be enabled. If specified in conjunction with {@link #SSL_STARTTLS} then SSL will not
* be negotiated until {@link org.xnio.channels.SslChannel#startHandshake()} or
* {@link SslConnection#startHandshake()} is called.
*
* @since 3.0
*/
public static final Option SSL_ENABLED = Option.simple(Options.class, "SSL_ENABLED", Boolean.class);
/**
* Specify the SSL client authentication mode.
*
* @since 2.0
*/
public static final Option SSL_CLIENT_AUTH_MODE = Option.simple(Options.class, "SSL_CLIENT_AUTH_MODE", SslClientAuthMode.class);
/**
* Specify the cipher suites for an SSL/TLS session. If a listed cipher suites is not supported, it is ignored; however, if you
* specify a list of cipher suites, none of which are supported, an exception will be thrown.
*
* @since 2.0
*/
public static final Option> SSL_ENABLED_CIPHER_SUITES = Option.sequence(Options.class, "SSL_ENABLED_CIPHER_SUITES", String.class);
/**
* Get the supported cipher suites for an SSL/TLS session. This option is generally read-only.
*
* @since 2.0
*/
public static final Option> SSL_SUPPORTED_CIPHER_SUITES = Option.sequence(Options.class, "SSL_SUPPORTED_CIPHER_SUITES", String.class);
/**
* Specify the enabled protocols for an SSL/TLS session. If a listed protocol is not supported, it is ignored; however, if you
* specify a list of protocols, none of which are supported, an exception will be thrown.
*
* @since 2.0
*/
public static final Option> SSL_ENABLED_PROTOCOLS = Option.sequence(Options.class, "SSL_ENABLED_PROTOCOLS", String.class);
/**
* Get the supported protocols for an SSL/TLS session. This option is generally read-only.
*
* @since 2.0
*/
public static final Option> SSL_SUPPORTED_PROTOCOLS = Option.sequence(Options.class, "SSL_SUPPORTED_PROTOCOLS", String.class);
/**
* Specify the requested provider for an SSL/TLS session.
*
* @since 2.0
*/
public static final Option SSL_PROVIDER = Option.simple(Options.class, "SSL_PROVIDER", String.class);
/**
* Specify the protocol name for an SSL context.
*
* @since 2.1
*/
public static final Option SSL_PROTOCOL = Option.simple(Options.class, "SSL_PROTOCOL", String.class);
/**
* Enable or disable session creation for an SSL connection. Defaults to {@code true} to enable session creation.
*
* @since 2.0
*/
public static final Option SSL_ENABLE_SESSION_CREATION = Option.simple(Options.class, "SSL_ENABLE_SESSION_CREATION", Boolean.class);
/**
* Specify whether SSL conversations should be in client or server mode. Defaults to {@code false} (use server mode). If
* set to {@code true}, the client and server side swap negotiation roles.
*
* @since 2.0
*/
public static final Option SSL_USE_CLIENT_MODE = Option.simple(Options.class, "SSL_USE_CLIENT_MODE", Boolean.class);
/**
* The size of the SSL client session cache.
*
* @since 3.0
*/
public static final Option SSL_CLIENT_SESSION_CACHE_SIZE = Option.simple(Options.class, "SSL_CLIENT_SESSION_CACHE_SIZE", Integer.class);
/**
* The SSL client session timeout (in seconds).
*
* @since 3.0
*/
public static final Option SSL_CLIENT_SESSION_TIMEOUT = Option.simple(Options.class, "SSL_CLIENT_SESSION_TIMEOUT", Integer.class);
/**
* The size of the SSL server session cache.
*
* @since 3.0
*/
public static final Option SSL_SERVER_SESSION_CACHE_SIZE = Option.simple(Options.class, "SSL_SERVER_SESSION_CACHE_SIZE", Integer.class);
/**
* The SSL server session timeout (in seconds).
*
* @since 3.0
*/
public static final Option SSL_SERVER_SESSION_TIMEOUT = Option.simple(Options.class, "SSL_SERVER_SESSION_TIMEOUT", Integer.class);
/**
* The possible key manager classes to use for a JSSE SSL context.
*
* @since 3.0
*/
public static final Option>> SSL_JSSE_KEY_MANAGER_CLASSES = Option.typeSequence(Options.class, "SSL_JSSE_KEY_MANAGER_CLASSES", KeyManager.class);
/**
* The possible trust store classes to use for a JSSE SSL context.
*
* @since 3.0
*/
public static final Option>> SSL_JSSE_TRUST_MANAGER_CLASSES = Option.typeSequence(Options.class, "SSL_JSSE_TRUST_MANAGER_CLASSES", TrustManager.class);
/**
* The configuration of a secure RNG for SSL usage.
*
* @since 3.0
*/
public static final Option SSL_RNG_OPTIONS = Option.simple(Options.class, "SSL_RNG_OPTIONS", OptionMap.class);
/**
* The packet buffer size for SSL.
*
* @since 3.0
*/
public static final Option SSL_PACKET_BUFFER_SIZE = Option.simple(Options.class, "SSL_PACKET_BUFFER_SIZE", Integer.class);
/**
* The application buffer size for SSL.
*
* @since 3.0
*/
public static final Option SSL_APPLICATION_BUFFER_SIZE = Option.simple(Options.class, "SSL_APPLICATION_BUFFER_SIZE", Integer.class);
/**
* The size of the allocation region to use for SSL packet buffers.
*
* @since 3.0
*/
public static final Option SSL_PACKET_BUFFER_REGION_SIZE = Option.simple(Options.class, "SSL_PACKET_BUFFER_REGION_SIZE", Integer.class);
/**
* The size of the allocation region to use for SSL application buffers.
*
* @since 3.0
*/
public static final Option SSL_APPLICATION_BUFFER_REGION_SIZE = Option.simple(Options.class, "SSL_APPLICATION_BUFFER_REGION_SIZE", Integer.class);
/**
* Specify whether to use STARTTLS mode (in which a connection starts clear and switches to TLS on demand).
*
* @since 3.0
*/
public static final Option SSL_STARTTLS = Option.simple(Options.class, "SSL_STARTTLS", Boolean.class);
/**
* Specify the (non-authoritative) name of the peer host to use for the purposes of session reuse, as well as
* for the use of certain cipher suites (such as Kerberos). If not given, defaults to the host name of the
* socket address of the peer.
*/
public static final Option SSL_PEER_HOST_NAME = Option.simple(Options.class, "SSL_PEER_HOST_NAME", String.class);
/**
* Specify the (non-authoritative) port number of the peer port number to use for the purposes of session reuse, as well as
* for the use of certain cipher suites. If not given, defaults to the port number of the socket address of the peer.
*/
public static final Option SSL_PEER_PORT = Option.simple(Options.class, "SSL_PEER_PORT", Integer.class);
/**
* Hint to the SSL engine that the key manager implementation(s) is/are non-blocking, so they can be executed
* in the I/O thread, possibly improving performance by decreasing latency.
*/
public static final Option SSL_NON_BLOCKING_KEY_MANAGER = Option.simple(Options.class, "SSL_NON_BLOCKING_KEY_MANAGER", Boolean.class);
/**
* Hint to the SSL engine that the trust manager implementation(s) is/are non-blocking, so they can be executed
* in the I/O thread, possibly improving performance by decreasing latency.
*/
public static final Option SSL_NON_BLOCKING_TRUST_MANAGER = Option.simple(Options.class, "SSL_NON_BLOCKING_TRUST_MANAGER", Boolean.class);
/**
* Specify whether direct buffers should be used for socket communications.
*
* @since 3.0
*/
public static final Option USE_DIRECT_BUFFERS = Option.simple(Options.class, "USE_DIRECT_BUFFERS", Boolean.class);
/**
* Determine whether the channel is encrypted, or employs some other level of security. The interpretation of this flag
* is specific to the channel in question; however, whatever the channel type, this flag is generally read-only.
*/
public static final Option SECURE = Option.simple(Options.class, "SECURE", Boolean.class);
/**
* Specify whether SASL mechanisms which implement forward secrecy between sessions are required.
*
* @see Sasl#POLICY_FORWARD_SECRECY
*/
public static final Option SASL_POLICY_FORWARD_SECRECY = Option.simple(Options.class, "SASL_POLICY_FORWARD_SECRECY", Boolean.class);
/**
* Specify whether SASL mechanisms which are susceptible to active (non-dictionary) attacks are permitted.
*
* @see Sasl#POLICY_NOACTIVE
*/
public static final Option SASL_POLICY_NOACTIVE = Option.simple(Options.class, "SASL_POLICY_NOACTIVE", Boolean.class);
/**
* Specify whether SASL mechanisms which accept anonymous logins are permitted.
*
* @see Sasl#POLICY_NOANONYMOUS
*/
public static final Option SASL_POLICY_NOANONYMOUS = Option.simple(Options.class, "SASL_POLICY_NOANONYMOUS", Boolean.class);
/**
* Specify whether SASL mechanisms which are susceptible to passive dictionary attacks are permitted.
*
* @see Sasl#POLICY_NODICTIONARY
*/
public static final Option SASL_POLICY_NODICTIONARY = Option.simple(Options.class, "SASL_POLICY_NODICTIONARY", Boolean.class);
/**
* Specify whether SASL mechanisms which are susceptible to simple plain passive attacks are permitted.
*
* @see Sasl#POLICY_NOPLAINTEXT
*/
public static final Option SASL_POLICY_NOPLAINTEXT = Option.simple(Options.class, "SASL_POLICY_NOPLAINTEXT", Boolean.class);
/**
* Specify whether SASL mechanisms which pass client credentials are required.
*
* @see Sasl#POLICY_PASS_CREDENTIALS
*/
public static final Option SASL_POLICY_PASS_CREDENTIALS = Option.simple(Options.class, "SASL_POLICY_PASS_CREDENTIALS", Boolean.class);
/**
* Specify the SASL quality-of-protection to use.
*
* @see Sasl#QOP
*/
public static final Option> SASL_QOP = Option.sequence(Options.class, "SASL_QOP", SaslQop.class);
/**
* Specify the SASL cipher strength to use.
*
* @see Sasl#STRENGTH
*/
public static final Option SASL_STRENGTH = Option.simple(Options.class, "SASL_STRENGTH", SaslStrength.class);
/**
* Specify whether the SASL server must authenticate to the client.
*
* @see Sasl#SERVER_AUTH
*/
public static final Option SASL_SERVER_AUTH = Option.simple(Options.class, "SASL_SERVER_AUTH", Boolean.class);
/**
* Specify whether SASL mechanisms should attempt to reuse authenticated session information.
*
* @see Sasl#REUSE
*/
public static final Option SASL_REUSE = Option.simple(Options.class, "SASL_REUSE", Boolean.class);
/**
* A list of SASL mechanisms, in decreasing order of preference.
*/
public static final Option> SASL_MECHANISMS = Option.sequence(Options.class, "SASL_MECHANISMS", String.class);
/**
* A list of disallowed SASL mechanisms.
*/
public static final Option> SASL_DISALLOWED_MECHANISMS = Option.sequence(Options.class, "SASL_DISALLOWED_MECHANISMS", String.class);
/**
* A list of provider specific SASL properties.
*/
public static final Option> SASL_PROPERTIES = Option.sequence(Options.class, "SASL_PROPERTIES", Property.class);
/**
* The file access mode to use when opening a file.
*/
public static final Option FILE_ACCESS = Option.simple(Options.class, "FILE_ACCESS", FileAccess.class);
/**
* A flag which indicates that opened files should be appended to. Some platforms do not support both append and
* {@link FileAccess#READ_WRITE} at the same time.
*/
public static final Option FILE_APPEND = Option.simple(Options.class, "FILE_APPEND", Boolean.class);
/**
* A flag which indicates that a file should be created if it does not exist ({@code true} by default for writing files,
* {@code false} by default for reading files).
*/
public static final Option FILE_CREATE = Option.simple(Options.class, "FILE_CREATE", Boolean.class);
/**
* The stack size (in bytes) to attempt to use for worker threads.
*/
public static final Option STACK_SIZE = Option.simple(Options.class, "STACK_SIZE", Long.class);
/**
* The name to use for a newly created worker. If not specified, the string "XNIO" will be used. The worker name
* is used as a part of the thread name for created threads, and for any management constructs.
*/
public static final Option WORKER_NAME = Option.simple(Options.class, "WORKER_NAME", String.class);
/**
* The thread priority for newly created worker threads. If not specified, the platform default value will be used.
*/
public static final Option THREAD_PRIORITY = Option.simple(Options.class, "THREAD_PRIORITY", Integer.class);
/**
* Specify whether worker threads should be daemon threads. Defaults to {@code false}.
*/
public static final Option THREAD_DAEMON = Option.simple(Options.class, "THREAD_DAEMON", Boolean.class);
/**
* Specify the number of I/O threads to create for the worker. If not specified, a default will be chosen.
*/
public static final Option WORKER_IO_THREADS = Option.simple(Options.class, "WORKER_IO_THREADS", Integer.class);
/**
* Specify the number of I/O threads to devote to reading for split thread channels. If not specified, a default will be chosen to be
* roughly half of the worker I/O threads, or the number of threads not specified for writing.
*/
public static final Option WORKER_READ_THREADS = Option.simple(Options.class, "WORKER_READ_THREADS", Integer.class);
/**
* Specify the number of I/O threads to devote to writing for split thread channels. If not specified, a default will be chosen to be
* roughly half of the worker I/O threads, or the number of threads not specified for reading.
*/
public static final Option WORKER_WRITE_THREADS = Option.simple(Options.class, "WORKER_WRITE_THREADS", Integer.class);
/**
* Specify whether read and write operations should be split among separate threads. If {@code true}, then each
* directional channel may be accessed concurrently with respect to one another, and will have different worker threads assigned;
* otherwise, both directions will share a worker thread and must not be accessed independently.
*/
public static final Option SPLIT_READ_WRITE_THREADS = Option.simple(Options.class, "SPLIT_READ_WRITE_THREADS", Boolean.class);
/**
* Specify whether a server, acceptor, or connector should be attached to write threads. By default, the establishing
* phase of connections are attached to read threads. Use this option if the client or server writes a message
* directly upon connect and a split threads configuration is used.
*/
public static final Option WORKER_ESTABLISH_WRITING = Option.simple(Options.class, "WORKER_ESTABLISH_WRITING", Boolean.class);
/**
* Specify the number of accept threads a single socket server should have. Specifying more than one can result in spurious wakeups
* for a socket server under low connection volume, but higher throughput at high connection volume. The minimum value
* is 1, and the maximum value is equal to the number of available worker threads.
*
* @deprecated This option is now ignored. All I/O threads are used for accept, except in the case of split read/write
* threads, in which case only read or write threads will be used as determined by {@link #WORKER_ESTABLISH_WRITING}.
*/
@Deprecated
public static final Option WORKER_ACCEPT_THREADS = Option.simple(Options.class, "WORKER_ACCEPT_THREADS", Integer.class);
/**
* Specify the number of "core" threads for the worker task thread pool.
*/
public static final Option WORKER_TASK_CORE_THREADS = Option.simple(Options.class, "WORKER_TASK_CORE_THREADS", Integer.class);
/**
* Specify the maximum number of threads for the worker task thread pool.
*/
public static final Option WORKER_TASK_MAX_THREADS = Option.simple(Options.class, "WORKER_TASK_MAX_THREADS", Integer.class);
/**
* Specify the number of milliseconds to keep non-core task threads alive.
*/
public static final Option WORKER_TASK_KEEPALIVE = Option.simple(Options.class, "WORKER_TASK_KEEPALIVE", Integer.class);
/**
* Specify the maximum number of worker tasks to allow before rejecting.
*/
public static final Option WORKER_TASK_LIMIT = Option.simple(Options.class, "WORKER_TASK_LIMIT", Integer.class);
/**
* Specify that output should be buffered. The exact behavior of the buffering is not specified; it may flush based
* on buffered size or time. An explicit {@link SuspendableWriteChannel#flush()} will still cause
* the channel to flush its contents immediately.
*/
public static final Option CORK = Option.simple(Options.class, "CORK", Boolean.class);
/**
* The high water mark for a server's connections. Once this number of connections have been accepted, accepts
* will be suspended for that server.
*/
public static final Option CONNECTION_HIGH_WATER = Option.simple(Options.class, "CONNECTION_HIGH_WATER", Integer.class);
/**
* The low water mark for a server's connections. Once the number of active connections have dropped below this
* number, accepts can be resumed for that server.
*/
public static final Option CONNECTION_LOW_WATER = Option.simple(Options.class, "CONNECTION_LOW_WATER", Integer.class);
/**
* The compression level to apply for compressing streams and channels.
*/
public static final Option COMPRESSION_LEVEL = Option.simple(Options.class, "COMPRESSION_LEVEL", Integer.class);
/**
* The compression type to apply for compressing streams and channels.
*/
public static final Option COMPRESSION_TYPE = Option.simple(Options.class, "COMPRESSION_TYPE", CompressionType.class);
/**
* The number of balancing tokens, if connection-balancing is enabled. Must be less than the number of I/O threads,
* or 0 to disable balancing and just accept opportunistically.
*/
public static final Option BALANCING_TOKENS = Option.simple(Options.class, "BALANCING_TOKENS", Integer.class);
/**
* The number of connections to create per connection-balancing token, if connection-balancing is enabled.
*/
public static final Option BALANCING_CONNECTIONS = Option.simple(Options.class, "BALANCING_CONNECTIONS", Integer.class);
/**
* The poll interval for poll based file system watchers. Defaults to 5000ms. Ignored on Java 7 and later.
*/
public static final Option WATCHER_POLL_INTERVAL = Option.simple(Options.class, "WATCHER_POLL_INTERVAL", Integer.class);
}
