com.gemstone.gemfire.management.GemFireProperties Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
Show all versions of gemfire-core Show documentation
SnappyData store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* 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. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.management;
/**
* Composite Data type to be used by member to depict gemfire properties in key value manner
* @author rishim
* @since 7.0
*
*/
public class GemFireProperties {
/**
* a symbolic name that can be used by administrators to help identify a
* connection to the distributed system.
**/
private String memberName;
private String memberGroups;
/**
* The port used for multicast networking. If zero, then multicast will be
* disabled and locators must be used to find the other members of the
* distributed system. If "mcast-port" is zero and "locators" is "" then this
* distributed system will be isolated from all other GemFire processes.
* Default: "10334"
**/
private int mcastPort;
/**
* The IP address used for multicast networking. If mcast-port is zero, then
* mcast-address is ignored. Default: "239.192.81.1"
**/
private String mcastAddress;
/**
* The IP address that this distributed system's server sockets will listen
* on. If set to an empty string then the local machine's default address will
* be listened on.
**/
private String bindAddress;
/**
* A 16-bit integer that determines the tcp/ip port number to listen on for
* cache communications. If zero, the operating system will select an
* available port to listen on. Each process on a machine must have its own
* tcp-port. Note that some operating systems restrict the range of ports
* usable by non-privileged users, and using restricted port numbers can cause
* runtime errors in GemFire startup.
**/
private int tcpPort;
/**
* Specifies the name of the XML file or resource to initialize the cache with
* when it is created. Create will first look for a file that matches the
* value of this property. If a file is not found then it will be searched for
* using ClassLoader.getResource(java.lang.String). If the value of this
* property is the empty string (""), then the cache will not be declaratively
* initialized
**/
private String cacheXMLFile;
private String configFile;
/**
* Determines how far through your network the multicast packets used by
* GemFire will propagate. Default: "32" Allowed values: 0..255
**/
private int mcastTTL;
private String serverBindAddress;
/**
* A list of locators (host and port) that are used to find other member of
* the distributed system. This attribute's value is a possibly empty comma
* separated list. Each element must be of the form "hostName[portNum]" and
* may be of the form "host:bindAddress[port]" if a specific bind address is
* to be used on the locator machine. The square brackets around the portNum
* are literal character and must be specified.
*
* Since IPv6 bind addresses may contain colons, you may use an at symbol
* instead of a colon to separate the host name and bind address. For example,
* "server1@fdf0:76cf:a0ed:9449::5[12233]" specifies a locator running on
* "server1" and bound to fdf0:76cf:a0ed:9449::5 on port 12233.
*
* If "mcast-port" is zero and "locators" is "" then this distributed system
* will be isolated from all other GemFire processes.
**/
private String locators;
/**
* A host name or bind-address and port ("host[port],peer=,server=") that are
* used to start a locator in the same process as the DistributedSystem. The
* locator is started when the DistributedSystem connects, and is stopped when
* the DistributedSystem disconnects. To start a locator that is not tied to
* the DistributedSystem's lifecycle, see the Locator class in this same
* package.
*
* The peer and server parameters are optional. They specify whether the
* locator can be used for peers to discover eachother, or for clients to
* discover peers. By default both are true. Default: "" (doesn't start a
* locator)
**/
private String startLocator;
/**
* Name of the file to write logging messages to. If the file name if ""
* (default) then messages are written to standard out.
**/
private String logFile;
/** The type of log messages that will actually write to the log file. **/
private int logLevel;
/**
* "true" causes the statistics to be sampled periodically and operating
* system statistics to be fetched each time a sample is taken. "false"
* disables sampling which also disables operating system statistic
* collection. Non OS statistics will still be recorded in memory and can be
* viewed by administration tools. However, charts will show no activity and
* no statistics will be archived while sampling is disabled.
**/
private boolean statisticSamplingEnabled;
/**
* The rate, in milliseconds, at which samples of the statistics will be
* taken.
**/
private int statisticSampleRate;
/**
* The file that statistic samples are written to. An empty string (default)
* disables statistic archival.
**/
private String statisticArchiveFile;
private String includeFile;
/**
* The number of seconds the distributed system will wait for a message to be
* acknowledged before it sends a warning level alert to signal that something
* might be wrong with the system node that is unresponsive. After sending
* this alert the waiter continues to wait. The alerts are logged in the log
* as warnings and will cause an alert notification in the Admin API and
* GemFire JMX Agent. Default: "15"
**/
private int ackWaitThreshold;
/**
* The number of seconds the distributed system will wait after the
* ack-wait-threshold for a message to be acknowledged before it issues an
* alert at severe level. The default value is zero, which turns off this
* feature.
*
* when ack-severe-alert-threshold is used, GemFire will also initiate
* additional checks to see if the process is alive. These checks will begin
* when the ack-wait-threshold is reached and will continue until GemFire has
* been able to communicate with the process and ascertain its status.
**/
private int ackSevereAlertThreshold;
/**
* Limits, in megabytes, how large the current statistic archive file can grow
* before it is closed and archival rolls on to a new file. Set to zero to
* disable archive rolling. Default: "0"
**/
private int archiveFileSizeLimit;
/**
* Limits, in megabytes, how much disk space can be consumed by old inactive
* statistic archive files. When the limit is exceeded the oldest inactive
* archive is deleted. Set to zero to disable automatic archive deletion.
* Default: "0"
**/
private int archiveDiskSpaceLimit;
/**
* Limits, in megabytes, how large the current log file can grow before it is
* closed and logging rolls on to a new file. Set to zero to disable log
* rolling.
**/
private int logFileSizeLimit;
/**
* Limits, in megabytes, how much disk space can be consumed by old inactive
* log files. When the limit is exceeded the oldest inactive log file is
* deleted. Set to zero to disable automatic log file deletion.
**/
private int logDiskSpaceLimit;
/**
* If true, all gemfire socket communication is configured to use SSL through
* JSSE.
**/
private boolean sslEnabled;
/**
* A space seperated list of the SSL cipher suites to enable. Those listed
* must be supported by the available providers.
**/
private String sslCiphers;
/**
* A space seperated list of the SSL protocols to enable. Those listed must be
* supported by the available providers.
**/
private String sslProtocols;
/**
* If false, allow ciphers that do not require the client side of the
* connection to be authenticated.
**/
private boolean sslRequireAuthentication;
/**
* The number of milliseconds a thread can keep exclusive access to a socket
* that it is not actively using. Once a thread loses its lease to a socket it
* will need to re-acquire a socket the next time it sends a message. A value
* of zero causes socket leases to never expire. This property is ignored if
* "conserve-sockets" is true. Default: "15000"
**/
private int socketLeaseTime;
/**
* The size of each socket buffer, in bytes. Smaller buffers conserve memory.
* Larger buffers can improve performance; in particular if large messages are
* being sent. Default: "32768"
**/
private int socketBufferSize;
/**
* Description: Sets the size of the socket buffer used for outgoing multicast
* transmissions. Default: "65535" Allowed values: 2048..Operating System
* maximum
**/
private int mcastSendBufferSize;
/**
* Description: Sets the size of the socket buffer used for incoming multicast
* transmissions. You should set this high if there will be high volumes of
* messages. Default: "1048576" Allowed values: 2048..Operating System maximum
**/
private int mcastRecvBufferSize;
/**
* The byteAllowance determines how many bytes can be sent without a recharge
* from other processes
**/
private int mcastByteAllowance;
/**
* The rechargeThreshold tells receivers how low the sender's initial to
* remaining allowance ratio should be before sending a recharge
**/
private float mcastRechargeThreshold;
/**
* The rechargeBlockMs tells the sender how long to wait for a recharge before
* explicitly requesting one.
**/
private int mcastRechargeBlockMs;
/**
* When messages are sent over datagram sockets, GemFire breaks large messages
* down into fragments for transmission. This property sets the maximum
* fragment size for transmission.
**/
private int udpFragmentSize;
/**
* Sets the size of the socket buffer used for outgoing udp point-to-point
* transmissions.
**/
private int udpSendBufferSize;
/**
* Sets the size of the socket buffer used for incoming udp point-to-point
* transmissions. Note: if multicast is not enabled and disable-tcp is not
* enabled, a reduced default size of 65535 is used.
**/
private int udpRecvBufferSize;
/**
* Turns off use of tcp/ip sockets, forcing the cache to use datagram sockets
* for all communication. This is useful if you have a large number of
* processes in the distributed cache since it eliminates the per-connection
* reader-thread that is otherwise required. However, udp communications are
* somewhat slower than tcp/ip communications due to the extra work required
* in Java to break messages down to transmittable sizes, and the extra work
* required to guarantee message delivery.
**/
private boolean disableTcp;
/**
* "true" causes additional time-based statistics to be gathered for gemfire
* operations. This can aid in discovering where time is going in cache
* operations, albeit at the expense of extra clock probes on every operation.
* "false" disables the additional time-based statistics.
**/
private boolean enableTimeStatistics;
/**
* Turns on network partitioning detection algorithms, which detect loss of
* processes eligible to function as the membership coordinator and correlates
* it with loss of a selected lead member.
**/
private boolean enableNetworkPartitionDetection;
/**
* Establishes the number of seconds of process failure history kept by the
* system for correlating loss of processes eligible to be the membership
* coordinator and the lead member.
**/
private int departureCorrelationWindow;
/**
* Sets the timeout interval, in milliseconds, used to determine whether
* another process is alive or not. When another process appears to be gone,
* GemFire tries five times to contact it before giving up. This property sets
* the timeout interval for each of these attempts. Default: "5000"
**/
private int memberTimeout;
/**
* The allowed range of ports for use in forming an unique membership
* identifier (UDP) and for failure detection purposes (TCP). This range is
* given as two numbers separated by a minus sign.
**/
private int[] membershipPortRange;
/**
* If "true" then a minimal number of sockets will be used when connecting to
* the distributed system. This conserves resource usage but can cause
* performance to suffer. If "false" then every application thread that sends
* distribution messages to other members of the distributed system will own
* its own sockets and have exclusive access to them. The length of time a
* thread can have exclusive access to a socket can be configured with
* "socket-lease-time". Default: "true"
**/
private boolean conserveSockets;
/**
* Specifies the application roles that this member performs in the
* distributed system. This is a comma delimited list of user-defined strings.
* Any number of members can be configured to perform the same role, and a
* member can be configured to perform any number of roles.
**/
private String roles;
/**
* Specifies the maximum number of milliseconds to wait for the distributed
* system to reconnect in case of required role loss. The system will attempt
* to reconnect more than once, and this timeout period applies to each
* reconnection attempt. Default: "10000"
**/
private int maxWaitTimeForReconnect;
/**
* Specifies the maximum number or times to attempt to reconnect to the
* distributed system when required roles are missing. Default: "3"
**/
private int maxNumReconnectTries;
/**
* The number of milliseconds before a publishing process should attempt to
* distribute a cache operation before switching over to asynchronous
* messaging for this process. To enable asynchronous messaging, the value
* must be set above zero. If a thread that is publishing to the cache exceeds
* this value when attempting to distribute to this process, it will switch to
* asynchronous messaging until this process catches up, departs, or some
* specified limit is reached, such as async-queue-timeout or
* async-max-queue-size. Default: "0"
**/
private int asyncDistributionTimeout;
/**
* The number of milliseconds a queuing publisher may enqueue asynchronous
* messages without any distribution to this process before that publisher
* requests this process to depart. If a queuing publisher has not been able
* to send this process any cache operations prior to the timeout, this
* process will attempt to close its cache and disconnect from the distributed
* system. Default: "60000"
**/
private int asyncQueueTimeout;
/**
* The maximum size in megabytes that a publishing process should be allowed
* to asynchronously enqueue for this process before asking this process to
* depart from the distributed system.
**/
private int asyncMaxQueueSize;
/**
* This is a client-side property that is passed to the server. Allowable
* values are "server", "true", and "false". With the "server" setting, this
* client's servers use their own client queue conflation settings. With a
* "true" setting, the servers disregard their own configuration and enable
* conflation of events for all regions for the client. A "false" setting
* causes the client's servers to disable conflation for all regions for the
* client. Default: "server"
**/
private String clientConflation;
/**
* The id to be used by this durable client. When a durable client connects to
* a server, this id is used by the server to identify it. The server will
* accumulate updates for a durable client while it is disconnected and
* deliver these events to the client when it reconnects. Default: ""
**/
private String durableClientId;
/**
* The number of seconds a disconnected durable client is kept alive and
* updates are accumulated for it by the server before it is terminated.
* Default: "300"
**/
private int durableClientTimeout;
/**
* Authentication module name for Clients that requires to act upon
* credentials read from the gemfire.properties file. Module must implement
* AuthInitialize interface. Default: "gemfire.jar:authInit"
**/
private String securityClientAuthInit;
private String securityClientAuthenticator;
private String securityClientDHAlgo;
private String securityPeerAuthInit;
private String securityPeerAuthenticator;
private String securityClientAccessor;
private String securityClientAccessorPP;
private int securityLogLevel;
private String securityLogFile;
private int securityPeerMembershipTimeout;
private boolean removeUnresponsiveClient;
/**
* "true" indicates that server propagates delta generated from Delta type of
* objects. If "false" then server propagates full object but not delta.
* Default: "true"
**/
private boolean deltaPropagation;
/**
* Defines the redundancy zone from this member. If this property is set,
* partitioned regions will not put two redundant copies of data in two
* members with the same redundancy zone setting.
**/
private String redundancyZone;
/**
* Whether or not partitioned regions will put redundant copies of the same
* data in different JVMs running on the same physical host. By default,
* partitioned regions will try to put redundancy copies on different physical
* hosts, but it may put them on the same physical host if no other hosts are
* available. Setting this property to true will prevent partitions regions
* from ever putting redundant copies of data on the same physical host.
**/
private boolean enforceUniqueHost;
private boolean jmxManager;
private boolean jmxManagerStart;
private boolean jmxManagerSSL;
private int jmxManagerPort;
private String jmxManagerBindAddress;
private String jmxManagerHostnameForClients;
private String jmxManagerPasswordFile;
private String jmxManagerAccessFile;
private int jmxManagerHttpPort;
private int jmxManagerUpdateRate;
public GemFireProperties() {
}
// Getters Starts ************************************//
public String getMemberName() {
return memberName;
}
public String getMemberGroups() {
return memberGroups;
}
public int getMcastPort() {
return mcastPort;
}
public String getMcastAddress() {
return mcastAddress;
}
public String getBindAddress() {
return bindAddress;
}
public int getTcpPort() {
return tcpPort;
}
public String getCacheXMLFile() {
return cacheXMLFile;
}
public String getConfigFile() {
return configFile;
}
public int getMcastTTL() {
return mcastTTL;
}
public String getServerBindAddress() {
return serverBindAddress;
}
public String getLocators() {
return locators;
}
public String getStartLocator() {
return startLocator;
}
public String getLogFile() {
return logFile;
}
public int getLogLevel() {
return logLevel;
}
public boolean isStatisticSamplingEnabled() {
return statisticSamplingEnabled;
}
public String getStatisticArchiveFile() {
return statisticArchiveFile;
}
public String getIncludeFile() {
return includeFile;
}
public int getAckWaitThreshold() {
return ackWaitThreshold;
}
public int getAckSevereAlertThreshold() {
return ackSevereAlertThreshold;
}
public int getArchiveFileSizeLimit() {
return archiveFileSizeLimit;
}
public int getArchiveDiskSpaceLimit() {
return archiveDiskSpaceLimit;
}
public int getLogFileSizeLimit() {
return logFileSizeLimit;
}
public int getLogDiskSpaceLimit() {
return logDiskSpaceLimit;
}
public boolean isSslEnabled() {
return sslEnabled;
}
public String getSslCiphers() {
return sslCiphers;
}
public String getSslProtocols() {
return sslProtocols;
}
public boolean isSslRequireAuthentication() {
return sslRequireAuthentication;
}
public int getSocketLeaseTime() {
return socketLeaseTime;
}
public int getSocketBufferSize() {
return socketBufferSize;
}
public int getMcastSendBufferSize() {
return mcastSendBufferSize;
}
public int getMcastRecvBufferSize() {
return mcastRecvBufferSize;
}
public int getMcastByteAllowance() {
return mcastByteAllowance;
}
public float getMcastRechargeThreshold() {
return mcastRechargeThreshold;
}
public int getMcastRechargeBlockMs() {
return mcastRechargeBlockMs;
}
public int getUdpFragmentSize() {
return udpFragmentSize;
}
public int getUdpSendBufferSize() {
return udpSendBufferSize;
}
public int getUdpRecvBufferSize() {
return udpRecvBufferSize;
}
public boolean isDisableTcp() {
return disableTcp;
}
public boolean isEnableTimeStatistics() {
return enableTimeStatistics;
}
public boolean isEnableNetworkPartitionDetection() {
return enableNetworkPartitionDetection;
}
public int getDepartureCorrelationWindow() {
return departureCorrelationWindow;
}
public int getMemberTimeout() {
return memberTimeout;
}
public int[] getMembershipPortRange() {
return membershipPortRange;
}
public boolean isConserveSockets() {
return conserveSockets;
}
public String getRoles() {
return roles;
}
public int getMaxWaitTimeForReconnect() {
return maxWaitTimeForReconnect;
}
public int getMaxNumReconnectTries() {
return maxNumReconnectTries;
}
public int getAsyncDistributionTimeout() {
return asyncDistributionTimeout;
}
public int getAsyncQueueTimeout() {
return asyncQueueTimeout;
}
public int getAsyncMaxQueueSize() {
return asyncMaxQueueSize;
}
public String getClientConflation() {
return clientConflation;
}
public String getDurableClientId() {
return durableClientId;
}
public int getDurableClientTimeout() {
return durableClientTimeout;
}
public String getSecurityClientAuthInit() {
return securityClientAuthInit;
}
public String getSecurityClientAuthenticator() {
return securityClientAuthenticator;
}
public String getSecurityClientDHAlgo() {
return securityClientDHAlgo;
}
public String getSecurityPeerAuthInit() {
return securityPeerAuthInit;
}
public String getSecurityPeerAuthenticator() {
return securityPeerAuthenticator;
}
public String getSecurityClientAccessor() {
return securityClientAccessor;
}
public String getSecurityClientAccessorPP() {
return securityClientAccessorPP;
}
public int getSecurityLogLevel() {
return securityLogLevel;
}
public String getSecurityLogFile() {
return securityLogFile;
}
public int getSecurityPeerMembershipTimeout() {
return securityPeerMembershipTimeout;
}
public boolean isRemoveUnresponsiveClient() {
return removeUnresponsiveClient;
}
public boolean isDeltaPropagation() {
return deltaPropagation;
}
public String getRedundancyZone() {
return redundancyZone;
}
public boolean isEnforceUniqueHost() {
return enforceUniqueHost;
}
public int getStatisticSampleRate(){
return statisticSampleRate;
}
public void setMemberName(String memberName) {
this.memberName = memberName;
}
public void setMemberGroups(String memberGroups) {
this.memberGroups = memberGroups;
}
public void setMcastPort(int mcastPort) {
this.mcastPort = mcastPort;
}
public void setMcastAddress(String mcastAddress) {
this.mcastAddress = mcastAddress;
}
public void setBindAddress(String bindAddress) {
this.bindAddress = bindAddress;
}
public void setTcpPort(int tcpPort) {
this.tcpPort = tcpPort;
}
public void setCacheXMLFile(String cacheXMLFile) {
this.cacheXMLFile = cacheXMLFile;
}
public void setConfigFile(String configFile) {
this.configFile = configFile;
}
public void setMcastTTL(int mcastTTL) {
this.mcastTTL = mcastTTL;
}
public void setServerBindAddress(String serverBindAddress) {
this.serverBindAddress = serverBindAddress;
}
public void setLocators(String locators) {
this.locators = locators;
}
public void setStartLocator(String startLocator) {
this.startLocator = startLocator;
}
public void setLogFile(String logFile) {
this.logFile = logFile;
}
public void setLogLevel(int logLevel) {
this.logLevel = logLevel;
}
public void setStatisticSamplingEnabled(boolean statisticSamplingEnabled) {
this.statisticSamplingEnabled = statisticSamplingEnabled;
}
public void setStatisticArchiveFile(String statisticArchiveFile) {
this.statisticArchiveFile = statisticArchiveFile;
}
public void setIncludeFile(String includeFile) {
this.includeFile = includeFile;
}
public void setAckWaitThreshold(int ackWaitThreshold) {
this.ackWaitThreshold = ackWaitThreshold;
}
public void setAckSevereAlertThreshold(int ackSevereAlertThreshold) {
this.ackSevereAlertThreshold = ackSevereAlertThreshold;
}
public void setArchiveFileSizeLimit(int archiveFileSizeLimit) {
this.archiveFileSizeLimit = archiveFileSizeLimit;
}
public void setArchiveDiskSpaceLimit(int archiveDiskSpaceLimit) {
this.archiveDiskSpaceLimit = archiveDiskSpaceLimit;
}
public void setLogFileSizeLimit(int logFileSizeLimit) {
this.logFileSizeLimit = logFileSizeLimit;
}
public void setLogDiskSpaceLimit(int logDiskSpaceLimit) {
this.logDiskSpaceLimit = logDiskSpaceLimit;
}
public void setSslEnabled(boolean sslEnabled) {
this.sslEnabled = sslEnabled;
}
public void setSslCiphers(String sslCiphers) {
this.sslCiphers = sslCiphers;
}
public void setSslProtocols(String sslProtocols) {
this.sslProtocols = sslProtocols;
}
public void setSslRequireAuthentication(boolean sslRequireAuthentication) {
this.sslRequireAuthentication = sslRequireAuthentication;
}
public void setSocketLeaseTime(int socketLeaseTime) {
this.socketLeaseTime = socketLeaseTime;
}
public void setSocketBufferSize(int socketBufferSize) {
this.socketBufferSize = socketBufferSize;
}
public void setMcastSendBufferSize(int mcastSendBufferSize) {
this.mcastSendBufferSize = mcastSendBufferSize;
}
public void setMcastRecvBufferSize(int mcastRecvBufferSize) {
this.mcastRecvBufferSize = mcastRecvBufferSize;
}
public void setMcastByteAllowance(int mcastByteAllowance) {
this.mcastByteAllowance = mcastByteAllowance;
}
public void setMcastRechargeThreshold(float mcastRechargeThreshold) {
this.mcastRechargeThreshold = mcastRechargeThreshold;
}
public void setMcastRechargeBlockMs(int mcastRechargeBlockMs) {
this.mcastRechargeBlockMs = mcastRechargeBlockMs;
}
public void setUdpFragmentSize(int udpFragmentSize) {
this.udpFragmentSize = udpFragmentSize;
}
public void setUdpSendBufferSize(int udpSendBufferSize) {
this.udpSendBufferSize = udpSendBufferSize;
}
public void setUdpRecvBufferSize(int udpRecvBufferSize) {
this.udpRecvBufferSize = udpRecvBufferSize;
}
public void setDisableTcp(boolean disableTcp) {
this.disableTcp = disableTcp;
}
public void setEnableTimeStatistics(boolean enableTimeStatistics) {
this.enableTimeStatistics = enableTimeStatistics;
}
public void setEnableNetworkPartitionDetection(
boolean enableNetworkPartitionDetection) {
this.enableNetworkPartitionDetection = enableNetworkPartitionDetection;
}
public void setDepartureCorrelationWindow(int departureCorrelationWindow) {
this.departureCorrelationWindow = departureCorrelationWindow;
}
public void setMemberTimeout(int memberTimeout) {
this.memberTimeout = memberTimeout;
}
public void setMembershipPortRange(int[] membershipPortRange) {
this.membershipPortRange = membershipPortRange;
}
public void setConserveSockets(boolean conserveSockets) {
this.conserveSockets = conserveSockets;
}
public void setRoles(String roles) {
this.roles = roles;
}
public void setMaxWaitTimeForReconnect(int maxWaitTimeForReconnect) {
this.maxWaitTimeForReconnect = maxWaitTimeForReconnect;
}
public void setMaxNumReconnectTries(int maxNumReconnectTries) {
this.maxNumReconnectTries = maxNumReconnectTries;
}
public void setAsyncDistributionTimeout(int asyncDistributionTimeout) {
this.asyncDistributionTimeout = asyncDistributionTimeout;
}
public void setAsyncQueueTimeout(int asyncQueueTimeout) {
this.asyncQueueTimeout = asyncQueueTimeout;
}
public void setAsyncMaxQueueSize(int asyncMaxQueueSize) {
this.asyncMaxQueueSize = asyncMaxQueueSize;
}
public void setClientConflation(String clientConflation) {
this.clientConflation = clientConflation;
}
public void setDurableClientId(String durableClientId) {
this.durableClientId = durableClientId;
}
public void setDurableClientTimeout(int durableClientTimeout) {
this.durableClientTimeout = durableClientTimeout;
}
public void setSecurityClientAuthInit(String securityClientAuthInit) {
this.securityClientAuthInit = securityClientAuthInit;
}
public void setSecurityClientAuthenticator(String securityClientAuthenticator) {
this.securityClientAuthenticator = securityClientAuthenticator;
}
public void setSecurityClientDHAlgo(String securityClientDHAlgo) {
this.securityClientDHAlgo = securityClientDHAlgo;
}
public void setSecurityPeerAuthInit(String securityPeerAuthInit) {
this.securityPeerAuthInit = securityPeerAuthInit;
}
public void setSecurityPeerAuthenticator(String securityPeerAuthenticator) {
this.securityPeerAuthenticator = securityPeerAuthenticator;
}
public void setSecurityClientAccessor(String securityClientAccessor) {
this.securityClientAccessor = securityClientAccessor;
}
public void setSecurityClientAccessorPP(String securityClientAccessorPP) {
this.securityClientAccessorPP = securityClientAccessorPP;
}
public void setSecurityLogLevel(int securityLogLevel) {
this.securityLogLevel = securityLogLevel;
}
public void setSecurityLogFile(String securityLogFile) {
this.securityLogFile = securityLogFile;
}
public void setSecurityPeerMembershipTimeout(int securityPeerMembershipTimeout) {
this.securityPeerMembershipTimeout = securityPeerMembershipTimeout;
}
public void setRemoveUnresponsiveClient(boolean removeUnresponsiveClient) {
this.removeUnresponsiveClient = removeUnresponsiveClient;
}
public void setDeltaPropagation(boolean deltaPropagation) {
this.deltaPropagation = deltaPropagation;
}
public void setRedundancyZone(String redundancyZone) {
this.redundancyZone = redundancyZone;
}
public void setEnforceUniqueHost(boolean enforceUniqueHost) {
this.enforceUniqueHost = enforceUniqueHost;
}
public void setStatisticSampleRate(int statisticSampleRate) {
this.statisticSampleRate = statisticSampleRate;
}
public boolean isJmxManager() {
return jmxManager;
}
public void setJmxManager(boolean jmxManager) {
this.jmxManager = jmxManager;
}
public boolean isJmxManagerStart() {
return jmxManagerStart;
}
public void setJmxManagerStart(boolean jmxManagerStart) {
this.jmxManagerStart = jmxManagerStart;
}
public boolean isJmxManagerSSL() {
return jmxManagerSSL;
}
public void setJmxManagerSSL(boolean jmxManagerSSL) {
this.jmxManagerSSL = jmxManagerSSL;
}
public int getJmxManagerPort() {
return jmxManagerPort;
}
public void setJmxManagerPort(int jmxManagerPort) {
this.jmxManagerPort = jmxManagerPort;
}
public String getJmxManagerBindAddress() {
return jmxManagerBindAddress;
}
public void setJmxManagerBindAddress(String jmxManagerBindAddress) {
this.jmxManagerBindAddress = jmxManagerBindAddress;
}
public String getJmxManagerHostnameForClients() {
return jmxManagerHostnameForClients;
}
public void setJmxManagerHostnameForClients(String jmxManagerHostnameForClients) {
this.jmxManagerHostnameForClients = jmxManagerHostnameForClients;
}
public String getJmxManagerPasswordFile() {
return jmxManagerPasswordFile;
}
public void setJmxManagerPasswordFile(String jmxManagerPasswordFile) {
this.jmxManagerPasswordFile = jmxManagerPasswordFile;
}
public String getJmxManagerAccessFile() {
return jmxManagerAccessFile;
}
public void setJmxManagerAccessFile(String jmxManagerAccessFile) {
this.jmxManagerAccessFile = jmxManagerAccessFile;
}
public int getJmxManagerHttpPort() {
return jmxManagerHttpPort;
}
public void setJmxManagerHttpPort(int jmxManagerHttpPort) {
this.jmxManagerHttpPort = jmxManagerHttpPort;
}
public int getJmxManagerUpdateRate() {
return jmxManagerUpdateRate;
}
public void setJmxManagerUpdateRate(int jmxManagerUpdateRate) {
this.jmxManagerUpdateRate = jmxManagerUpdateRate;
}
}