| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more contributor license |
| * agreements. See the NOTICE file distributed with this work for additional information regarding |
| * copyright ownership. The ASF licenses this file to You 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.apache.geode.distributed.internal; |
| |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_CIPHERS; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_ENABLED; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_KEYSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_KEYSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_KEYSTORE_TYPE; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_PROTOCOLS; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_REQUIRE_AUTHENTICATION; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_TRUSTSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.CLUSTER_SSL_TRUSTSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_CIPHERS; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_ENABLED; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_KEYSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_KEYSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_KEYSTORE_TYPE; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_PROTOCOLS; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_REQUIRE_AUTHENTICATION; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_TRUSTSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.GATEWAY_SSL_TRUSTSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_CIPHERS; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_ENABLED; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_KEYSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_KEYSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_KEYSTORE_TYPE; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_PROTOCOLS; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_REQUIRE_AUTHENTICATION; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_TRUSTSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.HTTP_SERVICE_SSL_TRUSTSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_CIPHERS; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_ENABLED; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_KEYSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_KEYSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_KEYSTORE_TYPE; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_PROTOCOLS; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_REQUIRE_AUTHENTICATION; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_TRUSTSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.JMX_MANAGER_SSL_TRUSTSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_PEER_AUTHENTICATOR; |
| import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_PEER_AUTH_INIT; |
| import static org.apache.geode.distributed.ConfigurationProperties.SECURITY_UDP_DHALGO; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_CIPHERS; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_ENABLED; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_KEYSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_KEYSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_KEYSTORE_TYPE; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_PROTOCOLS; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_REQUIRE_AUTHENTICATION; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_TRUSTSTORE; |
| import static org.apache.geode.distributed.ConfigurationProperties.SERVER_SSL_TRUSTSTORE_PASSWORD; |
| import static org.apache.geode.distributed.ConfigurationProperties.SSL_ENABLED_COMPONENTS; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.lang.reflect.Method; |
| import java.net.InetAddress; |
| import java.net.URL; |
| import java.net.UnknownHostException; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Set; |
| |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.commons.lang3.builder.EqualsBuilder; |
| import org.apache.commons.lang3.builder.HashCodeBuilder; |
| |
| import org.apache.geode.GemFireConfigException; |
| import org.apache.geode.GemFireIOException; |
| import org.apache.geode.InternalGemFireException; |
| import org.apache.geode.distributed.DistributedSystem; |
| import org.apache.geode.internal.ConfigSource; |
| import org.apache.geode.internal.net.SocketCreator; |
| import org.apache.geode.internal.process.ProcessLauncherContext; |
| import org.apache.geode.internal.security.SecurableCommunicationChannel; |
| |
| /** |
| * Provides an implementation of <code>DistributionConfig</code> that knows how to read the |
| * configuration file. |
| * <p> |
| * Note that if you add a property to this interface, should should update the |
| * {@link #DistributionConfigImpl(DistributionConfig) copy constructor}. |
| * |
| * @see InternalDistributedSystem |
| * @since GemFire 2.1 |
| */ |
| public class DistributionConfigImpl extends AbstractDistributionConfig implements Serializable { |
| |
| private static final long serialVersionUID = 4096393792893825167L; |
| |
| /** |
| * The name of the distribution manager/shared memory connection |
| */ |
| private String name = DEFAULT_NAME; |
| |
| /** |
| * The tcp/ip port used for distribution |
| */ |
| private int tcpPort = DEFAULT_TCP_PORT; |
| |
| /** |
| * The multicast port used for distribution |
| */ |
| private int mcastPort = DEFAULT_MCAST_PORT; |
| |
| /** |
| * The multicast ttl used for distribution |
| */ |
| private int mcastTtl = DEFAULT_MCAST_TTL; |
| |
| private int socketLeaseTime = DEFAULT_SOCKET_LEASE_TIME; |
| private int socketBufferSize = DEFAULT_SOCKET_BUFFER_SIZE; |
| private boolean conserveSockets = DEFAULT_CONSERVE_SOCKETS; |
| |
| /** |
| * Comma-delimited list of the application roles performed by this member. |
| */ |
| private String roles = DEFAULT_ROLES; |
| |
| /** |
| * The multicast address used for distribution |
| */ |
| private InetAddress mcastAddress = DEFAULT_MCAST_ADDRESS; |
| |
| /** |
| * The address server socket's should listen on |
| */ |
| private String bindAddress = DEFAULT_BIND_ADDRESS; |
| |
| /** |
| * The address server socket's in a client-server topology should listen on |
| */ |
| private String serverBindAddress = DEFAULT_SERVER_BIND_ADDRESS; |
| |
| /** |
| * The locations of the distribution locators |
| */ |
| private String locators = DEFAULT_LOCATORS; |
| |
| /** |
| * The amount of time to wait for a locator to appear when starting up |
| */ |
| private int locatorWaitTime; |
| |
| /** |
| * The name of the log file |
| */ |
| private File logFile = DEFAULT_LOG_FILE; |
| |
| private File deployWorkingDir = new File(System.getProperty("user.dir")); |
| |
| /** |
| * The level at which log messages are logged |
| * |
| * @see LogWriterImpl#levelNameToCode(String) |
| */ |
| protected int logLevel = DEFAULT_LOG_LEVEL; |
| |
| /** |
| * bind-address and host of locator to start |
| */ |
| private String startLocator = DEFAULT_START_LOCATOR; |
| |
| /** |
| * port of locator to start. use bind-address as host name |
| */ |
| private int startLocatorPort; |
| |
| /** |
| * Is statistic sampling enabled? |
| */ |
| protected boolean statisticSamplingEnabled = DEFAULT_STATISTIC_SAMPLING_ENABLED; |
| |
| /** |
| * The rate (in milliseconds) at which statistics are sampled |
| */ |
| protected int statisticSampleRate = DEFAULT_STATISTIC_SAMPLE_RATE; |
| |
| /** |
| * The name of the file to which statistics should be archived |
| */ |
| File statisticArchiveFile = DEFAULT_STATISTIC_ARCHIVE_FILE; |
| |
| /** |
| * The amount of time to wait for a ACK message |
| */ |
| private int ackWaitThreshold = DEFAULT_ACK_WAIT_THRESHOLD; |
| |
| /** |
| * The amount of time to wait for a ACK message after the ackWaitThreshold before shunning members |
| * that haven't responded. If zero, this feature is disabled. |
| */ |
| private int ackForceDisconnectThreshold = DEFAULT_ACK_SEVERE_ALERT_THRESHOLD; |
| |
| /** |
| * The name of an XML file used to initialize the cache |
| */ |
| private File cacheXmlFile = Boolean.getBoolean(InternalLocator.FORCE_LOCATOR_DM_TYPE) |
| ? new File("") : DEFAULT_CACHE_XML_FILE; |
| |
| protected int archiveDiskSpaceLimit = DEFAULT_ARCHIVE_DISK_SPACE_LIMIT; |
| protected int archiveFileSizeLimit = DEFAULT_ARCHIVE_FILE_SIZE_LIMIT; |
| protected int logDiskSpaceLimit = DEFAULT_LOG_DISK_SPACE_LIMIT; |
| protected int logFileSizeLimit = DEFAULT_LOG_FILE_SIZE_LIMIT; |
| |
| @Deprecated |
| private boolean clusterSSLEnabled = DEFAULT_SSL_ENABLED; |
| @Deprecated |
| private String clusterSSLProtocols = DEFAULT_SSL_PROTOCOLS; |
| @Deprecated |
| private String clusterSSLCiphers = DEFAULT_SSL_CIPHERS; |
| @Deprecated |
| private boolean clusterSSLRequireAuthentication = DEFAULT_SSL_REQUIRE_AUTHENTICATION; |
| @Deprecated |
| private String clusterSSLKeyStore = DEFAULT_SSL_KEYSTORE; |
| @Deprecated |
| private String clusterSSLKeyStoreType = DEFAULT_CLUSTER_SSL_KEYSTORE_TYPE; |
| @Deprecated |
| private String clusterSSLKeyStorePassword = DEFAULT_SSL_KEYSTORE_PASSWORD; |
| @Deprecated |
| private String clusterSSLTrustStore = DEFAULT_SSL_TRUSTSTORE; |
| @Deprecated |
| private String clusterSSLTrustStorePassword = DEFAULT_SSL_TRUSTSTORE_PASSWORD; |
| |
| private String clusterSSLAlias = DEFAULT_SSL_ALIAS; |
| |
| /** |
| * multicast send buffer size, in bytes |
| */ |
| private int mcastSendBufferSize = DEFAULT_MCAST_SEND_BUFFER_SIZE; |
| /** |
| * multicast receive buffer size, in bytes |
| */ |
| private int mcastRecvBufferSize = DEFAULT_MCAST_RECV_BUFFER_SIZE; |
| /** |
| * flow-of-control parameters for multicast messaging |
| */ |
| private FlowControlParams mcastFlowControl = DEFAULT_MCAST_FLOW_CONTROL; |
| |
| /** |
| * datagram socket send buffer size, in bytes |
| */ |
| private int udpSendBufferSize = DEFAULT_UDP_SEND_BUFFER_SIZE; |
| /** |
| * datagram socket receive buffer size, in bytes |
| */ |
| private int udpRecvBufferSize = DEFAULT_UDP_RECV_BUFFER_SIZE; |
| /** |
| * max datagram message size, in bytes. This should be < 64k |
| */ |
| private int udpFragmentSize = DEFAULT_UDP_FRAGMENT_SIZE; |
| |
| /** |
| * whether tcp/ip sockets should be disabled |
| */ |
| protected boolean disableTcp = DEFAULT_DISABLE_TCP; |
| |
| /** |
| * whether JMX should be disabled |
| */ |
| protected boolean disableJmx = DEFAULT_DISABLE_JMX; |
| |
| /** |
| * whether time statistics should be enabled for the distributed system |
| */ |
| protected boolean enableTimeStatistics = DEFAULT_ENABLE_TIME_STATISTICS; |
| |
| /** |
| * member contact timeout, in milliseconds, for failure detection |
| */ |
| protected int memberTimeout = DEFAULT_MEMBER_TIMEOUT; |
| |
| /** |
| * the Jgroups port ranges allowed |
| */ |
| private int[] membershipPortRange = DEFAULT_MEMBERSHIP_PORT_RANGE; |
| |
| /** |
| * Max wait time for the member before reconnecting to the DS in case of required role loss. |
| */ |
| private int maxWaitTimeForReconnect = DEFAULT_MAX_WAIT_TIME_FOR_RECONNECT; |
| /** |
| * Max number of tries allowed for reconnect in case of required role loss. |
| */ |
| private int maxNumReconnectTries = DEFAULT_MAX_NUM_RECONNECT_TRIES; |
| |
| private int asyncDistributionTimeout = DEFAULT_ASYNC_DISTRIBUTION_TIMEOUT; |
| private int asyncQueueTimeout = DEFAULT_ASYNC_QUEUE_TIMEOUT; |
| private int asyncMaxQueueSize = DEFAULT_ASYNC_MAX_QUEUE_SIZE; |
| |
| /** |
| * @since GemFire 5.7 |
| */ |
| private String clientConflation = CLIENT_CONFLATION_PROP_VALUE_DEFAULT; |
| |
| /** |
| * The id of the durable client |
| */ |
| private String durableClientId = DEFAULT_DURABLE_CLIENT_ID; |
| |
| /** |
| * The timeout of the durable client |
| */ |
| private int durableClientTimeout = DEFAULT_DURABLE_CLIENT_TIMEOUT; |
| |
| /** |
| * The client authentication initialization method name |
| */ |
| private String securityClientAuthInit = DEFAULT_SECURITY_CLIENT_AUTH_INIT; |
| |
| /** |
| * The client authenticating method name |
| */ |
| private String securityClientAuthenticator = DEFAULT_SECURITY_CLIENT_AUTHENTICATOR; |
| |
| /** |
| * The security manager class name |
| */ |
| private String securityManager = DEFAULT_SECURITY_MANAGER; |
| |
| /** |
| * The post processor class name |
| */ |
| private String postProcessor = DEFAULT_SECURITY_POST_PROCESSOR; |
| |
| /** |
| * The client Diffie-Hellman method name |
| */ |
| private String securityClientDHAlgo = DEFAULT_SECURITY_CLIENT_DHALGO; |
| |
| /** |
| * The udp Diffie-Hellman method name |
| */ |
| private String securityUDPDHAlgo = DEFAULT_SECURITY_UDP_DHALGO; |
| |
| /** |
| * The peer authentication initialization method name |
| */ |
| private String securityPeerAuthInit = DEFAULT_SECURITY_PEER_AUTH_INIT; |
| |
| /** |
| * The peer authenticating method name |
| */ |
| private String securityPeerAuthenticator = DEFAULT_SECURITY_PEER_AUTHENTICATOR; |
| |
| /** |
| * The client authorization method name |
| */ |
| private String securityClientAccessor = DEFAULT_SECURITY_CLIENT_ACCESSOR; |
| |
| /** |
| * The post-processing client authorization method name |
| */ |
| private String securityClientAccessorPP = DEFAULT_SECURITY_CLIENT_ACCESSOR_PP; |
| |
| /** |
| * The level at which security related log messages are logged |
| * |
| * @see LogWriterImpl#levelNameToCode(String) |
| */ |
| private int securityLogLevel = DEFAULT_LOG_LEVEL; |
| |
| /** |
| * whether network partition detection algorithms are enabled |
| */ |
| private boolean enableNetworkPartitionDetection = DEFAULT_ENABLE_NETWORK_PARTITION_DETECTION; |
| |
| /** |
| * whether auto reconnect after network partition is disabled |
| */ |
| private boolean disableAutoReconnect = DEFAULT_DISABLE_AUTO_RECONNECT; |
| |
| /** |
| * The security log file |
| */ |
| private File securityLogFile = DEFAULT_SECURITY_LOG_FILE; |
| |
| /** |
| * The p2p membership check timeout |
| */ |
| private int securityPeerMembershipTimeout = DEFAULT_SECURITY_PEER_VERIFYMEMBER_TIMEOUT; |
| |
| /** |
| * The member security credentials |
| */ |
| private final Properties security = new Properties(); |
| |
| /** |
| * The User defined properties to be used for cache.xml replacements |
| */ |
| private final Properties userDefinedProps = new Properties(); |
| /** |
| * Prefix to use for properties that are put as JVM java properties for use with layers (e.g. |
| * jgroups membership) that do not have a <code>DistributionConfig</code> object. |
| */ |
| public static final String SECURITY_SYSTEM_PREFIX = GEMFIRE_PREFIX + "sys."; |
| |
| /** |
| * whether to remove unresponsive client or not |
| */ |
| private boolean removeUnresponsiveClient = DEFAULT_REMOVE_UNRESPONSIVE_CLIENT; |
| |
| /** |
| * Is delta propagation enabled or not |
| **/ |
| private boolean deltaPropagation = DEFAULT_DELTA_PROPAGATION; |
| |
| private Map props; |
| |
| private int distributedSystemId = DistributionConfig.DEFAULT_DISTRIBUTED_SYSTEM_ID; |
| |
| /** |
| * The locations of the remote distribution locators |
| */ |
| private String remoteLocators = DEFAULT_REMOTE_LOCATORS; |
| |
| private boolean enforceUniqueHost = DistributionConfig.DEFAULT_ENFORCE_UNIQUE_HOST; |
| |
| private String redundancyZone = DistributionConfig.DEFAULT_REDUNDANCY_ZONE; |
| |
| /** |
| * holds the ssl properties specified in gfsecurity.properties |
| */ |
| private Properties sslProperties = new Properties(); |
| |
| /** |
| * holds the ssl properties specified in gfsecurity.properties |
| */ |
| private Properties clusterSSLProperties = new Properties(); |
| |
| private String groups = DEFAULT_GROUPS; |
| |
| private boolean enableSharedConfiguration = |
| DistributionConfig.DEFAULT_ENABLE_CLUSTER_CONFIGURATION; |
| private boolean enableManagementRestService = |
| DistributionConfig.DEFAULT_ENABLE_MANAGEMENT_REST_SERVICE; |
| private boolean useSharedConfiguration = DistributionConfig.DEFAULT_USE_CLUSTER_CONFIGURATION; |
| private boolean loadSharedConfigurationFromDir = |
| DistributionConfig.DEFAULT_LOAD_CLUSTER_CONFIG_FROM_DIR; |
| private String clusterConfigDir = ""; |
| |
| |
| private int httpServicePort = DEFAULT_HTTP_SERVICE_PORT; |
| |
| private String httpServiceBindAddress = DEFAULT_HTTP_SERVICE_BIND_ADDRESS; |
| |
| private boolean startDevRestApi = DEFAULT_START_DEV_REST_API; |
| |
| /** |
| * port on which {@link GemFireMemcachedServer} server is started |
| */ |
| private int memcachedPort; |
| |
| /** |
| * protocol for GemFireMemcachedServer |
| */ |
| private String memcachedProtocol = DEFAULT_MEMCACHED_PROTOCOL; |
| |
| /** |
| * Bind address for GemFireMemcachedServer |
| */ |
| private String memcachedBindAddress = DEFAULT_MEMCACHED_BIND_ADDRESS; |
| |
| /** |
| * Are distributed transactions enabled or not |
| */ |
| private boolean distributedTransactions = DEFAULT_DISTRIBUTED_TRANSACTIONS; |
| |
| /** |
| * port on which {@link GeodeRedisServer} is started |
| */ |
| private int redisPort = DEFAULT_REDIS_PORT; |
| |
| /** |
| * Bind address for GeodeRedisServer |
| */ |
| private String redisBindAddress = DEFAULT_REDIS_BIND_ADDRESS; |
| |
| private String redisPassword = DEFAULT_REDIS_PASSWORD; |
| |
| private boolean jmxManager = |
| Boolean.getBoolean(InternalLocator.FORCE_LOCATOR_DM_TYPE) || DEFAULT_JMX_MANAGER; |
| private boolean jmxManagerStart = DEFAULT_JMX_MANAGER_START; |
| private int jmxManagerPort = DEFAULT_JMX_MANAGER_PORT; |
| private String jmxManagerBindAddress = DEFAULT_JMX_MANAGER_BIND_ADDRESS; |
| private String jmxManagerHostnameForClients = DEFAULT_JMX_MANAGER_HOSTNAME_FOR_CLIENTS; |
| private String jmxManagerPasswordFile = DEFAULT_JMX_MANAGER_PASSWORD_FILE; |
| private String jmxManagerAccessFile = DEFAULT_JMX_MANAGER_ACCESS_FILE; |
| private int jmxManagerHttpPort = DEFAULT_HTTP_SERVICE_PORT; |
| private int jmxManagerUpdateRate = DEFAULT_JMX_MANAGER_UPDATE_RATE; |
| |
| @Deprecated |
| private boolean jmxManagerSSLEnabled = DEFAULT_JMX_MANAGER_SSL_ENABLED; |
| @Deprecated |
| private boolean jmxManagerSslRequireAuthentication = |
| DEFAULT_JMX_MANAGER_SSL_REQUIRE_AUTHENTICATION; |
| @Deprecated |
| private String jmxManagerSslProtocols = DEFAULT_JMX_MANAGER_SSL_PROTOCOLS; |
| @Deprecated |
| private String jmxManagerSslCiphers = DEFAULT_JMX_MANAGER_SSL_CIPHERS; |
| @Deprecated |
| private Properties jmxManagerSslProperties = new Properties(); |
| @Deprecated |
| private String jmxManagerSSLKeyStore = DEFAULT_JMX_MANAGER_SSL_KEYSTORE; |
| @Deprecated |
| private String jmxManagerSSLKeyStoreType = DEFAULT_JMX_MANAGER_SSL_KEYSTORE_TYPE; |
| @Deprecated |
| private String jmxManagerSSLKeyStorePassword = DEFAULT_JMX_MANAGER_SSL_KEYSTORE_PASSWORD; |
| @Deprecated |
| private String jmxManagerSSLTrustStore = DEFAULT_JMX_MANAGER_SSL_TRUSTSTORE; |
| @Deprecated |
| private String jmxManagerSSLTrustStorePassword = DEFAULT_JMX_MANAGER_SSL_TRUSTSTORE_PASSWORD; |
| |
| private String jmxManagerSSLAlias = DEFAULT_SSL_ALIAS; |
| |
| @Deprecated |
| private boolean serverSSLEnabled = DEFAULT_SERVER_SSL_ENABLED; |
| @Deprecated |
| private boolean serverSslRequireAuthentication = DEFAULT_SERVER_SSL_REQUIRE_AUTHENTICATION; |
| @Deprecated |
| private String serverSslProtocols = DEFAULT_SERVER_SSL_PROTOCOLS; |
| @Deprecated |
| private String serverSslCiphers = DEFAULT_SERVER_SSL_CIPHERS; |
| @Deprecated |
| private Properties serverSslProperties = new Properties(); |
| @Deprecated |
| private String serverSSLKeyStore = DEFAULT_SERVER_SSL_KEYSTORE; |
| @Deprecated |
| private String serverSSLKeyStoreType = DEFAULT_SERVER_SSL_KEYSTORE_TYPE; |
| @Deprecated |
| private String serverSSLKeyStorePassword = DEFAULT_SERVER_SSL_KEYSTORE_PASSWORD; |
| @Deprecated |
| private String serverSSLTrustStore = DEFAULT_SERVER_SSL_TRUSTSTORE; |
| @Deprecated |
| private String serverSSLTrustStorePassword = DEFAULT_SERVER_SSL_TRUSTSTORE_PASSWORD; |
| |
| private String serverSSLAlias = DEFAULT_SSL_ALIAS; |
| |
| @Deprecated |
| private boolean gatewaySSLEnabled = DEFAULT_GATEWAY_SSL_ENABLED; |
| @Deprecated |
| private boolean gatewaySslRequireAuthentication = DEFAULT_GATEWAY_SSL_REQUIRE_AUTHENTICATION; |
| @Deprecated |
| private String gatewaySslProtocols = DEFAULT_GATEWAY_SSL_PROTOCOLS; |
| @Deprecated |
| private String gatewaySslCiphers = DEFAULT_GATEWAY_SSL_CIPHERS; |
| @Deprecated |
| private Properties gatewaySslProperties = new Properties(); |
| @Deprecated |
| private String gatewaySSLKeyStore = DEFAULT_GATEWAY_SSL_KEYSTORE; |
| @Deprecated |
| private String gatewaySSLKeyStoreType = DEFAULT_GATEWAY_SSL_KEYSTORE_TYPE; |
| @Deprecated |
| private String gatewaySSLKeyStorePassword = DEFAULT_GATEWAY_SSL_KEYSTORE_PASSWORD; |
| @Deprecated |
| private String gatewaySSLTrustStore = DEFAULT_GATEWAY_SSL_TRUSTSTORE; |
| @Deprecated |
| private String gatewaySSLTrustStorePassword = DEFAULT_GATEWAY_SSL_TRUSTSTORE_PASSWORD; |
| |
| private String gatewaySSLAlias = DEFAULT_SSL_ALIAS; |
| |
| @Deprecated |
| private boolean httpServiceSSLEnabled = DEFAULT_HTTP_SERVICE_SSL_ENABLED; |
| @Deprecated |
| private boolean httpServiceSSLRequireAuthentication = |
| DEFAULT_HTTP_SERVICE_SSL_REQUIRE_AUTHENTICATION; |
| @Deprecated |
| private String httpServiceSSLProtocols = DEFAULT_HTTP_SERVICE_SSL_PROTOCOLS; |
| @Deprecated |
| private String httpServiceSSLCiphers = DEFAULT_HTTP_SERVICE_SSL_CIPHERS; |
| @Deprecated |
| private Properties httpServiceSSLProperties = new Properties(); |
| @Deprecated |
| private String httpServiceSSLKeyStore = DEFAULT_HTTP_SERVICE_SSL_KEYSTORE; |
| @Deprecated |
| private String httpServiceSSLKeyStoreType = DEFAULT_HTTP_SERVICE_SSL_KEYSTORE_TYPE; |
| @Deprecated |
| private String httpServiceSSLKeyStorePassword = DEFAULT_HTTP_SERVICE_SSL_KEYSTORE_PASSWORD; |
| @Deprecated |
| private String httpServiceSSLTrustStore = DEFAULT_HTTP_SERVICE_SSL_TRUSTSTORE; |
| @Deprecated |
| private String httpServiceSSLTrustStorePassword = DEFAULT_HTTP_SERVICE_SSL_TRUSTSTORE_PASSWORD; |
| |
| private String httpServiceSSLAlias = DEFAULT_SSL_ALIAS; |
| |
| private Boolean sslEndPointIdentificationEnabled = null; |
| |
| private SecurableCommunicationChannel[] securableCommunicationChannels = |
| DEFAULT_SSL_ENABLED_COMPONENTS; |
| |
| private boolean sslUseDefaultSSLContext = DEFAULT_SSL_USE_DEFAULT_CONTEXT; |
| private String sslProtocols = DEFAULT_SSL_PROTOCOLS; |
| private String sslCiphers = DEFAULT_SSL_CIPHERS; |
| private boolean sslRequireAuthentication = DEFAULT_SSL_REQUIRE_AUTHENTICATION; |
| private String sslKeyStore = DEFAULT_SSL_KEYSTORE; |
| private String sslKeyStoreType = DEFAULT_CLUSTER_SSL_KEYSTORE_TYPE; |
| private String sslKeyStorePassword = DEFAULT_SSL_KEYSTORE_PASSWORD; |
| private String sslTrustStore = DEFAULT_SSL_TRUSTSTORE; |
| private String sslTrustStorePassword = DEFAULT_SSL_TRUSTSTORE_PASSWORD; |
| private String sslTrustStoreType = DEFAULT_CLUSTER_SSL_KEYSTORE_TYPE; |
| private boolean sslWebServiceRequireAuthentication = |
| DEFAULT_SSL_WEB_SERVICE_REQUIRE_AUTHENTICATION; |
| |
| private String locatorSSLAlias = DEFAULT_SSL_ALIAS; |
| |
| private String sslDefaultAlias = DEFAULT_SSL_ALIAS; |
| |
| private Map<String, ConfigSource> sourceMap = |
| Collections.synchronizedMap(new HashMap<>()); |
| |
| private String userCommandPackages = DEFAULT_USER_COMMAND_PACKAGES; |
| |
| private boolean validateSerializableObjects = DEFAULT_VALIDATE_SERIALIZABLE_OBJECTS; |
| private String serializableObjectFilter = DEFAULT_SERIALIZABLE_OBJECT_FILTER; |
| |
| /** |
| * "off-heap-memory-size" with value of "" or "<size>[g|m]" |
| */ |
| protected String offHeapMemorySize = DEFAULT_OFF_HEAP_MEMORY_SIZE; |
| |
| /** |
| * Whether pages should be locked into memory or allowed to swap to disk |
| */ |
| private boolean lockMemory = DEFAULT_LOCK_MEMORY; |
| |
| private String shiroInit = ""; |
| |
| /** |
| * Is thread monitoring enabled |
| */ |
| private boolean threadMonitorEnabled = DEFAULT_THREAD_MONITOR_ENABLED; |
| |
| /** |
| * the thread monitoring interval |
| */ |
| private int threadMonitorInterval = DEFAULT_THREAD_MONITOR_INTERVAL; |
| |
| /** |
| * the thread monitoring time limit after which the monitored thread is considered stuck |
| */ |
| private int threadMonitorTimeLimit = DEFAULT_THREAD_MONITOR_TIME_LIMIT; |
| |
| /** |
| * Create a new <code>DistributionConfigImpl</code> from the contents of another |
| * <code>DistributionConfig</code>. |
| */ |
| public DistributionConfigImpl(DistributionConfig other) { |
| name = other.getName(); |
| tcpPort = other.getTcpPort(); |
| mcastPort = other.getMcastPort(); |
| mcastTtl = other.getMcastTtl(); |
| socketLeaseTime = other.getSocketLeaseTime(); |
| socketBufferSize = other.getSocketBufferSize(); |
| conserveSockets = other.getConserveSockets(); |
| roles = other.getRoles(); |
| mcastAddress = other.getMcastAddress(); |
| bindAddress = other.getBindAddress(); |
| serverBindAddress = other.getServerBindAddress(); |
| locators = ((DistributionConfigImpl) other).locators; |
| locatorWaitTime = other.getLocatorWaitTime(); |
| remoteLocators = other.getRemoteLocators(); |
| startLocator = other.getStartLocator(); |
| startLocatorPort = ((DistributionConfigImpl) other).startLocatorPort; |
| deployWorkingDir = other.getDeployWorkingDir(); |
| logFile = other.getLogFile(); |
| logLevel = other.getLogLevel(); |
| statisticSamplingEnabled = other.getStatisticSamplingEnabled(); |
| threadMonitorEnabled = other.getThreadMonitorEnabled(); |
| threadMonitorInterval = other.getThreadMonitorInterval(); |
| threadMonitorTimeLimit = other.getThreadMonitorTimeLimit(); |
| statisticSampleRate = other.getStatisticSampleRate(); |
| statisticArchiveFile = other.getStatisticArchiveFile(); |
| ackWaitThreshold = other.getAckWaitThreshold(); |
| ackForceDisconnectThreshold = other.getAckSevereAlertThreshold(); |
| cacheXmlFile = other.getCacheXmlFile(); |
| archiveDiskSpaceLimit = other.getArchiveDiskSpaceLimit(); |
| archiveFileSizeLimit = other.getArchiveFileSizeLimit(); |
| logDiskSpaceLimit = other.getLogDiskSpaceLimit(); |
| logFileSizeLimit = other.getLogFileSizeLimit(); |
| clusterSSLEnabled = other.getClusterSSLEnabled(); |
| clusterSSLProtocols = other.getClusterSSLProtocols(); |
| clusterSSLCiphers = other.getClusterSSLCiphers(); |
| clusterSSLRequireAuthentication = other.getClusterSSLRequireAuthentication(); |
| clusterSSLKeyStore = other.getClusterSSLKeyStore(); |
| clusterSSLKeyStoreType = other.getClusterSSLKeyStoreType(); |
| clusterSSLKeyStorePassword = other.getClusterSSLKeyStorePassword(); |
| clusterSSLTrustStore = other.getClusterSSLTrustStore(); |
| clusterSSLTrustStorePassword = other.getClusterSSLTrustStorePassword(); |
| asyncDistributionTimeout = other.getAsyncDistributionTimeout(); |
| asyncQueueTimeout = other.getAsyncQueueTimeout(); |
| asyncMaxQueueSize = other.getAsyncMaxQueueSize(); |
| modifiable = true; |
| // the following were added after version 4.1.2 |
| mcastSendBufferSize = other.getMcastSendBufferSize(); |
| mcastRecvBufferSize = other.getMcastRecvBufferSize(); |
| mcastFlowControl = other.getMcastFlowControl(); |
| udpSendBufferSize = other.getUdpSendBufferSize(); |
| udpRecvBufferSize = other.getUdpRecvBufferSize(); |
| udpFragmentSize = other.getUdpFragmentSize(); |
| disableTcp = other.getDisableTcp(); |
| disableJmx = other.getDisableJmx(); |
| enableTimeStatistics = other.getEnableTimeStatistics(); |
| memberTimeout = other.getMemberTimeout(); |
| membershipPortRange = other.getMembershipPortRange(); |
| maxWaitTimeForReconnect = other.getMaxWaitTimeForReconnect(); |
| maxNumReconnectTries = other.getMaxNumReconnectTries(); |
| clientConflation = other.getClientConflation(); |
| durableClientId = other.getDurableClientId(); |
| durableClientTimeout = other.getDurableClientTimeout(); |
| |
| enableNetworkPartitionDetection = other.getEnableNetworkPartitionDetection(); |
| disableAutoReconnect = other.getDisableAutoReconnect(); |
| |
| securityClientAuthInit = other.getSecurityClientAuthInit(); |
| securityClientAuthenticator = other.getSecurityClientAuthenticator(); |
| securityClientDHAlgo = other.getSecurityClientDHAlgo(); |
| securityUDPDHAlgo = other.getSecurityUDPDHAlgo(); |
| securityPeerAuthInit = other.getSecurityPeerAuthInit(); |
| securityPeerAuthenticator = other.getSecurityPeerAuthenticator(); |
| securityClientAccessor = other.getSecurityClientAccessor(); |
| securityClientAccessorPP = other.getSecurityClientAccessorPP(); |
| securityPeerMembershipTimeout = other.getSecurityPeerMembershipTimeout(); |
| securityLogLevel = other.getSecurityLogLevel(); |
| securityLogFile = other.getSecurityLogFile(); |
| security.putAll(other.getSecurityProps()); |
| removeUnresponsiveClient = other.getRemoveUnresponsiveClient(); |
| deltaPropagation = other.getDeltaPropagation(); |
| distributedSystemId = other.getDistributedSystemId(); |
| redundancyZone = other.getRedundancyZone(); |
| enforceUniqueHost = other.getEnforceUniqueHost(); |
| sslProperties = other.getSSLProperties(); |
| clusterSSLProperties = other.getClusterSSLProperties(); |
| jmxManagerSslProperties = other.getJmxSSLProperties(); |
| // Similar to this.security, assigning userDefinedProps |
| userDefinedProps.putAll(other.getUserDefinedProps()); |
| |
| // following added for 7.0 |
| groups = other.getGroups(); |
| jmxManager = other.getJmxManager(); |
| jmxManagerStart = other.getJmxManagerStart(); |
| jmxManagerSSLEnabled = other.getJmxManagerSSLEnabled(); |
| jmxManagerSslRequireAuthentication = other.getJmxManagerSSLRequireAuthentication(); |
| jmxManagerSslProtocols = other.getJmxManagerSSLProtocols(); |
| jmxManagerSslCiphers = other.getJmxManagerSSLCiphers(); |
| jmxManagerSSLKeyStore = other.getJmxManagerSSLKeyStore(); |
| jmxManagerSSLKeyStoreType = other.getJmxManagerSSLKeyStoreType(); |
| jmxManagerSSLKeyStorePassword = other.getJmxManagerSSLKeyStorePassword(); |
| jmxManagerSSLTrustStore = other.getJmxManagerSSLTrustStore(); |
| jmxManagerSSLTrustStorePassword = other.getJmxManagerSSLTrustStorePassword(); |
| jmxManagerSslProperties = other.getJmxSSLProperties(); |
| jmxManagerPort = other.getJmxManagerPort(); |
| jmxManagerBindAddress = other.getJmxManagerBindAddress(); |
| jmxManagerHostnameForClients = other.getJmxManagerHostnameForClients(); |
| jmxManagerPasswordFile = other.getJmxManagerPasswordFile(); |
| jmxManagerAccessFile = other.getJmxManagerAccessFile(); |
| jmxManagerHttpPort = other.getJmxManagerHttpPort(); |
| jmxManagerUpdateRate = other.getJmxManagerUpdateRate(); |
| memcachedPort = other.getMemcachedPort(); |
| memcachedProtocol = other.getMemcachedProtocol(); |
| memcachedBindAddress = other.getMemcachedBindAddress(); |
| redisPort = other.getRedisPort(); |
| redisBindAddress = other.getRedisBindAddress(); |
| redisPassword = other.getRedisPassword(); |
| userCommandPackages = other.getUserCommandPackages(); |
| |
| // following added for 8.0 |
| enableSharedConfiguration = other.getEnableClusterConfiguration(); |
| loadSharedConfigurationFromDir = other.getLoadClusterConfigFromDir(); |
| clusterConfigDir = other.getClusterConfigDir(); |
| useSharedConfiguration = other.getUseSharedConfiguration(); |
| serverSSLEnabled = other.getServerSSLEnabled(); |
| serverSslRequireAuthentication = other.getServerSSLRequireAuthentication(); |
| serverSslProtocols = other.getServerSSLProtocols(); |
| serverSslCiphers = other.getServerSSLCiphers(); |
| serverSSLKeyStore = other.getServerSSLKeyStore(); |
| serverSSLKeyStoreType = other.getServerSSLKeyStoreType(); |
| serverSSLKeyStorePassword = other.getServerSSLKeyStorePassword(); |
| serverSSLTrustStore = other.getServerSSLTrustStore(); |
| serverSSLTrustStorePassword = other.getServerSSLTrustStorePassword(); |
| serverSslProperties = other.getServerSSLProperties(); |
| |
| gatewaySSLEnabled = other.getGatewaySSLEnabled(); |
| gatewaySslRequireAuthentication = other.getGatewaySSLRequireAuthentication(); |
| gatewaySslProtocols = other.getGatewaySSLProtocols(); |
| gatewaySslCiphers = other.getGatewaySSLCiphers(); |
| gatewaySSLKeyStore = other.getGatewaySSLKeyStore(); |
| gatewaySSLKeyStoreType = other.getGatewaySSLKeyStoreType(); |
| gatewaySSLKeyStorePassword = other.getGatewaySSLKeyStorePassword(); |
| gatewaySSLTrustStore = other.getGatewaySSLTrustStore(); |
| gatewaySSLTrustStorePassword = other.getGatewaySSLTrustStorePassword(); |
| gatewaySslProperties = other.getGatewaySSLProperties(); |
| |
| httpServicePort = other.getHttpServicePort(); |
| httpServiceBindAddress = other.getHttpServiceBindAddress(); |
| |
| httpServiceSSLEnabled = other.getHttpServiceSSLEnabled(); |
| httpServiceSSLCiphers = other.getHttpServiceSSLCiphers(); |
| httpServiceSSLProtocols = other.getHttpServiceSSLProtocols(); |
| httpServiceSSLRequireAuthentication = other.getHttpServiceSSLRequireAuthentication(); |
| httpServiceSSLKeyStore = other.getHttpServiceSSLKeyStore(); |
| httpServiceSSLKeyStorePassword = other.getHttpServiceSSLKeyStorePassword(); |
| httpServiceSSLKeyStoreType = other.getHttpServiceSSLKeyStoreType(); |
| httpServiceSSLTrustStore = other.getHttpServiceSSLTrustStore(); |
| httpServiceSSLTrustStorePassword = other.getHttpServiceSSLTrustStorePassword(); |
| httpServiceSSLProperties = other.getHttpServiceSSLProperties(); |
| |
| startDevRestApi = other.getStartDevRestApi(); |
| |
| // following added for 9.0 |
| offHeapMemorySize = other.getOffHeapMemorySize(); |
| |
| Map<String, ConfigSource> otherSources = ((DistributionConfigImpl) other).sourceMap; |
| if (otherSources != null) { |
| sourceMap = new HashMap<>(otherSources); |
| } |
| |
| lockMemory = other.getLockMemory(); |
| distributedTransactions = other.getDistributedTransactions(); |
| shiroInit = other.getShiroInit(); |
| securityManager = other.getSecurityManager(); |
| postProcessor = other.getPostProcessor(); |
| |
| clusterSSLAlias = other.getClusterSSLAlias(); |
| gatewaySSLAlias = other.getGatewaySSLAlias(); |
| httpServiceSSLAlias = other.getHTTPServiceSSLAlias(); |
| jmxManagerSSLAlias = other.getJMXSSLAlias(); |
| serverSSLAlias = other.getServerSSLAlias(); |
| locatorSSLAlias = other.getLocatorSSLAlias(); |
| |
| this.sslEndPointIdentificationEnabled = other.getSSLEndPointIdentificationEnabled(); |
| this.securableCommunicationChannels = |
| ((DistributionConfigImpl) other).securableCommunicationChannels; |
| |
| this.sslUseDefaultSSLContext = other.getSSLUseDefaultContext(); |
| this.sslCiphers = other.getSSLCiphers(); |
| this.sslProtocols = other.getSSLProtocols(); |
| this.sslRequireAuthentication = other.getSSLRequireAuthentication(); |
| this.sslKeyStore = other.getSSLKeyStore(); |
| this.sslKeyStorePassword = other.getSSLKeyStorePassword(); |
| this.sslKeyStoreType = other.getSSLKeyStoreType(); |
| this.sslTrustStore = other.getSSLTrustStore(); |
| this.sslTrustStorePassword = other.getSSLTrustStorePassword(); |
| this.sslTrustStoreType = other.getSSLTrustStoreType(); |
| this.sslProperties = other.getSSLProperties(); |
| this.sslDefaultAlias = other.getSSLDefaultAlias(); |
| this.sslWebServiceRequireAuthentication = other.getSSLWebRequireAuthentication(); |
| |
| validateSerializableObjects = other.getValidateSerializableObjects(); |
| serializableObjectFilter = other.getSerializableObjectFilter(); |
| |
| // following added for 9.9 |
| enableManagementRestService = other.getEnableManagementRestService(); |
| } |
| |
| /** |
| * Set to true to make attributes writable. Set to false to make attributes read only. By default |
| * they are read only. |
| */ |
| protected boolean modifiable; |
| |
| @Override |
| protected boolean _modifiableDefault() { |
| return modifiable; |
| } |
| |
| /** |
| * Creates a default application config. Does not read any properties. Currently only used by |
| * DistributionConfigImpl.main. |
| */ |
| private DistributionConfigImpl() { |
| // do nothing. We just want a default config |
| } |
| |
| /** |
| * Creates a new <code>DistributionConfigImpl</code> with the given non-default configuration |
| * properties. See {@link DistributedSystem#connect} for a list of |
| * exceptions that may be thrown. |
| * |
| * @param nonDefault The configuration properties specified by the caller |
| */ |
| public DistributionConfigImpl(Properties nonDefault) { |
| this(nonDefault, false, false); |
| } |
| |
| /** |
| * Creates a new <code>DistributionConfigImpl</code> with the given non-default configuration |
| * properties. See {@link DistributedSystem#connect} for a list of |
| * exceptions that may be thrown. |
| * |
| * @param nonDefault The configuration properties specified by the caller |
| * @param ignoreGemFirePropsFile whether to skip loading distributed system properties from |
| * gemfire.properties file |
| * |
| * @since GemFire 6.5 |
| */ |
| |
| public DistributionConfigImpl(Properties nonDefault, boolean ignoreGemFirePropsFile) { |
| this(nonDefault, ignoreGemFirePropsFile, false); |
| } |
| |
| /** |
| * Creates a new <code>DistributionConfigImpl</code> with the given non-default configuration |
| * properties. See {@link DistributedSystem#connect} for a list of |
| * exceptions that may be thrown. |
| * |
| * @param nonDefault The configuration properties specified by the caller |
| * @param ignoreGemFirePropsFile whether to skip loading distributed system properties from |
| * gemfire.properties file |
| * @param isConnected whether to skip Validation for SSL properties and copy of ssl properties to |
| * other ssl properties. This parameter will be used till we provide support for ssl-* |
| * properties. |
| * |
| * @since GemFire 8.0 |
| */ |
| public DistributionConfigImpl(Properties nonDefault, boolean ignoreGemFirePropsFile, |
| boolean isConnected) { |
| Map<Object, Object> props = new HashMap<>(); |
| if (!ignoreGemFirePropsFile) {// For admin bug #40434 |
| props.putAll(loadPropertiesFromURL(DistributedSystem.getPropertyFileURL(), false)); |
| } |
| props.putAll(loadPropertiesFromURL(DistributedSystem.getSecurityPropertiesFileURL(), true)); |
| |
| // Now override values picked up from the file with values passed |
| // in from the caller's code |
| if (nonDefault != null) { |
| props.putAll(nonDefault); |
| setSource(nonDefault, ConfigSource.api()); |
| } |
| // Now remove all user defined properties from props. |
| for (Object entry : props.entrySet()) { |
| Map.Entry<String, String> ent = (Map.Entry<String, String>) entry; |
| if (ent.getKey().startsWith(USERDEFINED_PREFIX_NAME)) { |
| userDefinedProps.put(ent.getKey(), ent.getValue()); |
| } |
| } |
| // Now override values picked up from the file or code with values |
| // from the system properties. |
| String[] attNames = getAttributeNames(); |
| |
| // For gemfire.security-* properties, we will need to look at |
| // all the system properties instead of looping through attNames |
| Set attNameSet = new HashSet(); |
| for (int index = 0; index < attNames.length; ++index) { |
| attNameSet.add(GEMFIRE_PREFIX + attNames[index]); |
| } |
| |
| // Ensure that we're also iterating over the default properties - see GEODE-4690. |
| for (String key : System.getProperties().stringPropertyNames()) { |
| if (attNameSet.contains(key) || key.startsWith(GEMFIRE_PREFIX + SECURITY_PREFIX_NAME) |
| || key.startsWith(GEMFIRE_PREFIX + SSL_SYSTEM_PROPS_NAME)) { |
| String sysValue = System.getProperty(key); |
| if (sysValue != null) { |
| String attName = key.substring(GEMFIRE_PREFIX.length()); |
| props.put(attName, sysValue); |
| sourceMap.put(attName, ConfigSource.sysprop()); |
| } |
| } |
| } |
| |
| final Properties overriddenDefaults = ProcessLauncherContext.getOverriddenDefaults(); |
| if (!overriddenDefaults.isEmpty()) { |
| for (String key : overriddenDefaults.stringPropertyNames()) { |
| // only apply the overridden default if it's not already specified in props |
| final String property = |
| key.substring(ProcessLauncherContext.OVERRIDDEN_DEFAULTS_PREFIX.length()); |
| if (!props.containsKey(property)) { |
| props.put(property, overriddenDefaults.getProperty(key)); |
| sourceMap.put(property, ConfigSource.launcher()); |
| } |
| } |
| } |
| |
| initialize(props); |
| |
| if (securityPeerAuthInit != null && securityPeerAuthInit.length() > 0) { |
| System.setProperty(SECURITY_SYSTEM_PREFIX + SECURITY_PEER_AUTH_INIT, securityPeerAuthInit); |
| } |
| if (securityPeerAuthenticator != null && securityPeerAuthenticator.length() > 0) { |
| System.setProperty(SECURITY_SYSTEM_PREFIX + SECURITY_PEER_AUTHENTICATOR, |
| securityPeerAuthenticator); |
| } |
| |
| if (!isConnected) { |
| copySSLPropsToServerSSLProps(); |
| copySSLPropsToJMXSSLProps(); |
| copyClusterSSLPropsToGatewaySSLProps(); |
| copySSLPropsToHTTPSSLProps(); |
| } |
| |
| // Make attributes writeable only |
| modifiable = true; |
| validateConfigurationProperties(props); |
| validateSSLEnabledComponentsConfiguration(); |
| // Make attributes read only |
| modifiable = false; |
| } |
| |
| private void validateSSLEnabledComponentsConfiguration() { |
| Object value = null; |
| try { |
| Method method = getters.get(SSL_ENABLED_COMPONENTS); |
| if (method != null) { |
| value = method.invoke(this); |
| } |
| } catch (Exception e) { |
| if (e instanceof RuntimeException) { |
| throw (RuntimeException) e; |
| } |
| if (e.getCause() instanceof RuntimeException) { |
| throw (RuntimeException) e.getCause(); |
| } else { |
| throw new InternalGemFireException( |
| "error invoking getter for property" + SSL_ENABLED_COMPONENTS); |
| } |
| } |
| SecurableCommunicationChannel[] sslEnabledComponents = (SecurableCommunicationChannel[]) value; |
| for (SecurableCommunicationChannel securableCommunicationChannel : sslEnabledComponents) { |
| if (!isAliasCorrectlyConfiguredForComponents(securableCommunicationChannel)) { |
| throw new IllegalArgumentException( |
| "The alias options for the SSL options provided seem to be invalid. Please check that all required aliases are set"); |
| } |
| } |
| } |
| |
| /** |
| * Used by tests to create a default instance without reading in properties. |
| */ |
| static DistributionConfig createDefaultInstance() { |
| return new DistributionConfigImpl(); |
| } |
| |
| private boolean isAliasCorrectlyConfiguredForComponents( |
| final SecurableCommunicationChannel component) { |
| switch (component) { |
| case ALL: { |
| // If the default alias is not set, then check that all the other component aliases are set |
| if (StringUtils.isEmpty(getSSLDefaultAlias())) { |
| boolean correctAlias = true; |
| correctAlias &= |
| isAliasCorrectlyConfiguredForComponents(SecurableCommunicationChannel.CLUSTER); |
| correctAlias &= |
| isAliasCorrectlyConfiguredForComponents(SecurableCommunicationChannel.GATEWAY); |
| correctAlias &= |
| isAliasCorrectlyConfiguredForComponents(SecurableCommunicationChannel.WEB); |
| correctAlias &= |
| isAliasCorrectlyConfiguredForComponents(SecurableCommunicationChannel.JMX); |
| correctAlias &= |
| isAliasCorrectlyConfiguredForComponents(SecurableCommunicationChannel.LOCATOR); |
| correctAlias &= |
| isAliasCorrectlyConfiguredForComponents(SecurableCommunicationChannel.SERVER); |
| return correctAlias; |
| } |
| } |
| case CLUSTER: { |
| return StringUtils.isEmpty(getClusterSSLAlias()) |
| || getSecurableCommunicationChannels().length <= 1 || !StringUtils |
| .isEmpty(getSSLDefaultAlias()); |
| } |
| case GATEWAY: { |
| return StringUtils.isEmpty(getGatewaySSLAlias()) |
| || getSecurableCommunicationChannels().length <= 1 || !StringUtils |
| .isEmpty(getSSLDefaultAlias()); |
| } |
| case WEB: { |
| return StringUtils.isEmpty(getHTTPServiceSSLAlias()) |
| || getSecurableCommunicationChannels().length <= 1 || !StringUtils |
| .isEmpty(getSSLDefaultAlias()); |
| } |
| case JMX: { |
| return StringUtils.isEmpty(getJMXSSLAlias()) |
| || getSecurableCommunicationChannels().length <= 1 || !StringUtils |
| .isEmpty(getSSLDefaultAlias()); |
| } |
| case LOCATOR: { |
| return StringUtils.isEmpty(getLocatorSSLAlias()) |
| || getSecurableCommunicationChannels().length <= 1 || !StringUtils |
| .isEmpty(getSSLDefaultAlias()); |
| } |
| case SERVER: { |
| return StringUtils.isEmpty(getServerSSLAlias()) |
| || getSecurableCommunicationChannels().length <= 1 || !StringUtils |
| .isEmpty(getSSLDefaultAlias()); |
| } |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Here we will validate the correctness of the set properties as per the CheckAttributeChecker |
| * annotations defined in #AbstractDistributionConfig |
| */ |
| private void validateConfigurationProperties(final Map<Object, Object> props) { |
| for (Object o : props.keySet()) { |
| String propertyName = (String) o; |
| Object value = null; |
| try { |
| Method method = getters.get(propertyName); |
| if (method != null) { |
| value = method.invoke(this); |
| } |
| } catch (Exception e) { |
| if (e instanceof RuntimeException) { |
| throw (RuntimeException) e; |
| } |
| if (e.getCause() instanceof RuntimeException) { |
| throw (RuntimeException) e.getCause(); |
| } else { |
| throw new InternalGemFireException("error invoking getter for property" + propertyName); |
| } |
| } |
| checkAttribute(propertyName, value); |
| } |
| } |
| |
| /** |
| * if jmx-manager-ssl is true and jmx-manager-ssl-enabled is false then override |
| * jmx-manager-ssl-enabled with jmx-manager-ssl if jmx-manager-ssl-enabled is false, then use the |
| * properties from cluster-ssl-* properties if jmx-manager-ssl-*properties are given then use |
| * them, and copy the unspecified jmx-manager properties from cluster-properties |
| */ |
| private void copySSLPropsToJMXSSLProps() { |
| boolean jmxSSLEnabledOverriden = sourceMap.get(JMX_MANAGER_SSL_ENABLED) != null; |
| boolean clusterSSLOverRidden = sourceMap.get(CLUSTER_SSL_ENABLED) != null; |
| boolean hasSSLComponents = sourceMap.get(SSL_ENABLED_COMPONENTS) != null; |
| |
| if (clusterSSLOverRidden && !jmxSSLEnabledOverriden && !hasSSLComponents) { |
| jmxManagerSSLEnabled = clusterSSLEnabled; |
| sourceMap.put(JMX_MANAGER_SSL_ENABLED, sourceMap.get(CLUSTER_SSL_ENABLED)); |
| if (sourceMap.get(CLUSTER_SSL_CIPHERS) != null) { |
| jmxManagerSslCiphers = clusterSSLCiphers; |
| sourceMap.put(JMX_MANAGER_SSL_CIPHERS, sourceMap.get(CLUSTER_SSL_CIPHERS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_PROTOCOLS) != null) { |
| jmxManagerSslProtocols = clusterSSLProtocols; |
| sourceMap.put(JMX_MANAGER_SSL_PROTOCOLS, sourceMap.get(CLUSTER_SSL_PROTOCOLS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION) != null) { |
| jmxManagerSslRequireAuthentication = clusterSSLRequireAuthentication; |
| sourceMap.put(JMX_MANAGER_SSL_REQUIRE_AUTHENTICATION, |
| sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| jmxManagerSSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(JMX_MANAGER_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| jmxManagerSSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(JMX_MANAGER_SSL_KEYSTORE_TYPE, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| jmxManagerSSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(JMX_MANAGER_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| jmxManagerSSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(JMX_MANAGER_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| jmxManagerSSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(JMX_MANAGER_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| jmxManagerSslProperties.putAll(clusterSSLProperties); |
| } |
| |
| if (jmxSSLEnabledOverriden) { |
| if (sourceMap.get(JMX_MANAGER_SSL_KEYSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| jmxManagerSSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(JMX_MANAGER_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(JMX_MANAGER_SSL_KEYSTORE_TYPE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| jmxManagerSSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(JMX_MANAGER_SSL_KEYSTORE_TYPE, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(JMX_MANAGER_SSL_KEYSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| jmxManagerSSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(JMX_MANAGER_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(JMX_MANAGER_SSL_TRUSTSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| jmxManagerSSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(JMX_MANAGER_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(JMX_MANAGER_SSL_TRUSTSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| jmxManagerSSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(JMX_MANAGER_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| } |
| } |
| |
| /** |
| * if http-service-ssl-enabled is false, then use the properties from cluster-ssl-* properties if |
| * http-service-ssl-*properties are given then use them, and copy the unspecified http-service |
| * properties from cluster-properties |
| */ |
| private void copySSLPropsToHTTPSSLProps() { |
| boolean httpServiceSSLEnabledOverriden = sourceMap.get(HTTP_SERVICE_SSL_ENABLED) != null; |
| boolean clusterSSLOverRidden = sourceMap.get(CLUSTER_SSL_ENABLED) != null; |
| boolean hasSSLComponents = sourceMap.get(SSL_ENABLED_COMPONENTS) != null; |
| |
| if (clusterSSLOverRidden && !httpServiceSSLEnabledOverriden && !hasSSLComponents) { |
| httpServiceSSLEnabled = clusterSSLEnabled; |
| sourceMap.put(HTTP_SERVICE_SSL_ENABLED, sourceMap.get(CLUSTER_SSL_ENABLED)); |
| |
| if (sourceMap.get(CLUSTER_SSL_CIPHERS) != null) { |
| httpServiceSSLCiphers = clusterSSLCiphers; |
| sourceMap.put(HTTP_SERVICE_SSL_CIPHERS, sourceMap.get(CLUSTER_SSL_CIPHERS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_PROTOCOLS) != null) { |
| httpServiceSSLProtocols = clusterSSLProtocols; |
| sourceMap.put(HTTP_SERVICE_SSL_PROTOCOLS, sourceMap.get(CLUSTER_SSL_PROTOCOLS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION) != null) { |
| httpServiceSSLRequireAuthentication = clusterSSLRequireAuthentication; |
| sourceMap.put(HTTP_SERVICE_SSL_REQUIRE_AUTHENTICATION, |
| sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| setHttpServiceSSLKeyStore(clusterSSLKeyStore); |
| sourceMap.put(HTTP_SERVICE_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| setHttpServiceSSLKeyStoreType(clusterSSLKeyStoreType); |
| sourceMap.put(HTTP_SERVICE_SSL_KEYSTORE_TYPE, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| setHttpServiceSSLKeyStorePassword(clusterSSLKeyStorePassword); |
| sourceMap.put(HTTP_SERVICE_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| setHttpServiceSSLTrustStore(clusterSSLTrustStore); |
| sourceMap.put(HTTP_SERVICE_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| setHttpServiceSSLTrustStorePassword(clusterSSLTrustStorePassword); |
| sourceMap.put(HTTP_SERVICE_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| httpServiceSSLProperties.putAll(clusterSSLProperties); |
| } |
| |
| if (httpServiceSSLEnabledOverriden) { |
| if (sourceMap.get(HTTP_SERVICE_SSL_KEYSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| httpServiceSSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(HTTP_SERVICE_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(HTTP_SERVICE_SSL_KEYSTORE_TYPE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| httpServiceSSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(HTTP_SERVICE_SSL_KEYSTORE_TYPE, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(HTTP_SERVICE_SSL_KEYSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| httpServiceSSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(HTTP_SERVICE_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(HTTP_SERVICE_SSL_TRUSTSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| httpServiceSSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(HTTP_SERVICE_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(HTTP_SERVICE_SSL_TRUSTSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| httpServiceSSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(HTTP_SERVICE_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| } |
| |
| } |
| |
| /* |
| * if server-ssl-enabled is false, then use the properties from cluster-ssl-* properties if |
| * server-ssl-*properties are given then use them, and copy the unspecified server properties from |
| * cluster-properties |
| */ |
| private void copySSLPropsToServerSSLProps() { |
| boolean cacheServerSSLOverriden = sourceMap.get(SERVER_SSL_ENABLED) != null; |
| boolean clusterSSLOverRidden = sourceMap.get(CLUSTER_SSL_ENABLED) != null; |
| boolean hasSSLComponents = sourceMap.get(SSL_ENABLED_COMPONENTS) != null; |
| |
| if (clusterSSLOverRidden && !cacheServerSSLOverriden && !hasSSLComponents) { |
| serverSSLEnabled = clusterSSLEnabled; |
| sourceMap.put(SERVER_SSL_ENABLED, sourceMap.get(CLUSTER_SSL_ENABLED)); |
| if (sourceMap.get(CLUSTER_SSL_CIPHERS) != null) { |
| serverSslCiphers = clusterSSLCiphers; |
| sourceMap.put(SERVER_SSL_CIPHERS, sourceMap.get(CLUSTER_SSL_CIPHERS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_PROTOCOLS) != null) { |
| serverSslProtocols = clusterSSLProtocols; |
| sourceMap.put(SERVER_SSL_PROTOCOLS, sourceMap.get(CLUSTER_SSL_PROTOCOLS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION) != null) { |
| serverSslRequireAuthentication = clusterSSLRequireAuthentication; |
| sourceMap.put(SERVER_SSL_REQUIRE_AUTHENTICATION, |
| sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| serverSSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(SERVER_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| serverSSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(SERVER_SSL_KEYSTORE_TYPE, sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| serverSSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(SERVER_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| serverSSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(SERVER_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| serverSSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(SERVER_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| serverSslProperties.putAll(clusterSSLProperties); |
| } |
| |
| if (cacheServerSSLOverriden) { |
| if (sourceMap.get(SERVER_SSL_KEYSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| serverSSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(SERVER_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(SERVER_SSL_KEYSTORE_TYPE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| serverSSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(SERVER_SSL_KEYSTORE_TYPE, sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(SERVER_SSL_KEYSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| serverSSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(SERVER_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(SERVER_SSL_TRUSTSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| serverSSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(SERVER_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(SERVER_SSL_TRUSTSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| serverSSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(SERVER_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| } |
| } |
| |
| /** |
| * if gateway-ssl-enabled is false, then use the properties from cluster-ssl-* properties if |
| * gateway-ssl-*properties are given then use them, and copy the unspecified gateway properties |
| * from cluster-properties |
| */ |
| private void copyClusterSSLPropsToGatewaySSLProps() { |
| boolean gatewaySSLOverriden = sourceMap.get(GATEWAY_SSL_ENABLED) != null; |
| boolean clusterSSLOverRidden = sourceMap.get(CLUSTER_SSL_ENABLED) != null; |
| boolean hasSSLComponents = sourceMap.get(SSL_ENABLED_COMPONENTS) != null; |
| |
| if (clusterSSLOverRidden && !gatewaySSLOverriden && !hasSSLComponents) { |
| gatewaySSLEnabled = clusterSSLEnabled; |
| sourceMap.put(GATEWAY_SSL_ENABLED, sourceMap.get(CLUSTER_SSL_ENABLED)); |
| if (sourceMap.get(CLUSTER_SSL_CIPHERS) != null) { |
| gatewaySslCiphers = clusterSSLCiphers; |
| sourceMap.put(GATEWAY_SSL_CIPHERS, sourceMap.get(CLUSTER_SSL_CIPHERS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_PROTOCOLS) != null) { |
| gatewaySslProtocols = clusterSSLProtocols; |
| sourceMap.put(GATEWAY_SSL_PROTOCOLS, sourceMap.get(CLUSTER_SSL_PROTOCOLS)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION) != null) { |
| gatewaySslRequireAuthentication = clusterSSLRequireAuthentication; |
| sourceMap.put(GATEWAY_SSL_REQUIRE_AUTHENTICATION, |
| sourceMap.get(CLUSTER_SSL_REQUIRE_AUTHENTICATION)); |
| } |
| |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| gatewaySSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(GATEWAY_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| gatewaySSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(GATEWAY_SSL_KEYSTORE_TYPE, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| gatewaySSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(GATEWAY_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| gatewaySSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(GATEWAY_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| gatewaySSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(GATEWAY_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| gatewaySslProperties.putAll(clusterSSLProperties); |
| } |
| |
| if (gatewaySSLOverriden) { |
| if (sourceMap.get(GATEWAY_SSL_KEYSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE) != null) { |
| gatewaySSLKeyStore = clusterSSLKeyStore; |
| sourceMap.put(GATEWAY_SSL_KEYSTORE, sourceMap.get(CLUSTER_SSL_KEYSTORE)); |
| } |
| if (sourceMap.get(GATEWAY_SSL_KEYSTORE_TYPE) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE) != null) { |
| gatewaySSLKeyStoreType = clusterSSLKeyStoreType; |
| sourceMap.put(GATEWAY_SSL_KEYSTORE_TYPE, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_TYPE)); |
| } |
| if (sourceMap.get(GATEWAY_SSL_KEYSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD) != null) { |
| gatewaySSLKeyStorePassword = clusterSSLKeyStorePassword; |
| sourceMap.put(GATEWAY_SSL_KEYSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_KEYSTORE_PASSWORD)); |
| } |
| if (sourceMap.get(GATEWAY_SSL_TRUSTSTORE) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE) != null) { |
| gatewaySSLTrustStore = clusterSSLTrustStore; |
| sourceMap.put(GATEWAY_SSL_TRUSTSTORE, sourceMap.get(CLUSTER_SSL_TRUSTSTORE)); |
| } |
| if (sourceMap.get(GATEWAY_SSL_TRUSTSTORE_PASSWORD) == null |
| && sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD) != null) { |
| gatewaySSLTrustStorePassword = clusterSSLTrustStorePassword; |
| sourceMap.put(GATEWAY_SSL_TRUSTSTORE_PASSWORD, |
| sourceMap.get(CLUSTER_SSL_TRUSTSTORE_PASSWORD)); |
| } |
| } |
| } |
| |
| /** |
| * Produce a DistributionConfigImpl for the given properties and return it. |
| */ |
| public static DistributionConfigImpl produce(Properties props) { |
| if (props != null) { |
| Object o = props.get(DS_CONFIG_NAME); |
| if (o instanceof DistributionConfigImpl) { |
| return (DistributionConfigImpl) o; |
| } |
| } |
| return new DistributionConfigImpl(props, false, false); |
| } |
| |
| /** |
| * Produce a DistributionConfigImpl for the given properties and return it. |
| */ |
| public static DistributionConfigImpl produce(Properties props, boolean isConnected) { |
| if (props != null) { |
| Object o = props.get(DS_CONFIG_NAME); |
| if (o instanceof DistributionConfigImpl) { |
| return (DistributionConfigImpl) o; |
| } |
| } |
| return new DistributionConfigImpl(props, false, isConnected); |
| } |
| |
| void setApiProps(Properties apiProps) { |
| if (apiProps != null) { |
| setSource(apiProps, ConfigSource.api()); |
| modifiable = true; |
| Iterator it = apiProps.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry me = (Map.Entry) it.next(); |
| String propName = (String) me.getKey(); |
| props.put(propName, me.getValue()); |
| if (specialPropName(propName)) { |
| continue; |
| } |
| String propVal = (String) me.getValue(); |
| if (propVal != null) { |
| setAttribute(propName, propVal.trim(), sourceMap.get(propName)); |
| } |
| } |
| // Make attributes read only |
| modifiable = false; |
| } |
| } |
| |
| private static boolean specialPropName(String propName) { |
| return propName.equalsIgnoreCase(CLUSTER_SSL_ENABLED) |
| || propName.equals(SECURITY_PEER_AUTH_INIT) || propName.equals(SECURITY_PEER_AUTHENTICATOR) |
| || propName.equals(LOG_WRITER_NAME) || propName.equals(DS_CONFIG_NAME) |
| || propName.equals(SECURITY_LOG_WRITER_NAME) || propName.equals(LOG_OUTPUTSTREAM_NAME) |
| || propName.equals(SECURITY_LOG_OUTPUTSTREAM_NAME); |
| } |
| |
| @Override |
| protected Map<String, ConfigSource> getAttSourceMap() { |
| return sourceMap; |
| } |
| |
| @Override |
| public Properties getUserDefinedProps() { |
| return userDefinedProps; |
| } |
| |
| /** |
| * Loads the properties from gemfire.properties & gfsecurity.properties files into given |
| * Properties object. |
| * |
| * @param properties the Properties to fill in |
| * |
| * @throws GemFireIOException when error occurs while reading properties file |
| */ |
| public static void loadGemFireProperties(Properties properties) throws GemFireIOException { |
| loadGemFireProperties(properties, false); |
| } |
| |
| /** |
| * Loads the properties from gemfire.properties & gfsecurity.properties files into given |
| * Properties object. if <code>ignoreGemFirePropsFile</code> is <code>true</code>, properties are |
| * not read from gemfire.properties. |
| * |
| * @param properties the Properties to fill in |
| * @param ignoreGemFirePropsFile whether to ignore properties from gemfire.properties |
| * |
| * @throws GemFireIOException when error occurs while reading properties file |
| */ |
| // Fix for #44924 |
| public static void loadGemFireProperties(Properties properties, boolean ignoreGemFirePropsFile) |
| throws GemFireIOException { |
| if (!ignoreGemFirePropsFile) { |
| loadPropertiesFromURL(properties, DistributedSystem.getPropertyFileURL()); |
| } |
| // load the security properties file |
| loadPropertiesFromURL(properties, DistributedSystem.getSecurityPropertiesFileURL()); |
| } |
| |
| /** |
| * For every key in p mark it as being from the given source. |
| */ |
| private void setSource(Properties p, ConfigSource source) { |
| if (source == null) { |
| throw new IllegalArgumentException("Valid ConfigSource must be specified instead of null."); |
| } |
| for (Object k : p.keySet()) { |
| sourceMap.put((String) k, source); |
| } |
| } |
| |
| private Properties loadPropertiesFromURL(URL url, boolean secure) { |
| Properties result = new Properties(); |
| loadPropertiesFromURL(result, url); |
| if (!result.isEmpty()) { |
| setSource(result, ConfigSource.file(url.toString(), secure)); |
| } |
| return result; |
| } |
| |
| private static void loadPropertiesFromURL(Properties properties, URL url) { |
| if (url != null) { |
| try { |
| properties.load(url.openStream()); |
| } catch (IOException io) { |
| throw new GemFireIOException( |
| String.format("Failed reading %s", url), io); |
| } |
| } |
| } |
| |
| private void initialize(Map props) { |
| // Allow attributes to be modified |
| modifiable = true; |
| this.props = props; |
| Iterator it = props.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry me = (Map.Entry) it.next(); |
| String propName = (String) me.getKey(); |
| // if ssl-enabled is set to true before the mcast port is set to 0, then it will error. |
| // security should not be enabled before the mcast port is set to 0. |
| if (specialPropName(propName)) { |
| continue; |
| } |
| Object propVal = me.getValue(); |
| // weed out extraneous non-string properties |
| if (propVal instanceof String) { |
| setAttribute(propName, ((String) propVal).trim(), sourceMap.get(propName)); |
| } |
| } |
| if (props.containsKey(CLUSTER_SSL_ENABLED)) { |
| setAttribute(CLUSTER_SSL_ENABLED, (String) props.get(CLUSTER_SSL_ENABLED), |
| sourceMap.get(CLUSTER_SSL_ENABLED)); |
| } |
| // now set the security authInit if needed |
| if (props.containsKey(SECURITY_PEER_AUTH_INIT)) { |
| setAttribute(SECURITY_PEER_AUTH_INIT, (String) props.get(SECURITY_PEER_AUTH_INIT), |
| sourceMap.get(SECURITY_PEER_AUTH_INIT)); |
| } |
| // and security authenticator if needed |
| if (props.containsKey(SECURITY_PEER_AUTHENTICATOR)) { |
| setAttribute(SECURITY_PEER_AUTHENTICATOR, |
| (String) props.get(SECURITY_PEER_AUTHENTICATOR), |
| sourceMap.get(SECURITY_PEER_AUTHENTICATOR)); |
| } |
| |
| // Make attributes read only |
| modifiable = false; |
| } |
| |
| private String convertCommaDelimitedToSpaceDelimitedString(final String propVal) { |
| return propVal.replace(",", " "); |
| } |
| |
| @Override |
| public void close() { |
| // Clear the extra stuff from System properties |
| Properties properties = System.getProperties(); |
| properties.remove(SECURITY_SYSTEM_PREFIX + SECURITY_PEER_AUTH_INIT); |
| properties.remove(SECURITY_SYSTEM_PREFIX + SECURITY_PEER_AUTHENTICATOR); |
| |
| Iterator iter = security.keySet().iterator(); |
| while (iter.hasNext()) { |
| properties.remove(SECURITY_SYSTEM_PREFIX + iter.next()); |
| } |
| System.setProperties(properties); |
| } |
| |
| @Override |
| public String getName() { |
| return name; |
| } |
| |
| @Override |
| public int getTcpPort() { |
| return tcpPort; |
| } |
| |
| @Override |
| public int getMcastPort() { |
| return mcastPort; |
| } |
| |
| @Override |
| public int getMcastTtl() { |
| return mcastTtl; |
| } |
| |
| @Override |
| public int getSocketLeaseTime() { |
| return socketLeaseTime; |
| } |
| |
| @Override |
| public int getSocketBufferSize() { |
| return socketBufferSize; |
| } |
| |
| @Override |
| public boolean getConserveSockets() { |
| return conserveSockets; |
| } |
| |
| @Override |
| public String getRoles() { |
| return roles; |
| } |
| |
| @Override |
| public int getMaxWaitTimeForReconnect() { |
| return maxWaitTimeForReconnect; |
| } |
| |
| @Override |
| public int getMaxNumReconnectTries() { |
| return maxNumReconnectTries; |
| } |
| |
| @Override |
| public InetAddress getMcastAddress() { |
| try { |
| return mcastAddress; |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } |
| |
| @Override |
| public String getBindAddress() { |
| return bindAddress; |
| } |
| |
| @Override |
| public String getServerBindAddress() { |
| return serverBindAddress; |
| } |
| |
| @Override |
| public String getLocators() { |
| if (startLocator != null && startLocator.length() > 0) { |
| String locs = locators; |
| String startL = getStartLocator(); |
| int comma = startL.indexOf(','); |
| if (comma >= 0) { |
| startL = startL.substring(0, comma); |
| } |
| if (locs.length() > 0) { |
| if (locs.contains(startL)) { |
| return locs; // fix for bug 43929 |
| } |
| return locs + "," + startL; |
| } else { |
| return startL; |
| } |
| } |
| return locators; |
| } |
| |
| @Override |
| public String getStartLocator() { |
| if (startLocatorPort > 0) { |
| if (bindAddress != null) { |
| return bindAddress + "[" + startLocatorPort + "]"; |
| } |
| try { |
| return SocketCreator.getHostName(SocketCreator.getLocalHost()) + "[" + startLocatorPort |
| + "]"; |
| } catch (UnknownHostException ignore) { |
| // punt and use this.startLocator instead |
| } |
| } |
| return startLocator; |
| } |
| |
| @Override |
| public File getDeployWorkingDir() { |
| return deployWorkingDir; |
| } |
| |
| @Override |
| public File getLogFile() { |
| return logFile; |
| } |
| |
| @Override |
| public int getLogLevel() { |
| return logLevel; |
| } |
| |
| @Override |
| public boolean getStatisticSamplingEnabled() { |
| return statisticSamplingEnabled; |
| } |
| |
| @Override |
| public int getStatisticSampleRate() { |
| return statisticSampleRate; |
| } |
| |
| @Override |
| public File getStatisticArchiveFile() { |
| return statisticArchiveFile; |
| } |
| |
| @Override |
| public int getAckWaitThreshold() { |
| return ackWaitThreshold; |
| } |
| |
| @Override |
| public int getAckSevereAlertThreshold() { |
| return ackForceDisconnectThreshold; |
| } |
| |
| @Override |
| public File getCacheXmlFile() { |
| return cacheXmlFile; |
| } |
| |
| @Override |
| public boolean getClusterSSLEnabled() { |
| return clusterSSLEnabled; |
| } |
| |
| @Override |
| public String getClusterSSLProtocols() { |
| return clusterSSLProtocols; |
| } |
| |
| @Override |
| public String getClusterSSLCiphers() { |
| return clusterSSLCiphers; |
| } |
| |
| @Override |
| public boolean getClusterSSLRequireAuthentication() { |
| return clusterSSLRequireAuthentication; |
| } |
| |
| @Override |
| public String getClusterSSLKeyStore() { |
| return clusterSSLKeyStore; |
| } |
| |
| @Override |
| public String getClusterSSLKeyStoreType() { |
| return clusterSSLKeyStoreType; |
| } |
| |
| @Override |
| public String getClusterSSLKeyStorePassword() { |
| return clusterSSLKeyStorePassword; |
| } |
| |
| @Override |
| public String getClusterSSLTrustStore() { |
| return clusterSSLTrustStore; |
| } |
| |
| @Override |
| public String getClusterSSLTrustStorePassword() { |
| return clusterSSLTrustStorePassword; |
| } |
| |
| @Override |
| public int getAsyncDistributionTimeout() { |
| return asyncDistributionTimeout; |
| } |
| |
| @Override |
| public int getAsyncQueueTimeout() { |
| return asyncQueueTimeout; |
| } |
| |
| @Override |
| public int getAsyncMaxQueueSize() { |
| return asyncMaxQueueSize; |
| } |
| |
| @Override |
| public String getUserCommandPackages() { |
| return userCommandPackages; |
| } |
| |
| @Override |
| public int getHttpServicePort() { |
| return httpServicePort; |
| } |
| |
| @Override |
| public void setHttpServicePort(int value) { |
| httpServicePort = value; |
| } |
| |
| @Override |
| public String getHttpServiceBindAddress() { |
| return httpServiceBindAddress; |
| } |
| |
| @Override |
| public void setHttpServiceBindAddress(String value) { |
| httpServiceBindAddress = value; |
| } |
| |
| @Override |
| public boolean getStartDevRestApi() { |
| return startDevRestApi; |
| } |
| |
| @Override |
| public void setStartDevRestApi(boolean value) { |
| startDevRestApi = value; |
| } |
| |
| @Override |
| public void setUserCommandPackages(String value) { |
| userCommandPackages = value; |
| } |
| |
| @Override |
| public boolean getDeltaPropagation() { |
| return deltaPropagation; |
| } |
| |
| @Override |
| public void setDeltaPropagation(boolean value) { |
| deltaPropagation = value; |
| } |
| |
| @Override |
| public void setName(String value) { |
| if (value == null) { |
| value = DEFAULT_NAME; |
| } |
| name = value; |
| } |
| |
| @Override |
| public void setTcpPort(int value) { |
| tcpPort = value; |
| } |
| |
| @Override |
| public void setMcastPort(int value) { |
| mcastPort = value; |
| } |
| |
| @Override |
| public void setMcastTtl(int value) { |
| mcastTtl = value; |
| } |
| |
| @Override |
| public void setSocketLeaseTime(int value) { |
| socketLeaseTime = value; |
| } |
| |
| @Override |
| public void setSocketBufferSize(int value) { |
| socketBufferSize = value; |
| } |
| |
| @Override |
| public void setConserveSockets(boolean newValue) { |
| conserveSockets = newValue; |
| } |
| |
| @Override |
| public void setRoles(String roles) { |
| this.roles = roles; |
| } |
| |
| @Override |
| public void setMaxWaitTimeForReconnect(int timeOut) { |
| maxWaitTimeForReconnect = timeOut; |
| } |
| |
| @Override |
| public void setMaxNumReconnectTries(int tries) { |
| maxNumReconnectTries = tries; |
| } |
| |
| @Override |
| public void setMcastAddress(InetAddress value) { |
| mcastAddress = value; |
| } |
| |
| @Override |
| public void setBindAddress(String value) { |
| bindAddress = value; |
| } |
| |
| @Override |
| public void setServerBindAddress(String value) { |
| serverBindAddress = value; |
| } |
| |
| @Override |
| public void setLocators(String value) { |
| if (value == null) { |
| value = DEFAULT_LOCATORS; |
| } |
| locators = value; |
| } |
| |
| @Override |
| public void setLocatorWaitTime(int seconds) { |
| locatorWaitTime = seconds; |
| } |
| |
| @Override |
| public int getLocatorWaitTime() { |
| return locatorWaitTime; |
| } |
| |
| @Override |
| public void setDeployWorkingDir(File value) { |
| deployWorkingDir = value; |
| } |
| |
| @Override |
| public void setLogFile(File value) { |
| logFile = value; |
| } |
| |
| @Override |
| public void setLogLevel(int value) { |
| logLevel = value; |
| } |
| |
| /** |
| * the locator startup code must be able to modify the locator log file in order to establish a |
| * default log file if one hasn't been specified by the user. This method will change the log |
| * file, but only in the configuration settings - it won't affect a running distributed system's |
| * log file |
| */ |
| void unsafeSetLogFile(File value) { |
| logFile = value; |
| } |
| |
| @Override |
| public void setStartLocator(String value) { |
| startLocatorPort = 0; |
| if (value == null) { |
| value = DEFAULT_START_LOCATOR; |
| } else { |
| // bug 37938 - allow just a port |
| boolean alldigits = true; |
| for (int i = 0; i < value.length(); i++) { |
| char c = value.charAt(i); |
| if (!Character.isDigit(c)) { |
| alldigits = false; |
| break; |
| } |
| } |
| if (value.length() > 0 && alldigits) { |
| try { |
| int port = Integer.parseInt(value); |
| if (port < 0 || port > 65535) { |
| throw new GemFireConfigException("Illegal port specified for start-locator"); |
| } |
| startLocatorPort = port; |
| } catch (NumberFormatException e) { |
| throw new GemFireConfigException("Illegal port specified for start-locator", e); |
| } |
| } |
| } |
| startLocator = value; |
| } |
| |
| @Override |
| public void setStatisticSamplingEnabled(boolean newValue) { |
| statisticSamplingEnabled = newValue; |
| } |
| |
| @Override |
| public void setStatisticSampleRate(int value) { |
| if (value < DEFAULT_STATISTIC_SAMPLE_RATE) { |
| // fix 48228 |
| InternalDistributedSystem ids = InternalDistributedSystem.getConnectedInstance(); |
| if (ids != null) { |
| ids.getLogWriter() |
| .info("Setting statistic-sample-rate to " + DEFAULT_STATISTIC_SAMPLE_RATE |
| + " instead of the requested " + value |
| + " because VSD does not work with sub-second sampling."); |
| } |
| value = DEFAULT_STATISTIC_SAMPLE_RATE; |
| } |
| statisticSampleRate = value; |
| } |
| |
| @Override |
| public void setStatisticArchiveFile(File value) { |
| if (value == null) { |
| value = new File(""); |
| } |
| statisticArchiveFile = value; |
| } |
| |
| @Override |
| public void setCacheXmlFile(File value) { |
| cacheXmlFile = value; |
| } |
| |
| @Override |
| public void setAckWaitThreshold(int newThreshold) { |
| ackWaitThreshold = newThreshold; |
| } |
| |
| @Override |
| public void setAckSevereAlertThreshold(int newThreshold) { |
| ackForceDisconnectThreshold = newThreshold; |
| } |
| |
| @Override |
| public int getArchiveDiskSpaceLimit() { |
| return archiveDiskSpaceLimit; |
| } |
| |
| @Override |
| public void setArchiveDiskSpaceLimit(int value) { |
| archiveDiskSpaceLimit = value; |
| } |
| |
| @Override |
| public int getArchiveFileSizeLimit() { |
| return archiveFileSizeLimit; |
| } |
| |
| @Override |
| public void setArchiveFileSizeLimit(int value) { |
| archiveFileSizeLimit = value; |
| } |
| |
| @Override |
| public int getLogDiskSpaceLimit() { |
| return logDiskSpaceLimit; |
| } |
| |
| @Override |
| public void setLogDiskSpaceLimit(int value) { |
| logDiskSpaceLimit = value; |
| } |
| |
| @Override |
| public int getLogFileSizeLimit() { |
| return logFileSizeLimit; |
| } |
| |
| @Override |
| public void setLogFileSizeLimit(int value) { |
| logFileSizeLimit = value; |
| } |
| |
| @Override |
| public void setClusterSSLEnabled(boolean enabled) { |
| clusterSSLEnabled = enabled; |
| } |
| |
| @Override |
| public void setClusterSSLProtocols(String protocols) { |
| clusterSSLProtocols = protocols; |
| } |
| |
| @Override |
| public void setClusterSSLCiphers(String ciphers) { |
| clusterSSLCiphers = ciphers; |
| } |
| |
| @Override |
| public void setClusterSSLRequireAuthentication(boolean enabled) { |
| clusterSSLRequireAuthentication = enabled; |
| } |
| |
| @Override |
| public void setClusterSSLKeyStore(String keyStore) { |
| getClusterSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_NAME, keyStore); |
| clusterSSLKeyStore = keyStore; |
| } |
| |
| @Override |
| public void setClusterSSLKeyStoreType(String keyStoreType) { |
| getClusterSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_TYPE_NAME, |
| keyStoreType); |
| clusterSSLKeyStoreType = keyStoreType; |
| } |
| |
| @Override |
| public void setClusterSSLKeyStorePassword(String keyStorePassword) { |
| getClusterSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_PASSWORD_NAME, |
| keyStorePassword); |
| clusterSSLKeyStorePassword = keyStorePassword; |
| } |
| |
| @Override |
| public void setClusterSSLTrustStore(String trustStore) { |
| getClusterSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_NAME, trustStore); |
| clusterSSLTrustStore = trustStore; |
| } |
| |
| @Override |
| public void setClusterSSLTrustStorePassword(String trusStorePassword) { |
| getClusterSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_PASSWORD_NAME, |
| trusStorePassword); |
| clusterSSLTrustStorePassword = trusStorePassword; |
| } |
| |
| @Override |
| public int getMcastSendBufferSize() { |
| return mcastSendBufferSize; |
| } |
| |
| @Override |
| public void setMcastSendBufferSize(int value) { |
| mcastSendBufferSize = value; |
| } |
| |
| @Override |
| public int getMcastRecvBufferSize() { |
| return mcastRecvBufferSize; |
| } |
| |
| @Override |
| public void setMcastRecvBufferSize(int value) { |
| mcastRecvBufferSize = value; |
| } |
| |
| @Override |
| public void setAsyncDistributionTimeout(int newValue) { |
| asyncDistributionTimeout = newValue; |
| } |
| |
| @Override |
| public void setAsyncQueueTimeout(int newValue) { |
| asyncQueueTimeout = newValue; |
| } |
| |
| @Override |
| public void setAsyncMaxQueueSize(int newValue) { |
| asyncMaxQueueSize = newValue; |
| } |
| |
| @Override |
| public FlowControlParams getMcastFlowControl() { |
| return mcastFlowControl; |
| } |
| |
| @Override |
| public void setMcastFlowControl(FlowControlParams values) { |
| mcastFlowControl = values; |
| } |
| |
| @Override |
| public int getUdpFragmentSize() { |
| return udpFragmentSize; |
| } |
| |
| @Override |
| public void setUdpFragmentSize(int value) { |
| udpFragmentSize = value; |
| } |
| |
| @Override |
| public int getUdpSendBufferSize() { |
| return udpSendBufferSize; |
| } |
| |
| @Override |
| public void setUdpSendBufferSize(int value) { |
| udpSendBufferSize = value; |
| } |
| |
| @Override |
| public int getUdpRecvBufferSize() { |
| return udpRecvBufferSize; |
| } |
| |
| @Override |
| public void setUdpRecvBufferSize(int value) { |
| udpRecvBufferSize = value; |
| } |
| |
| @Override |
| public boolean getDisableTcp() { |
| return disableTcp; |
| } |
| |
| @Override |
| public void setDisableTcp(boolean newValue) { |
| disableTcp = newValue; |
| } |
| |
| @Override |
| public boolean getDisableJmx() { |
| return disableJmx; |
| } |
| |
| @Override |
| public void setDisableJmx(boolean newValue) { |
| disableJmx = newValue; |
| } |
| |
| @Override |
| public boolean getEnableTimeStatistics() { |
| return enableTimeStatistics; |
| } |
| |
| @Override |
| public void setEnableTimeStatistics(boolean newValue) { |
| enableTimeStatistics = newValue; |
| } |
| |
| @Override |
| public int getMemberTimeout() { |
| return memberTimeout; |
| } |
| |
| @Override |
| public void setMemberTimeout(int value) { |
| memberTimeout = value; |
| } |
| |
| /** |
| * @since GemFire 5.7 |
| */ |
| @Override |
| public String getClientConflation() { |
| return clientConflation; |
| } |
| |
| /** |
| * @since GemFire 5.7 |
| */ |
| @Override |
| public void setClientConflation(String clientConflation) { |
| this.clientConflation = clientConflation; |
| } |
| |
| @Override |
| public String getDurableClientId() { |
| return durableClientId; |
| } |
| |
| @Override |
| public void setDurableClientId(String durableClientId) { |
| this.durableClientId = durableClientId; |
| } |
| |
| @Override |
| public int getDurableClientTimeout() { |
| return durableClientTimeout; |
| } |
| |
| @Override |
| public void setDurableClientTimeout(int durableClientTimeout) { |
| this.durableClientTimeout = durableClientTimeout; |
| } |
| |
| @Override |
| public String getSecurityClientAuthInit() { |
| return securityClientAuthInit; |
| } |
| |
| @Override |
| public void setSecurityClientAuthInit(String attValue) { |
| securityClientAuthInit = attValue; |
| } |
| |
| @Override |
| public String getSecurityClientAuthenticator() { |
| return securityClientAuthenticator; |
| } |
| |
| @Override |
| public String getSecurityManager() { |
| return securityManager; |
| } |
| |
| @Override |
| public String getPostProcessor() { |
| return postProcessor; |
| } |
| |
| @Override |
| public boolean getEnableNetworkPartitionDetection() { |
| return enableNetworkPartitionDetection; |
| } |
| |
| @Override |
| public void setEnableNetworkPartitionDetection(boolean newValue) { |
| enableNetworkPartitionDetection = newValue; |
| } |
| |
| @Override |
| public boolean getDisableAutoReconnect() { |
| return disableAutoReconnect; |
| } |
| |
| @Override |
| public void setDisableAutoReconnect(boolean value) { |
| disableAutoReconnect = value; |
| } |
| |
| @Override |
| public void setSecurityClientAuthenticator(String attValue) { |
| securityClientAuthenticator = attValue; |
| } |
| |
| @Override |
| public void setSecurityManager(String attValue) { |
| securityManager = attValue; |
| } |
| |
| @Override |
| public void setPostProcessor(String attValue) { |
| postProcessor = attValue; |
| } |
| |
| @Override |
| public String getSecurityClientDHAlgo() { |
| return securityClientDHAlgo; |
| } |
| |
| @Override |
| public void setSecurityClientDHAlgo(String attValue) { |
| securityClientDHAlgo = attValue; |
| } |
| |
| @Override |
| public String getSecurityUDPDHAlgo() { |
| return securityUDPDHAlgo; |
| } |
| |
| @Override |
| public void setSecurityUDPDHAlgo(String attValue) { |
| securityUDPDHAlgo = (String) checkAttribute(SECURITY_UDP_DHALGO, attValue); |
| } |
| |
| @Override |
| public String getSecurityPeerAuthInit() { |
| return securityPeerAuthInit; |
| } |
| |
| @Override |
| public void setSecurityPeerAuthInit(String attValue) { |
| securityPeerAuthInit = attValue; |
| } |
| |
| @Override |
| public String getSecurityPeerAuthenticator() { |
| return securityPeerAuthenticator; |
| } |
| |
| @Override |
| public void setSecurityPeerAuthenticator(String attValue) { |
| securityPeerAuthenticator = attValue; |
| } |
| |
| @Override |
| public String getSecurityClientAccessor() { |
| return securityClientAccessor; |
| } |
| |
| @Override |
| public void setSecurityClientAccessor(String attValue) { |
| securityClientAccessor = attValue; |
| } |
| |
| @Override |
| public String getSecurityClientAccessorPP() { |
| return securityClientAccessorPP; |
| } |
| |
| @Override |
| public void setSecurityClientAccessorPP(String attValue) { |
| securityClientAccessorPP = attValue; |
| } |
| |
| @Override |
| public int getSecurityLogLevel() { |
| return securityLogLevel; |
| } |
| |
| @Override |
| public void setSecurityLogLevel(int level) { |
| securityLogLevel = level; |
| } |
| |
| @Override |
| public File getSecurityLogFile() { |
| return securityLogFile; |
| } |
| |
| @Override |
| public void setSecurityLogFile(File value) { |
| securityLogFile = value; |
| } |
| |
| @Override |
| public int getSecurityPeerMembershipTimeout() { |
| return securityPeerMembershipTimeout; |
| } |
| |
| @Override |
| public void setSecurityPeerMembershipTimeout(int attValue) { |
| securityPeerMembershipTimeout = attValue; |
| } |
| |
| @Override |
| public Properties getSecurityProps() { |
| Properties result = new Properties(); |
| result.putAll(security); |
| return result; |
| } |
| |
| @Override |
| public Properties toSecurityProperties() { |
| Properties result = new Properties(); |
| for (Object attName : security.keySet()) { |
| if (attName instanceof String) { |
| result.put(attName, getAttribute((String) attName)); |
| } else { |
| result.put(attName, security.get(attName)); |
| } |
| } |
| return result; |
| } |
| |
| @Override |
| public String getSecurity(String attName) { |
| |
| String attValue = security.getProperty(attName); |
| return attValue == null ? "" : attValue; |
| } |
| |
| @Override |
| public void setSecurity(String attName, String attValue) { |
| security.setProperty(attName, attValue); |
| } |
| |
| @Override |
| public boolean getRemoveUnresponsiveClient() { |
| return removeUnresponsiveClient; |
| } |
| |
| @Override |
| public void setRemoveUnresponsiveClient(boolean value) { |
| removeUnresponsiveClient = value; |
| } |
| |
| @Override |
| public int getDistributedSystemId() { |
| return distributedSystemId; |
| } |
| |
| @Override |
| public void setDistributedSystemId(int distributedSystemId) { |
| this.distributedSystemId = distributedSystemId; |
| |
| } |
| |
| @Override |
| public boolean getEnforceUniqueHost() { |
| return enforceUniqueHost; |
| } |
| |
| @Override |
| public String getRedundancyZone() { |
| // TODO Auto-generated method stub |
| return redundancyZone; |
| } |
| |
| @Override |
| public void setEnforceUniqueHost(boolean enforceUniqueHost) { |
| this.enforceUniqueHost = enforceUniqueHost; |
| |
| } |
| |
| @Override |
| public void setRedundancyZone(String redundancyZone) { |
| this.redundancyZone = redundancyZone; |
| |
| } |
| |
| @Override |
| public void setSSLProperty(String attName, String attValue) { |
| if (attName.startsWith(SYS_PROP_NAME)) { |
| attName = attName.substring(SYS_PROP_NAME.length()); |
| } |
| if (attName.endsWith(JMX_SSL_PROPS_SUFFIX)) { |
| jmxManagerSslProperties.setProperty( |
| attName.substring(0, attName.length() - JMX_SSL_PROPS_SUFFIX.length()), attValue); |
| } else { |
| sslProperties.setProperty(attName, attValue); |
| |
| if (!jmxManagerSslProperties.containsKey(attName)) { |
| // use sslProperties as base and let props with suffix JMX_SSL_PROPS_SUFFIX override that |
| // base |
| jmxManagerSslProperties.setProperty(attName, attValue); |
| } |
| |
| if (!serverSslProperties.containsKey(attName)) { |
| // use sslProperties as base and let props with suffix CACHESERVER_SSL_PROPS_SUFFIX override |
| // that base |
| serverSslProperties.setProperty(attName, attValue); |
| } |
| if (!gatewaySslProperties.containsKey(attName)) { |
| // use sslProperties as base and let props with suffix GATEWAY_SSL_PROPS_SUFFIX override |
| // that base |
| gatewaySslProperties.setProperty(attName, attValue); |
| } |
| if (!httpServiceSSLProperties.containsKey(attName)) { |
| // use sslProperties as base and let props with suffix GATEWAY_SSL_PROPS_SUFFIX override |
| // that base |
| httpServiceSSLProperties.setProperty(attName, attValue); |
| } |
| if (!clusterSSLProperties.containsKey(attName)) { |
| // use sslProperties as base and let props with suffix GATEWAY_SSL_PROPS_SUFFIX override |
| // that base |
| clusterSSLProperties.setProperty(attName, attValue); |
| } |
| } |
| } |
| |
| @Override |
| public Properties getSSLProperties() { |
| return sslProperties; |
| } |
| |
| @Override |
| public Properties getClusterSSLProperties() { |
| return clusterSSLProperties; |
| } |
| |
| @Override |
| public Properties getJmxSSLProperties() { |
| return jmxManagerSslProperties; |
| } |
| |
| @Override |
| public String getGroups() { |
| return groups; |
| } |
| |
| @Override |
| public void setGroups(String value) { |
| if (value == null) { |
| value = DEFAULT_GROUPS; |
| } |
| groups = value; |
| } |
| |
| @Override |
| public boolean getJmxManager() { |
| return jmxManager; |
| } |
| |
| @Override |
| public void setJmxManager(boolean value) { |
| jmxManager = value; |
| } |
| |
| @Override |
| public boolean getJmxManagerStart() { |
| return jmxManagerStart; |
| } |
| |
| @Override |
| public void setJmxManagerStart(boolean value) { |
| jmxManagerStart = value; |
| } |
| |
| @Override |
| public boolean getJmxManagerSSLEnabled() { |
| return jmxManagerSSLEnabled; |
| } |
| |
| @Override |
| public void setJmxManagerSSLEnabled(boolean enabled) { |
| jmxManagerSSLEnabled = enabled; |
| } |
| |
| @Override |
| public boolean getJmxManagerSSLRequireAuthentication() { |
| return jmxManagerSslRequireAuthentication; |
| } |
| |
| @Override |
| public void setJmxManagerSSLRequireAuthentication(boolean enabled) { |
| jmxManagerSslRequireAuthentication = enabled; |
| } |
| |
| @Override |
| public String getJmxManagerSSLProtocols() { |
| return jmxManagerSslProtocols; |
| } |
| |
| @Override |
| public void setJmxManagerSSLProtocols(String protocols) { |
| jmxManagerSslProtocols = protocols; |
| } |
| |
| @Override |
| public String getJmxManagerSSLCiphers() { |
| return jmxManagerSslCiphers; |
| } |
| |
| @Override |
| public void setJmxManagerSSLCiphers(String ciphers) { |
| jmxManagerSslCiphers = ciphers; |
| } |
| |
| @Override |
| public void setJmxManagerSSLKeyStore(String keyStore) { |
| getJmxSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_NAME, keyStore); |
| jmxManagerSSLKeyStore = keyStore; |
| } |
| |
| @Override |
| public void setJmxManagerSSLKeyStoreType(String keyStoreType) { |
| getJmxSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_TYPE_NAME, keyStoreType); |
| jmxManagerSSLKeyStoreType = keyStoreType; |
| } |
| |
| @Override |
| public void setJmxManagerSSLKeyStorePassword(String keyStorePassword) { |
| getJmxSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_PASSWORD_NAME, |
| keyStorePassword); |
| jmxManagerSSLKeyStorePassword = keyStorePassword; |
| } |
| |
| @Override |
| public void setJmxManagerSSLTrustStore(String trustStore) { |
| getJmxSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_NAME, trustStore); |
| jmxManagerSSLTrustStore = trustStore; |
| } |
| |
| @Override |
| public void setJmxManagerSSLTrustStorePassword(String trusStorePassword) { |
| getJmxSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_PASSWORD_NAME, |
| trusStorePassword); |
| jmxManagerSSLTrustStorePassword = trusStorePassword; |
| } |
| |
| @Override |
| public String getJmxManagerSSLKeyStore() { |
| return jmxManagerSSLKeyStore; |
| } |
| |
| @Override |
| public String getJmxManagerSSLKeyStoreType() { |
| return jmxManagerSSLKeyStoreType; |
| } |
| |
| @Override |
| public String getJmxManagerSSLKeyStorePassword() { |
| return jmxManagerSSLKeyStorePassword; |
| } |
| |
| @Override |
| public String getJmxManagerSSLTrustStore() { |
| return jmxManagerSSLTrustStore; |
| } |
| |
| @Override |
| public String getJmxManagerSSLTrustStorePassword() { |
| return jmxManagerSSLTrustStorePassword; |
| } |
| |
| @Override |
| public int getJmxManagerPort() { |
| return jmxManagerPort; |
| } |
| |
| @Override |
| public void setJmxManagerPort(int value) { |
| jmxManagerPort = value; |
| } |
| |
| @Override |
| public String getJmxManagerBindAddress() { |
| return jmxManagerBindAddress; |
| } |
| |
| @Override |
| public void setJmxManagerBindAddress(String value) { |
| if (value == null) { |
| value = ""; |
| } |
| jmxManagerBindAddress = value; |
| } |
| |
| @Override |
| public String getJmxManagerHostnameForClients() { |
| return jmxManagerHostnameForClients; |
| } |
| |
| @Override |
| public void setJmxManagerHostnameForClients(String value) { |
| if (value == null) { |
| value = ""; |
| } |
| jmxManagerHostnameForClients = value; |
| } |
| |
| @Override |
| public String getJmxManagerPasswordFile() { |
| return jmxManagerPasswordFile; |
| } |
| |
| @Override |
| public void setJmxManagerPasswordFile(String value) { |
| if (value == null) { |
| value = ""; |
| } |
| jmxManagerPasswordFile = value; |
| } |
| |
| @Override |
| public String getJmxManagerAccessFile() { |
| return jmxManagerAccessFile; |
| } |
| |
| @Override |
| public void setJmxManagerAccessFile(String value) { |
| if (value == null) { |
| value = ""; |
| } |
| jmxManagerAccessFile = value; |
| } |
| |
| @Override |
| public int getJmxManagerHttpPort() { |
| return getHttpServicePort(); |
| } |
| |
| @Override |
| public void setJmxManagerHttpPort(int value) { |
| setHttpServicePort(value); |
| } |
| |
| @Override |
| public int getJmxManagerUpdateRate() { |
| return jmxManagerUpdateRate; |
| } |
| |
| @Override |
| public void setJmxManagerUpdateRate(int value) { |
| jmxManagerUpdateRate = value; |
| } |
| |
| @Override |
| public boolean getLockMemory() { |
| return lockMemory; |
| } |
| |
| @Override |
| public void setLockMemory(final boolean value) { |
| lockMemory = value; |
| } |
| |
| @Override |
| public void setShiroInit(String value) { |
| shiroInit = value; |
| } |
| |
| @Override |
| public String getShiroInit() { |
| return shiroInit; |
| } |
| |
| @Override |
| public String getClusterSSLAlias() { |
| return clusterSSLAlias; |
| } |
| |
| @Override |
| public void setClusterSSLAlias(final String alias) { |
| clusterSSLAlias = alias; |
| } |
| |
| @Override |
| public String getLocatorSSLAlias() { |
| return locatorSSLAlias; |
| } |
| |
| @Override |
| public void setLocatorSSLAlias(final String alias) { |
| locatorSSLAlias = alias; |
| } |
| |
| @Override |
| public String getGatewaySSLAlias() { |
| return gatewaySSLAlias; |
| } |
| |
| @Override |
| public void setGatewaySSLAlias(final String alias) { |
| gatewaySSLAlias = alias; |
| } |
| |
| @Override |
| public String getHTTPServiceSSLAlias() { |
| return httpServiceSSLAlias; |
| } |
| |
| @Override |
| public void setHTTPServiceSSLAlias(final String alias) { |
| httpServiceSSLAlias = alias; |
| } |
| |
| @Override |
| public String getJMXSSLAlias() { |
| return jmxManagerSSLAlias; |
| } |
| |
| @Override |
| public void setJMXSSLAlias(final String alias) { |
| jmxManagerSSLAlias = alias; |
| } |
| |
| @Override |
| public String getServerSSLAlias() { |
| return serverSSLAlias; |
| } |
| |
| @Override |
| public void setServerSSLAlias(final String alias) { |
| serverSSLAlias = alias; |
| } |
| |
| @Override |
| public boolean getSSLEndPointIdentificationEnabled() { |
| // sslEndPointIdentificationEnabled is a boxed boolean and no default value is set, so that |
| // we can differentiate between an assigned default vs user provided override. This is set |
| // to true when ssl-use-default-context is true or else its false. So return false if its null. |
| if (this.sslEndPointIdentificationEnabled == null) { |
| return false; |
| } |
| return sslEndPointIdentificationEnabled; |
| } |
| |
| @Override |
| public void setSSLEndPointIdentificationEnabled(final boolean sslEndPointIdentificationEnabled) { |
| this.sslEndPointIdentificationEnabled = sslEndPointIdentificationEnabled; |
| } |
| |
| @Override |
| public SecurableCommunicationChannel[] getSecurableCommunicationChannels() { |
| return securableCommunicationChannels; |
| } |
| |
| @Override |
| public void setSecurableCommunicationChannels( |
| final SecurableCommunicationChannel[] sslEnabledComponents) { |
| securableCommunicationChannels = sslEnabledComponents; |
| } |
| |
| @Override |
| public boolean getSSLUseDefaultContext() { |
| return sslUseDefaultSSLContext; |
| } |
| |
| @Override |
| public void setSSLUseDefaultContext(final boolean sslUseDefaultSSLContext) { |
| if (this.sslEndPointIdentificationEnabled == null) { |
| this.sslEndPointIdentificationEnabled = Boolean.TRUE; |
| } |
| this.sslUseDefaultSSLContext = sslUseDefaultSSLContext; |
| } |
| |
| @Override |
| public String getSSLProtocols() { |
| return sslProtocols; |
| } |
| |
| @Override |
| public void setSSLProtocols(final String protocols) { |
| // This conversion is required due to backwards compatibility of the existing protocols code |
| sslProtocols = convertCommaDelimitedToSpaceDelimitedString(protocols); |
| } |
| |
| @Override |
| public String getSSLCiphers() { |
| return sslCiphers; |
| } |
| |
| @Override |
| public void setSSLCiphers(final String ciphers) { |
| // This conversion is required due to backwards compatibility of the existing cipher code |
| sslCiphers = convertCommaDelimitedToSpaceDelimitedString(ciphers); |
| } |
| |
| @Override |
| public boolean getSSLRequireAuthentication() { |
| return sslRequireAuthentication; |
| } |
| |
| @Override |
| public void setSSLRequireAuthentication(final boolean enabled) { |
| sslRequireAuthentication = enabled; |
| } |
| |
| @Override |
| public String getSSLKeyStore() { |
| return sslKeyStore; |
| } |
| |
| @Override |
| public void setSSLKeyStore(final String keyStore) { |
| sslKeyStore = keyStore; |
| } |
| |
| @Override |
| public String getSSLKeyStoreType() { |
| return sslKeyStoreType; |
| } |
| |
| @Override |
| public void setSSLKeyStoreType(final String keyStoreType) { |
| sslKeyStoreType = keyStoreType; |
| } |
| |
| @Override |
| public String getSSLKeyStorePassword() { |
| return sslKeyStorePassword; |
| } |
| |
| @Override |
| public void setSSLKeyStorePassword(final String keyStorePassword) { |
| sslKeyStorePassword = keyStorePassword; |
| } |
| |
| @Override |
| public String getSSLTrustStore() { |
| return sslTrustStore; |
| } |
| |
| @Override |
| public void setSSLTrustStore(final String trustStore) { |
| sslTrustStore = trustStore; |
| } |
| |
| @Override |
| public String getSSLDefaultAlias() { |
| return sslDefaultAlias; |
| } |
| |
| @Override |
| public void setSSLDefaultAlias(final String sslDefaultAlias) { |
| this.sslDefaultAlias = sslDefaultAlias; |
| } |
| |
| @Override |
| public String getSSLTrustStorePassword() { |
| return sslTrustStorePassword; |
| } |
| |
| @Override |
| public void setSSLTrustStorePassword(final String trustStorePassword) { |
| sslTrustStorePassword = trustStorePassword; |
| } |
| |
| @Override |
| public String getSSLTrustStoreType() { |
| return sslTrustStoreType; |
| } |
| |
| @Override |
| public void setSSLTrustStoreType(final String trustStoreType) { |
| sslTrustStoreType = trustStoreType; |
| } |
| |
| @Override |
| public boolean getSSLWebRequireAuthentication() { |
| return sslWebServiceRequireAuthentication; |
| } |
| |
| @Override |
| public void setSSLWebRequireAuthentication(final boolean requiresAuthentication) { |
| sslWebServiceRequireAuthentication = requiresAuthentication; |
| } |
| |
| @Override |
| public boolean getValidateSerializableObjects() { |
| return validateSerializableObjects; |
| } |
| |
| @Override |
| public void setValidateSerializableObjects(boolean value) { |
| validateSerializableObjects = value; |
| } |
| |
| @Override |
| public String getSerializableObjectFilter() { |
| return serializableObjectFilter; |
| } |
| |
| @Override |
| public void setSerializableObjectFilter(String value) { |
| serializableObjectFilter = value; |
| } |
| |
| /** |
| * Two instances of <code>DistributedConfigImpl</code> are equal if all of their configuration |
| * properties are the same. Be careful if you need to remove final and override this. See bug |
| * #50939. |
| */ |
| @Override |
| public boolean equals(final Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| |
| if (obj == null || getClass() != obj.getClass()) { |
| return false; |
| } |
| |
| final DistributionConfigImpl that = (DistributionConfigImpl) obj; |
| |
| return new EqualsBuilder().append(tcpPort, that.tcpPort).append(mcastPort, that.mcastPort) |
| .append(mcastTtl, that.mcastTtl).append(socketLeaseTime, that.socketLeaseTime) |
| .append(socketBufferSize, that.socketBufferSize) |
| .append(conserveSockets, that.conserveSockets).append(locatorWaitTime, that.locatorWaitTime) |
| .append(logLevel, that.logLevel).append(startLocatorPort, that.startLocatorPort) |
| .append(statisticSamplingEnabled, that.statisticSamplingEnabled) |
| .append(statisticSampleRate, that.statisticSampleRate) |
| .append(ackWaitThreshold, that.ackWaitThreshold) |
| .append(ackForceDisconnectThreshold, that.ackForceDisconnectThreshold) |
| .append(archiveDiskSpaceLimit, that.archiveDiskSpaceLimit) |
| .append(archiveFileSizeLimit, that.archiveFileSizeLimit) |
| .append(logDiskSpaceLimit, that.logDiskSpaceLimit) |
| .append(logFileSizeLimit, that.logFileSizeLimit) |
| .append(clusterSSLEnabled, that.clusterSSLEnabled) |
| .append(clusterSSLRequireAuthentication, that.clusterSSLRequireAuthentication) |
| .append(mcastSendBufferSize, that.mcastSendBufferSize) |
| .append(mcastRecvBufferSize, that.mcastRecvBufferSize) |
| .append(udpSendBufferSize, that.udpSendBufferSize) |
| .append(udpRecvBufferSize, that.udpRecvBufferSize) |
| .append(udpFragmentSize, that.udpFragmentSize).append(disableTcp, that.disableTcp) |
| .append(disableJmx, that.disableJmx) |
| .append(enableTimeStatistics, that.enableTimeStatistics) |
| .append(memberTimeout, that.memberTimeout) |
| .append(maxWaitTimeForReconnect, that.maxWaitTimeForReconnect) |
| .append(maxNumReconnectTries, that.maxNumReconnectTries) |
| .append(asyncDistributionTimeout, that.asyncDistributionTimeout) |
| .append(asyncQueueTimeout, that.asyncQueueTimeout) |
| .append(asyncMaxQueueSize, that.asyncMaxQueueSize) |
| .append(durableClientTimeout, that.durableClientTimeout) |
| .append(securityLogLevel, that.securityLogLevel) |
| .append(enableNetworkPartitionDetection, that.enableNetworkPartitionDetection) |
| .append(disableAutoReconnect, that.disableAutoReconnect) |
| .append(securityPeerMembershipTimeout, that.securityPeerMembershipTimeout) |
| .append(removeUnresponsiveClient, that.removeUnresponsiveClient) |
| .append(deltaPropagation, that.deltaPropagation) |
| .append(distributedSystemId, that.distributedSystemId) |
| .append(enforceUniqueHost, that.enforceUniqueHost) |
| .append(enableSharedConfiguration, that.enableSharedConfiguration) |
| .append(useSharedConfiguration, that.useSharedConfiguration) |
| .append(loadSharedConfigurationFromDir, that.loadSharedConfigurationFromDir) |
| .append(httpServicePort, that.httpServicePort).append(startDevRestApi, that.startDevRestApi) |
| .append(memcachedPort, that.memcachedPort) |
| .append(distributedTransactions, that.distributedTransactions) |
| .append(redisPort, that.redisPort).append(jmxManager, that.jmxManager) |
| .append(jmxManagerStart, that.jmxManagerStart).append(jmxManagerPort, that.jmxManagerPort) |
| .append(jmxManagerHttpPort, that.jmxManagerHttpPort) |
| .append(jmxManagerUpdateRate, that.jmxManagerUpdateRate) |
| .append(jmxManagerSSLEnabled, that.jmxManagerSSLEnabled) |
| .append(jmxManagerSslRequireAuthentication, that.jmxManagerSslRequireAuthentication) |
| .append(serverSSLEnabled, that.serverSSLEnabled) |
| .append(serverSslRequireAuthentication, that.serverSslRequireAuthentication) |
| .append(gatewaySSLEnabled, that.gatewaySSLEnabled) |
| .append(gatewaySslRequireAuthentication, that.gatewaySslRequireAuthentication) |
| .append(httpServiceSSLEnabled, that.httpServiceSSLEnabled) |
| .append(httpServiceSSLRequireAuthentication, that.httpServiceSSLRequireAuthentication) |
| .append(sslRequireAuthentication, that.sslRequireAuthentication) |
| .append(sslWebServiceRequireAuthentication, that.sslWebServiceRequireAuthentication) |
| .append(lockMemory, that.lockMemory).append(modifiable, that.modifiable) |
| .append(name, that.name).append(roles, that.roles).append(mcastAddress, that.mcastAddress) |
| .append(bindAddress, that.bindAddress).append(serverBindAddress, that.serverBindAddress) |
| .append(locators, that.locators).append(logFile, that.logFile) |
| .append(deployWorkingDir, that.deployWorkingDir).append(startLocator, that.startLocator) |
| .append(statisticArchiveFile, that.statisticArchiveFile) |
| .append(cacheXmlFile, that.cacheXmlFile) |
| .append(clusterSSLProtocols, that.clusterSSLProtocols) |
| .append(clusterSSLCiphers, that.clusterSSLCiphers) |
| .append(clusterSSLKeyStore, that.clusterSSLKeyStore) |
| .append(clusterSSLKeyStoreType, that.clusterSSLKeyStoreType) |
| .append(clusterSSLKeyStorePassword, that.clusterSSLKeyStorePassword) |
| .append(clusterSSLTrustStore, that.clusterSSLTrustStore) |
| .append(clusterSSLTrustStorePassword, that.clusterSSLTrustStorePassword) |
| .append(clusterSSLAlias, that.clusterSSLAlias) |
| .append(mcastFlowControl, that.mcastFlowControl) |
| .append(membershipPortRange, that.membershipPortRange) |
| .append(clientConflation, that.clientConflation) |
| .append(durableClientId, that.durableClientId) |
| .append(securityClientAuthInit, that.securityClientAuthInit) |
| .append(securityClientAuthenticator, that.securityClientAuthenticator) |
| .append(securityManager, that.securityManager).append(postProcessor, that.postProcessor) |
| .append(securityClientDHAlgo, that.securityClientDHAlgo) |
| .append(securityPeerAuthInit, that.securityPeerAuthInit) |
| .append(securityPeerAuthenticator, that.securityPeerAuthenticator) |
| .append(securityClientAccessor, that.securityClientAccessor) |
| .append(securityClientAccessorPP, that.securityClientAccessorPP) |
| .append(securityLogFile, that.securityLogFile).append(security, that.security) |
| .append(userDefinedProps, that.userDefinedProps).append(props, that.props) |
| .append(remoteLocators, that.remoteLocators).append(redundancyZone, that.redundancyZone) |
| .append(sslProperties, that.sslProperties) |
| .append(clusterSSLProperties, that.clusterSSLProperties).append(groups, that.groups) |
| .append(clusterConfigDir, that.clusterConfigDir) |
| .append(httpServiceBindAddress, that.httpServiceBindAddress) |
| .append(memcachedProtocol, that.memcachedProtocol) |
| .append(memcachedBindAddress, that.memcachedBindAddress) |
| .append(redisBindAddress, that.redisBindAddress).append(redisPassword, that.redisPassword) |
| .append(jmxManagerBindAddress, that.jmxManagerBindAddress) |
| .append(jmxManagerHostnameForClients, that.jmxManagerHostnameForClients) |
| .append(jmxManagerPasswordFile, that.jmxManagerPasswordFile) |
| .append(jmxManagerAccessFile, that.jmxManagerAccessFile) |
| .append(jmxManagerSslProtocols, that.jmxManagerSslProtocols) |
| .append(jmxManagerSslCiphers, that.jmxManagerSslCiphers) |
| .append(jmxManagerSslProperties, that.jmxManagerSslProperties) |
| .append(jmxManagerSSLKeyStore, that.jmxManagerSSLKeyStore) |
| .append(jmxManagerSSLKeyStoreType, that.jmxManagerSSLKeyStoreType) |
| .append(jmxManagerSSLKeyStorePassword, that.jmxManagerSSLKeyStorePassword) |
| .append(jmxManagerSSLTrustStore, that.jmxManagerSSLTrustStore) |
| .append(jmxManagerSSLTrustStorePassword, that.jmxManagerSSLTrustStorePassword) |
| .append(jmxManagerSSLAlias, that.jmxManagerSSLAlias) |
| .append(serverSslProtocols, that.serverSslProtocols) |
| .append(serverSslCiphers, that.serverSslCiphers) |
| .append(serverSslProperties, that.serverSslProperties) |
| .append(serverSSLKeyStore, that.serverSSLKeyStore) |
| .append(serverSSLKeyStoreType, that.serverSSLKeyStoreType) |
| .append(serverSSLKeyStorePassword, that.serverSSLKeyStorePassword) |
| .append(serverSSLTrustStore, that.serverSSLTrustStore) |
| .append(serverSSLTrustStorePassword, that.serverSSLTrustStorePassword) |
| .append(serverSSLAlias, that.serverSSLAlias) |
| .append(gatewaySslProtocols, that.gatewaySslProtocols) |
| .append(gatewaySslCiphers, that.gatewaySslCiphers) |
| .append(gatewaySslProperties, that.gatewaySslProperties) |
| .append(gatewaySSLKeyStore, that.gatewaySSLKeyStore) |
| .append(gatewaySSLKeyStoreType, that.gatewaySSLKeyStoreType) |
| .append(gatewaySSLKeyStorePassword, that.gatewaySSLKeyStorePassword) |
| .append(gatewaySSLTrustStore, that.gatewaySSLTrustStore) |
| .append(gatewaySSLTrustStorePassword, that.gatewaySSLTrustStorePassword) |
| .append(gatewaySSLAlias, that.gatewaySSLAlias) |
| .append(httpServiceSSLProtocols, that.httpServiceSSLProtocols) |
| .append(httpServiceSSLCiphers, that.httpServiceSSLCiphers) |
| .append(httpServiceSSLProperties, that.httpServiceSSLProperties) |
| .append(httpServiceSSLKeyStore, that.httpServiceSSLKeyStore) |
| .append(httpServiceSSLKeyStoreType, that.httpServiceSSLKeyStoreType) |
| .append(httpServiceSSLKeyStorePassword, that.httpServiceSSLKeyStorePassword) |
| .append(httpServiceSSLTrustStore, that.httpServiceSSLTrustStore) |
| .append(httpServiceSSLTrustStorePassword, that.httpServiceSSLTrustStorePassword) |
| .append(httpServiceSSLAlias, that.httpServiceSSLAlias) |
| .append(securableCommunicationChannels, that.securableCommunicationChannels) |
| .append(sslProtocols, that.sslProtocols).append(sslCiphers, that.sslCiphers) |
| .append(sslKeyStore, that.sslKeyStore).append(sslKeyStoreType, that.sslKeyStoreType) |
| .append(sslKeyStorePassword, that.sslKeyStorePassword) |
| .append(sslTrustStore, that.sslTrustStore) |
| .append(sslTrustStorePassword, that.sslTrustStorePassword) |
| .append(locatorSSLAlias, that.locatorSSLAlias).append(sslDefaultAlias, that.sslDefaultAlias) |
| .append(sourceMap, that.sourceMap).append(userCommandPackages, that.userCommandPackages) |
| .append(offHeapMemorySize, that.offHeapMemorySize).append(shiroInit, that.shiroInit) |
| .append(threadMonitorEnabled, that.threadMonitorEnabled) |
| .append(threadMonitorInterval, that.threadMonitorInterval) |
| .append(threadMonitorTimeLimit, that.threadMonitorTimeLimit).isEquals(); |
| } |
| |
| /** |
| * The hash code of a <code>DistributionConfigImpl</code> is based on the value of all of its |
| * configuration properties. Be careful if you need to remove final and override this. See bug |
| * #50939. |
| */ |
| @Override |
| public int hashCode() { |
| return new HashCodeBuilder(17, 37).append(name).append(tcpPort).append(mcastPort) |
| .append(mcastTtl).append(socketLeaseTime).append(socketBufferSize).append(conserveSockets) |
| .append(roles).append(mcastAddress).append(bindAddress).append(serverBindAddress) |
| .append(locators).append(locatorWaitTime).append(logFile).append(deployWorkingDir) |
| .append(logLevel).append(startLocator).append(startLocatorPort) |
| .append(statisticSamplingEnabled).append(statisticSampleRate).append(statisticArchiveFile) |
| .append(ackWaitThreshold).append(ackForceDisconnectThreshold).append(cacheXmlFile) |
| .append(archiveDiskSpaceLimit).append(archiveFileSizeLimit).append(logDiskSpaceLimit) |
| .append(logFileSizeLimit).append(clusterSSLEnabled).append(clusterSSLProtocols) |
| .append(clusterSSLCiphers).append(clusterSSLRequireAuthentication) |
| .append(clusterSSLKeyStore).append(clusterSSLKeyStoreType) |
| .append(clusterSSLKeyStorePassword).append(clusterSSLTrustStore) |
| .append(clusterSSLTrustStorePassword).append(clusterSSLAlias).append(mcastSendBufferSize) |
| .append(mcastRecvBufferSize).append(mcastFlowControl).append(udpSendBufferSize) |
| .append(udpRecvBufferSize).append(udpFragmentSize).append(disableTcp).append(disableJmx) |
| .append(enableTimeStatistics).append(memberTimeout).append(membershipPortRange) |
| .append(maxWaitTimeForReconnect).append(maxNumReconnectTries) |
| .append(asyncDistributionTimeout).append(asyncQueueTimeout).append(asyncMaxQueueSize) |
| .append(clientConflation).append(durableClientId).append(durableClientTimeout) |
| .append(securityClientAuthInit).append(securityClientAuthenticator).append(securityManager) |
| .append(postProcessor).append(securityClientDHAlgo).append(securityPeerAuthInit) |
| .append(securityPeerAuthenticator).append(securityClientAccessor) |
| .append(securityClientAccessorPP).append(securityLogLevel) |
| .append(enableNetworkPartitionDetection).append(disableAutoReconnect) |
| .append(securityLogFile).append(securityPeerMembershipTimeout).append(security) |
| .append(userDefinedProps).append(removeUnresponsiveClient).append(deltaPropagation) |
| .append(props).append(distributedSystemId).append(remoteLocators).append(enforceUniqueHost) |
| .append(redundancyZone).append(sslProperties).append(clusterSSLProperties).append(groups) |
| .append(enableSharedConfiguration).append(useSharedConfiguration) |
| .append(loadSharedConfigurationFromDir).append(clusterConfigDir).append(httpServicePort) |
| .append(httpServiceBindAddress).append(startDevRestApi).append(memcachedPort) |
| .append(memcachedProtocol).append(memcachedBindAddress).append(distributedTransactions) |
| .append(redisPort).append(redisBindAddress).append(redisPassword).append(jmxManager) |
| .append(jmxManagerStart).append(jmxManagerPort).append(jmxManagerBindAddress) |
| .append(jmxManagerHostnameForClients).append(jmxManagerPasswordFile) |
| .append(jmxManagerAccessFile).append(jmxManagerHttpPort).append(jmxManagerUpdateRate) |
| .append(jmxManagerSSLEnabled).append(jmxManagerSslRequireAuthentication) |
| .append(jmxManagerSslProtocols).append(jmxManagerSslCiphers).append(jmxManagerSslProperties) |
| .append(jmxManagerSSLKeyStore).append(jmxManagerSSLKeyStoreType) |
| .append(jmxManagerSSLKeyStorePassword).append(jmxManagerSSLTrustStore) |
| .append(jmxManagerSSLTrustStorePassword).append(jmxManagerSSLAlias).append(serverSSLEnabled) |
| .append(serverSslRequireAuthentication).append(serverSslProtocols).append(serverSslCiphers) |
| .append(serverSslProperties).append(serverSSLKeyStore).append(serverSSLKeyStoreType) |
| .append(serverSSLKeyStorePassword).append(serverSSLTrustStore) |
| .append(serverSSLTrustStorePassword).append(serverSSLAlias).append(gatewaySSLEnabled) |
| .append(gatewaySslRequireAuthentication).append(gatewaySslProtocols) |
| .append(gatewaySslCiphers).append(gatewaySslProperties).append(gatewaySSLKeyStore) |
| .append(gatewaySSLKeyStoreType).append(gatewaySSLKeyStorePassword) |
| .append(gatewaySSLTrustStore).append(gatewaySSLTrustStorePassword).append(gatewaySSLAlias) |
| .append(httpServiceSSLEnabled).append(httpServiceSSLRequireAuthentication) |
| .append(httpServiceSSLProtocols).append(httpServiceSSLCiphers) |
| .append(httpServiceSSLProperties).append(httpServiceSSLKeyStore) |
| .append(httpServiceSSLKeyStoreType).append(httpServiceSSLKeyStorePassword) |
| .append(httpServiceSSLTrustStore).append(httpServiceSSLTrustStorePassword) |
| .append(httpServiceSSLAlias).append(securableCommunicationChannels).append(sslProtocols) |
| .append(sslCiphers).append(sslRequireAuthentication).append(sslKeyStore) |
| .append(sslKeyStoreType).append(sslKeyStorePassword).append(sslTrustStore) |
| .append(sslTrustStorePassword).append(sslWebServiceRequireAuthentication) |
| .append(locatorSSLAlias).append(sslDefaultAlias).append(sourceMap) |
| .append(userCommandPackages).append(offHeapMemorySize).append(lockMemory).append(shiroInit) |
| .append(modifiable).append(threadMonitorEnabled).append(threadMonitorInterval) |
| .append(threadMonitorTimeLimit).toHashCode(); |
| } |
| |
| /** |
| * For dunit tests we do not allow use of the default multicast address/port. Please use |
| * AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS) to obtain a free port for your |
| * test. |
| */ |
| void checkForDisallowedDefaults() { |
| if (Boolean.getBoolean(DistributionConfig.GEMFIRE_PREFIX + "disallowMcastDefaults")) { |
| if (getMcastPort() != 0) { // it is not disabled |
| if (getMcastAddress().equals(DistributionConfig.DEFAULT_MCAST_ADDRESS) |
| && getMcastPort() == DistributionConfig.DEFAULT_MCAST_PORT) { |
| throw new IllegalStateException(DistributionConfig.GEMFIRE_PREFIX |
| + "disallowMcastDefaults set and default address and port are being used"); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public int[] getMembershipPortRange() { |
| return membershipPortRange; |
| } |
| |
| @Override |
| public void setMembershipPortRange(int[] range) { |
| membershipPortRange = range; |
| } |
| |
| /** |
| * Set the host-port information of remote site locator |
| */ |
| @Override |
| public void setRemoteLocators(String locators) { |
| remoteLocators = locators; |
| } |
| |
| /** |
| * get the host-port information of remote site locator |
| */ |
| @Override |
| public String getRemoteLocators() { |
| return remoteLocators; |
| } |
| |
| public Map getProps() { |
| return props; |
| } |
| |
| @Override |
| public int getMemcachedPort() { |
| return memcachedPort; |
| } |
| |
| @Override |
| public void setMemcachedPort(int value) { |
| memcachedPort = value; |
| } |
| |
| @Override |
| public String getMemcachedProtocol() { |
| return memcachedProtocol; |
| } |
| |
| @Override |
| public void setMemcachedProtocol(String protocol) { |
| memcachedProtocol = protocol; |
| } |
| |
| @Override |
| public int getRedisPort() { |
| return redisPort; |
| } |
| |
| @Override |
| public void setRedisPort(int value) { |
| redisPort = value; |
| } |
| |
| @Override |
| public String getRedisBindAddress() { |
| return redisBindAddress; |
| } |
| |
| @Override |
| public void setRedisBindAddress(String bindAddress) { |
| redisBindAddress = bindAddress; |
| } |
| |
| @Override |
| public String getRedisPassword() { |
| return redisPassword; |
| } |
| |
| @Override |
| public void setRedisPassword(String password) { |
| redisPassword = password; |
| } |
| |
| @Override |
| public String getOffHeapMemorySize() { |
| return offHeapMemorySize; |
| } |
| |
| @Override |
| public void setOffHeapMemorySize(String value) { |
| offHeapMemorySize = value; |
| } |
| |
| @Override |
| public String getMemcachedBindAddress() { |
| return memcachedBindAddress; |
| } |
| |
| @Override |
| public void setMemcachedBindAddress(String bindAddress) { |
| memcachedBindAddress = bindAddress; |
| } |
| |
| @Override |
| public void setEnableClusterConfiguration(boolean newValue) { |
| enableSharedConfiguration = newValue; |
| } |
| |
| @Override |
| public boolean getEnableClusterConfiguration() { |
| return enableSharedConfiguration; |
| } |
| |
| |
| @Override |
| public void setUseSharedConfiguration(boolean newValue) { |
| useSharedConfiguration = newValue; |
| } |
| |
| @Override |
| public boolean getEnableManagementRestService() { |
| return enableManagementRestService; |
| } |
| |
| @Override |
| public void setEnableManagementRestService(boolean enableManagementRestService) { |
| this.enableManagementRestService = enableManagementRestService; |
| } |
| |
| @Override |
| public boolean getUseSharedConfiguration() { |
| return useSharedConfiguration; |
| } |
| |
| @Override |
| public void setLoadClusterConfigFromDir(boolean newValue) { |
| loadSharedConfigurationFromDir = newValue; |
| } |
| |
| @Override |
| public boolean getLoadClusterConfigFromDir() { |
| return loadSharedConfigurationFromDir; |
| } |
| |
| @Override |
| public void setClusterConfigDir(String clusterConfigDir) { |
| this.clusterConfigDir = clusterConfigDir; |
| } |
| |
| @Override |
| public String getClusterConfigDir() { |
| return clusterConfigDir; |
| } |
| |
| @Override |
| public boolean getServerSSLEnabled() { |
| return serverSSLEnabled; |
| } |
| |
| @Override |
| public void setServerSSLEnabled(boolean enabled) { |
| serverSSLEnabled = enabled; |
| |
| } |
| |
| @Override |
| public boolean getServerSSLRequireAuthentication() { |
| return serverSslRequireAuthentication; |
| } |
| |
| @Override |
| public void setServerSSLRequireAuthentication(boolean enabled) { |
| serverSslRequireAuthentication = enabled; |
| } |
| |
| @Override |
| public String getServerSSLProtocols() { |
| return serverSslProtocols; |
| } |
| |
| @Override |
| public void setServerSSLProtocols(String protocols) { |
| serverSslProtocols = protocols; |
| } |
| |
| @Override |
| public String getServerSSLCiphers() { |
| return serverSslCiphers; |
| } |
| |
| @Override |
| public void setServerSSLCiphers(String ciphers) { |
| serverSslCiphers = ciphers; |
| } |
| |
| @Override |
| public void setServerSSLKeyStore(String keyStore) { |
| getServerSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_NAME, keyStore); |
| serverSSLKeyStore = keyStore; |
| } |
| |
| @Override |
| public void setServerSSLKeyStoreType(String keyStoreType) { |
| getServerSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_TYPE_NAME, keyStoreType); |
| serverSSLKeyStoreType = keyStoreType; |
| } |
| |
| @Override |
| public void setServerSSLKeyStorePassword(String keyStorePassword) { |
| getServerSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_PASSWORD_NAME, |
| keyStorePassword); |
| serverSSLKeyStorePassword = keyStorePassword; |
| } |
| |
| @Override |
| public void setServerSSLTrustStore(String trustStore) { |
| getServerSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_NAME, trustStore); |
| serverSSLTrustStore = trustStore; |
| } |
| |
| @Override |
| public void setServerSSLTrustStorePassword(String trusStorePassword) { |
| getServerSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_PASSWORD_NAME, |
| trusStorePassword); |
| serverSSLTrustStorePassword = trusStorePassword; |
| } |
| |
| @Override |
| public String getServerSSLKeyStore() { |
| return serverSSLKeyStore; |
| } |
| |
| @Override |
| public String getServerSSLKeyStoreType() { |
| return serverSSLKeyStoreType; |
| } |
| |
| @Override |
| public String getServerSSLKeyStorePassword() { |
| return serverSSLKeyStorePassword; |
| } |
| |
| @Override |
| public String getServerSSLTrustStore() { |
| return serverSSLTrustStore; |
| } |
| |
| @Override |
| public String getServerSSLTrustStorePassword() { |
| return serverSSLTrustStorePassword; |
| } |
| |
| @Override |
| public Properties getServerSSLProperties() { |
| return serverSslProperties; |
| } |
| |
| @Override |
| public boolean getGatewaySSLEnabled() { |
| return gatewaySSLEnabled; |
| } |
| |
| @Override |
| public void setGatewaySSLEnabled(boolean enabled) { |
| gatewaySSLEnabled = enabled; |
| |
| } |
| |
| @Override |
| public boolean getGatewaySSLRequireAuthentication() { |
| return gatewaySslRequireAuthentication; |
| } |
| |
| @Override |
| public void setGatewaySSLRequireAuthentication(boolean enabled) { |
| gatewaySslRequireAuthentication = enabled; |
| } |
| |
| @Override |
| public String getGatewaySSLProtocols() { |
| return gatewaySslProtocols; |
| } |
| |
| @Override |
| public void setGatewaySSLProtocols(String protocols) { |
| gatewaySslProtocols = protocols; |
| } |
| |
| @Override |
| public String getGatewaySSLCiphers() { |
| return gatewaySslCiphers; |
| } |
| |
| @Override |
| public void setGatewaySSLCiphers(String ciphers) { |
| gatewaySslCiphers = ciphers; |
| } |
| |
| @Override |
| public void setGatewaySSLKeyStore(String keyStore) { |
| getGatewaySSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_NAME, keyStore); |
| gatewaySSLKeyStore = keyStore; |
| } |
| |
| @Override |
| public void setGatewaySSLKeyStoreType(String keyStoreType) { |
| getGatewaySSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_TYPE_NAME, |
| keyStoreType); |
| gatewaySSLKeyStoreType = keyStoreType; |
| } |
| |
| @Override |
| public void setGatewaySSLKeyStorePassword(String keyStorePassword) { |
| getGatewaySSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_PASSWORD_NAME, |
| keyStorePassword); |
| gatewaySSLKeyStorePassword = keyStorePassword; |
| } |
| |
| @Override |
| public void setGatewaySSLTrustStore(String trustStore) { |
| getGatewaySSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_NAME, trustStore); |
| gatewaySSLTrustStore = trustStore; |
| } |
| |
| @Override |
| public void setGatewaySSLTrustStorePassword(String trusStorePassword) { |
| getGatewaySSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_PASSWORD_NAME, |
| trusStorePassword); |
| gatewaySSLTrustStorePassword = trusStorePassword; |
| } |
| |
| @Override |
| public String getGatewaySSLKeyStore() { |
| return gatewaySSLKeyStore; |
| } |
| |
| @Override |
| public String getGatewaySSLKeyStoreType() { |
| return gatewaySSLKeyStoreType; |
| } |
| |
| @Override |
| public String getGatewaySSLKeyStorePassword() { |
| return gatewaySSLKeyStorePassword; |
| } |
| |
| @Override |
| public String getGatewaySSLTrustStore() { |
| return gatewaySSLTrustStore; |
| } |
| |
| @Override |
| public String getGatewaySSLTrustStorePassword() { |
| return gatewaySSLTrustStorePassword; |
| } |
| |
| @Override |
| public Properties getGatewaySSLProperties() { |
| return gatewaySslProperties; |
| } |
| |
| @Override |
| public boolean getHttpServiceSSLEnabled() { |
| return httpServiceSSLEnabled; |
| } |
| |
| @Override |
| public void setHttpServiceSSLEnabled(boolean httpServiceSSLEnabled) { |
| this.httpServiceSSLEnabled = httpServiceSSLEnabled; |
| } |
| |
| @Override |
| public boolean getHttpServiceSSLRequireAuthentication() { |
| return httpServiceSSLRequireAuthentication; |
| } |
| |
| @Override |
| public void setHttpServiceSSLRequireAuthentication(boolean httpServiceSSLRequireAuthentication) { |
| this.httpServiceSSLRequireAuthentication = httpServiceSSLRequireAuthentication; |
| } |
| |
| @Override |
| public String getHttpServiceSSLProtocols() { |
| return httpServiceSSLProtocols; |
| } |
| |
| @Override |
| public void setHttpServiceSSLProtocols(String protocols) { |
| httpServiceSSLProtocols = protocols; |
| } |
| |
| @Override |
| public String getHttpServiceSSLCiphers() { |
| return httpServiceSSLCiphers; |
| } |
| |
| @Override |
| public void setHttpServiceSSLCiphers(String ciphers) { |
| httpServiceSSLCiphers = ciphers; |
| } |
| |
| @Override |
| public String getHttpServiceSSLKeyStore() { |
| return httpServiceSSLKeyStore; |
| } |
| |
| @Override |
| public void setHttpServiceSSLKeyStore(String keyStore) { |
| getHttpServiceSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_NAME, |
| keyStore); |
| httpServiceSSLKeyStore = keyStore; |
| } |
| |
| @Override |
| public String getHttpServiceSSLKeyStoreType() { |
| return httpServiceSSLKeyStoreType; |
| } |
| |
| @Override |
| public void setHttpServiceSSLKeyStoreType(String keyStoreType) { |
| getHttpServiceSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_TYPE_NAME, |
| keyStoreType); |
| httpServiceSSLKeyStoreType = keyStoreType; |
| } |
| |
| @Override |
| public String getHttpServiceSSLKeyStorePassword() { |
| return httpServiceSSLKeyStorePassword; |
| } |
| |
| @Override |
| public void setHttpServiceSSLKeyStorePassword(String keyStorePassword) { |
| getHttpServiceSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + KEY_STORE_PASSWORD_NAME, |
| keyStorePassword); |
| httpServiceSSLKeyStorePassword = keyStorePassword; |
| } |
| |
| @Override |
| public String getHttpServiceSSLTrustStore() { |
| return httpServiceSSLTrustStore; |
| } |
| |
| @Override |
| public void setHttpServiceSSLTrustStore(String trustStore) { |
| getHttpServiceSSLProperties().setProperty(SSL_SYSTEM_PROPS_NAME + TRUST_STORE_NAME, |
| trustStore); |
| httpServiceSSLTrustStore = trustStore; |
| } |
| |
| @Override |
| public String getHttpServiceSSLTrustStorePassword() { |
| return httpServiceSSLTrustStorePassword; |
| } |
| |
| @Override |
| public void setHttpServiceSSLTrustStorePassword(String trustStorePassword) { |
| getHttpServiceSSLProperties().setProperty( |
| SSL_SYSTEM_PROPS_NAME + TRUST_STORE_PASSWORD_NAME, trustStorePassword); |
| httpServiceSSLTrustStorePassword = trustStorePassword; |
| } |
| |
| @Override |
| public Properties getHttpServiceSSLProperties() { |
| return httpServiceSSLProperties; |
| } |
| |
| @Override |
| public ConfigSource getConfigSource(String attName) { |
| return sourceMap.get(attName); |
| } |
| |
| @Override |
| public boolean getDistributedTransactions() { |
| return distributedTransactions; |
| } |
| |
| @Override |
| public void setDistributedTransactions(boolean value) { |
| distributedTransactions = value; |
| } |
| |
| @Override |
| public boolean getThreadMonitorEnabled() { |
| return threadMonitorEnabled; |
| } |
| |
| @Override |
| public void setThreadMonitorEnabled(boolean newValue) { |
| threadMonitorEnabled = newValue; |
| } |
| |
| @Override |
| public int getThreadMonitorInterval() { |
| return threadMonitorInterval; |
| } |
| |
| @Override |
| public void setThreadMonitorInterval(int newValue) { |
| threadMonitorInterval = newValue; |
| } |
| |
| @Override |
| public int getThreadMonitorTimeLimit() { |
| return threadMonitorTimeLimit; |
| } |
| |
| @Override |
| public void setThreadMonitorTimeLimit(int newValue) { |
| threadMonitorTimeLimit = newValue; |
| } |
| } |
