org.gridgain.client.GridClientConfiguration Maven / Gradle / Ivy
/*
Copyright (C) GridGain Systems. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/* _________ _____ __________________ _____
* __ ____/___________(_)______ /__ ____/______ ____(_)_______
* _ / __ __ ___/__ / _ __ / _ / __ _ __ `/__ / __ __ \
* / /_/ / _ / _ / / /_/ / / /_/ / / /_/ / _ / _ / / /
* \____/ /_/ /_/ \_,__/ \____/ \__,_/ /_/ /_/ /_/
*/
package org.gridgain.client;
import org.gridgain.client.balancer.*;
import org.gridgain.client.marshaller.*;
import org.gridgain.client.marshaller.jdk.*;
import org.gridgain.client.marshaller.optimized.*;
import org.gridgain.client.marshaller.protobuf.*;
import org.gridgain.client.ssl.*;
import org.jetbrains.annotations.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;
import static org.apache.commons.lang.StringUtils.*;
/**
* Java client configuration.
*/
public class GridClientConfiguration {
/** Default client protocol. */
public static final GridClientProtocol DFLT_CLIENT_PROTOCOL = GridClientProtocol.TCP;
/** Default topology refresh frequency is 2 sec. */
public static final int DFLT_TOP_REFRESH_FREQ = 2000;
/** Default maximum time connection can be idle. */
public static final long DFLT_MAX_CONN_IDLE_TIME = 30000;
/** Default ping interval in milliseconds. */
public static final long DFLT_PING_INTERVAL = 5000;
/** Default ping timeout in milliseconds. */
public static final long DFLT_PING_TIMEOUT = 7000;
/** Default connect timeout in milliseconds. */
public static final int DFLT_CONNECT_TIMEOUT = 10000;
/** Default flag setting for TCP_NODELAY option. */
public static final boolean DFLT_TCP_NODELAY = true;
/** List of servers to connect to. */
private Collection srvs = Collections.emptySet();
/** List of routers to connect to. */
private Collection routers = Collections.emptySet();
/** Client protocol. */
private GridClientProtocol proto = DFLT_CLIENT_PROTOCOL;
/** Socket connect timeout. */
private int connectTimeout = DFLT_CONNECT_TIMEOUT;
/** TCP_NODELAY flag. */
private boolean tcpNoDelay = DFLT_TCP_NODELAY;
/** SSL context factory */
private GridSslContextFactory sslCtxFactory;
/** Flag indicating whether metrics cache is enabled. */
private boolean enableMetricsCache = true;
/** Flag indicating whether attributes cache is enabled. */
private boolean enableAttrsCache = true;
/** Flag indicating whether metrics should be automatically fetched. */
private boolean autoFetchMetrics = true;
/** Flag indicating whether attributes should be automatically fetched. */
private boolean autoFetchAttrs = true;
/** Topology refresh frequency. */
private long topRefreshFreq = DFLT_TOP_REFRESH_FREQ;
/** Max time of connection idleness. */
private long maxConnIdleTime = DFLT_MAX_CONN_IDLE_TIME;
/** Ping interval. */
private long pingInterval = DFLT_PING_INTERVAL;
/** Ping timeout. */
private long pingTimeout = DFLT_PING_TIMEOUT;
/** Default balancer. */
private GridClientLoadBalancer balancer = new GridClientRandomBalancer();
/** Collection of data configurations. */
private Map dataCfgs = Collections.emptyMap();
/** Credentials. */
private Object cred;
/** Executor. */
private ExecutorService executor;
/** Marshaller. */
private GridClientMarshaller marshaller = new GridClientOptimizedMarshaller();
/**
* Creates default configuration.
*/
public GridClientConfiguration() {
// No-op.
}
/**
* Copy constructor.
*
* @param cfg Configuration to be copied.
*/
public GridClientConfiguration(GridClientConfiguration cfg) {
// Preserve alphabetical order for maintenance;
autoFetchAttrs = cfg.isAutoFetchAttributes();
autoFetchMetrics = cfg.isAutoFetchMetrics();
balancer = cfg.getBalancer();
connectTimeout = cfg.getConnectTimeout();
cred = cfg.getCredentials();
enableAttrsCache = cfg.isEnableAttributesCache();
enableMetricsCache = cfg.isEnableMetricsCache();
executor = cfg.getExecutorService();
maxConnIdleTime = cfg.getMaxConnectionIdleTime();
pingInterval = cfg.getPingInterval();
pingTimeout = cfg.getPingTimeout();
proto = cfg.getProtocol();
routers = cfg.getRouters();
srvs = cfg.getServers();
sslCtxFactory = cfg.getSslContextFactory();
tcpNoDelay = cfg.isTcpNoDelay();
topRefreshFreq = cfg.getTopologyRefreshFrequency();
marshaller = cfg.getMarshaller();
setDataConfigurations(cfg.getDataConfigurations());
}
/**
* Creates properties-based configuration based on passed in properties.
*
* @param in Client configuration in properties format.
* @throws GridClientException If parsing configuration failed.
*/
public GridClientConfiguration(Properties in) throws GridClientException {
this("gg.client", in);
}
/**
* Creates properties-based configuration.
*
* @param prefix Prefix for the client properties.
* @param in Properties map to load configuration from.
* @throws GridClientException If parsing configuration failed.
*/
public GridClientConfiguration(String prefix, Properties in) throws GridClientException {
load(prefix, in);
}
/**
* Collection of {@code 'host:port'} pairs representing
* remote grid servers used to establish initial connection to
* the grid. Once connection is established, GridGain will get
* a full view on grid topology and will be able to connect to
* any available remote node.
*
* Note that only these addresses are used to perform
* topology updates in background and to detect Grid connectivity
* status.
*
* @return Collection of {@code 'host:port'} pairs representing remote
* grid servers.
* @see GridClient#connected()
*/
public Collection getServers() {
return Collections.unmodifiableCollection(srvs);
}
/**
* Collection of {@code 'host:port'} pairs representing
* grid routers used to establish connection to the grid.
*
* Addresses here could be owned by Routers as well as
* by individual Grid nodes. No additional connections
* will be made even if other Grid nodes are available.
*
* This configuration mode is designated for cases when
* some Grid nodes are unavailable (due to security restrictions
* for example). So only few nodes acting as routers or
* dedicated router components used to access entire Grid.
*
* This configuration parameter will not be used and direct
* connections to all grid nodes will be established if
* {@link #getServers()} return non-empty collection value.
*
* Note that only these addresses are used to perform
* topology updates in background and to detect Grid connectivity
* status.
*
* @return Collection of {@code 'host:port'} pairs
* representing routers.
* @see GridClient#connected()
*/
public Collection getRouters() {
return routers;
}
/**
* Sets list of servers this client should connect to.
*
* @param srvs List of servers.
*/
public void setServers(Collection srvs) {
this.srvs = srvs != null ? srvs : Collections.emptySet();
}
/**
* Sets list of routers this client should connect to.
*
* @param routers List of routers.
*/
public void setRouters(Collection routers) {
this.routers = routers != null ? routers : Collections.emptySet();
}
/**
* Gets protocol for communication between client and remote grid.
* Default is defined by {@link #DFLT_CLIENT_PROTOCOL} constant.
*
* @return Protocol for communication between client and remote grid.
*/
public GridClientProtocol getProtocol() {
return proto;
}
/**
* Sets protocol type that should be used in communication. Protocol type cannot be changed after
* client is created.
*
* @param proto Protocol type.
* @see GridClientProtocol
*/
public void setProtocol(GridClientProtocol proto) {
this.proto = proto;
}
/**
* Gets timeout for socket connect operation in milliseconds. If {@code 0} -
* then wait infinitely. Default is defined by {@link #DFLT_CONNECT_TIMEOUT} constant.
*
* @return Connect timeout in milliseconds.
*/
public int getConnectTimeout() {
return connectTimeout;
}
/**
* Gets flag indicating whether {@code TCP_NODELAY} flag should be enabled for outgoing connections.
* This flag reduces communication latency and in the majority of cases should be set to true. For more
* information, see {@link Socket#setTcpNoDelay(boolean)}
*
* If not set, default value is {@link #DFLT_TCP_NODELAY}
*
* @return If {@code TCP_NODELAY} should be set on underlying sockets.
*/
public boolean isTcpNoDelay() {
return tcpNoDelay;
}
/**
* Sets whether {@code TCP_NODELAY} flag should be set on underlying socket connections.
*
* @param tcpNoDelay {@code True} if flag should be set.
*/
public void setTcpNoDelay(boolean tcpNoDelay) {
this.tcpNoDelay = tcpNoDelay;
}
/**
* Sets timeout for socket connect operation.
*
* @param connectTimeout Connect timeout in milliseconds.
*/
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
/**
* Gets a factory that should be used for SSL context creation.
* If it returns {@code null} then SSL is considered disabled.
*
* @return Factory instance.
* @see GridSslContextFactory
*/
public GridSslContextFactory getSslContextFactory() {
return sslCtxFactory;
}
/**
* Sets SSL context factory that will be used for creation of secure connections.
*
* @param sslCtxFactory Context factory.
*/
public void setSslContextFactory(GridSslContextFactory sslCtxFactory) {
this.sslCtxFactory = sslCtxFactory;
}
/**
* Default balancer to be used for computational client. It can be overridden
* for different compute instances. By default {@link GridClientRandomBalancer}
* is used.
*
* @return Default balancer to be used for computational client.
*/
public GridClientLoadBalancer getBalancer() {
return balancer;
}
/**
* Sets default compute balancer.
*
* @param balancer Balancer to use.
*/
public void setBalancer(GridClientLoadBalancer balancer) {
this.balancer = balancer;
}
/**
* Gets client credentials to authenticate with.
*
* @return Credentials object (possibly {@code null})
*/
public Object getCredentials() {
return cred;
}
/**
* Sets client credentials object used in authentication process.
*
* @param cred Client credentials.
*/
public void setCredentials(Object cred) {
this.cred = cred;
}
/**
* Gets a collection of data configurations specified by user.
*
* @return Collection of data configurations (possibly empty).
*/
public Collection getDataConfigurations() {
return dataCfgs.values();
}
/**
* Sets data configurations.
*
* @param dataCfgs Data configurations.
*/
public void setDataConfigurations(Collection dataCfgs) {
this.dataCfgs = new HashMap<>(dataCfgs.size());
for (GridClientDataConfiguration dataCfg : dataCfgs)
this.dataCfgs.put(dataCfg.getName(), new GridClientDataConfiguration(dataCfg));
}
/**
* Gets data configuration for a cache with specified name.
*
* @param name Name of grid cache.
* @return Configuration or {@code null} if there is not configuration for specified name.
*/
public GridClientDataConfiguration getDataConfiguration(@Nullable String name) {
return dataCfgs.get(name);
}
/**
* Sets flag indicating whether node and cache metrics should be cached by client.
*
* @param enableMetricsCache {@code True} if cache should be enabled.
*/
public void setEnableMetricsCache(boolean enableMetricsCache) {
this.enableMetricsCache = enableMetricsCache;
}
/**
* Enables client to cache per-node and per-cache metrics internally. In memory
* sensitive environments, such as mobile platforms, caching metrics
* may be expensive and, hence, this parameter should be set to {@code false}.
*
* Note that topology is refreshed automatically every {@link #getTopologyRefreshFrequency()}
* interval, and if {@link #isAutoFetchMetrics()} enabled then metrics will be updated
* with that frequency.
*
* By default this value is {@code true} which means that metrics will be cached
* on the client side.
*
* @return {@code True} if metrics cache is enabled, {@code false} otherwise.
*/
public boolean isEnableMetricsCache() {
return enableMetricsCache;
}
/**
* Sets flag indicating whether node attributes should be cached by client.
*
* @param enableAttrsCache {@code True} if cache should be enabled.
*/
public void setEnableAttributesCache(boolean enableAttrsCache) {
this.enableAttrsCache = enableAttrsCache;
}
/**
* Enables client to cache per-node attributes internally. In memory
* sensitive environments, such as mobile platforms, caching node attributes
* may be expensive and, hence, this parameter should be set to {@code false}.
*
* Note that node attributes are static and, if cached, there is no need
* to refresh them again. If {@link #isAutoFetchAttributes()} is enabled then
* attributes will be cached during client initialization.
*
* By default this value is {@code true} which means that node attributes
* will be cached on the client side.
*
* @return {@code True} if attributes cache is enabled, {@code false} otherwise.
*/
public boolean isEnableAttributesCache() {
return enableAttrsCache;
}
/**
* Sets flag indicating whether node metrics should be fetched by client automatically.
*
* @param autoFetchMetrics {@code True} if metrics should be fetched.
*/
public void setAutoFetchMetrics(boolean autoFetchMetrics) {
this.autoFetchMetrics = autoFetchMetrics;
}
/**
* Allows client to fetch node metrics automatically with background topology refresh.
*
* Note that this parameter will only affect auto-fetching of node metrics.
* Cache metrics still need to be fetched explicitly via
* {@link GridClientData#metrics()} or {@link GridClientData#metricsAsync()} methods.
*
* By default this value is {@code true} which means that metrics will be fetched
* automatically.
*
* @return {@code true} if client should fetch metrics on topology refresh,
* {@code false} otherwise.
*/
public boolean isAutoFetchMetrics() {
return autoFetchMetrics;
}
/**
* Sets flag indicating whether node attributes should be fetched by client automatically.
*
* @param autoFetchAttrs {@code True} if attributes should be fetched.
*/
public void setAutoFetchAttributes(boolean autoFetchAttrs) {
this.autoFetchAttrs = autoFetchAttrs;
}
/**
* Allows client to fetch node attributes automatically with background topology refresh.
*
* By default this value is {@code true} which means that attributes will be fetched
* automatically.
*
* @return {@code True} if client should fetch attributes once on topology refresh,
* {@code false} otherwise.
*/
public boolean isAutoFetchAttributes() {
return autoFetchAttrs;
}
/**
* Gets topology refresh frequency. Default is defined by {@link #DFLT_TOP_REFRESH_FREQ}
* constant.
*
* @return Topology refresh frequency.
*/
public long getTopologyRefreshFrequency() {
return topRefreshFreq;
}
/**
* Sets topology refresh frequency. If topology cache is enabled, grid topology
* will be refreshed every {@code topRefreshFreq} milliseconds.
*
* @param topRefreshFreq Topology refresh frequency in milliseconds.
*/
public void setTopologyRefreshFrequency(long topRefreshFreq) {
this.topRefreshFreq = topRefreshFreq;
}
/**
* Gets maximum amount of time that client connection can be idle before it is closed.
* Default is defined by {@link #DFLT_MAX_CONN_IDLE_TIME} constant.
*
* @return Maximum idle time in milliseconds.
*/
public long getMaxConnectionIdleTime() {
return maxConnIdleTime;
}
/**
* Sets maximum time in milliseconds which connection can be idle before it is closed by client.
*
* @param maxConnIdleTime Maximum time of connection idleness in milliseconds.
*/
public void setMaxConnectionIdleTime(long maxConnIdleTime) {
this.maxConnIdleTime = maxConnIdleTime;
}
/**
* Gets time interval in milliseconds between ping requests. Default is defined
* by {@link #DFLT_PING_INTERVAL} constant.
*
* Ping requests used by {@link GridClientProtocol#TCP} protocol
* to detect network failures and half-opened sockets.
*
* @return Ping interval.
*/
public long getPingInterval() {
return pingInterval;
}
/**
* Sets ping interval in milliseconds.
*
* @param pingInterval Ping interval in milliseconds.
*/
public void setPingInterval(long pingInterval) {
this.pingInterval = pingInterval;
}
/**
* Gets ping timeout. Default is defined by {@link #DFLT_PING_TIMEOUT} constant.
*
* Ping requests used by {@link GridClientProtocol#TCP} protocol
* to detect network failures and half-opened sockets.
* If no response received in period equal to this timeout than connection
* considered broken and closed.
*
* @return Ping timeout.
*/
public long getPingTimeout() {
return pingTimeout;
}
/**
* Sets ping timeout in milliseconds.
*
* @param pingTimeout Ping interval in milliseconds.
*/
public void setPingTimeout(long pingTimeout) {
this.pingTimeout = pingTimeout;
}
/**
* Gets {@link ExecutorService} where client could run asynchronous operations.
*
* When using {@link GridClientProtocol#TCP} this executor should be able to serve at least
* {@code Runtime.getRuntime().availableProcessors()} parallel tasks.
*
* Note that this executor will be automatically shut down when client get closed.
*
* @return {@link ExecutorService} instance to use.
*/
public ExecutorService getExecutorService() {
return executor;
}
/**
* Sets executor service.
*
* @param executor Executor service to use in client.
*/
public void setExecutorService(ExecutorService executor) {
this.executor = executor;
}
/**
* Gets the marshaller, that is used to communicate between client and server.
*
* Options, that can be used out-of-the-box:
*
* - {@link GridClientOptimizedMarshaller} (default) - GridGain's optimized marshaller.
* - {@link GridClientProtobufMarshaller} - marshaller, that uses
* Google Protobuf.
* - {@link GridClientJdkMarshaller} - default JDK marshaller (not recommended).
*
*
* @return A marshaller to use.
*/
public GridClientMarshaller getMarshaller() {
return marshaller;
}
/**
* Sets the marshaller to use for communication.
*
* @param marshaller A marshaller to use.
*/
public void setMarshaller(GridClientMarshaller marshaller) {
this.marshaller = marshaller;
}
/**
* Load client configuration from the properties map.
*
* @param prefix Prefix for the client properties.
* @param in Properties map to load configuration from.
* @throws GridClientException If parsing configuration failed.
*/
public void load(String prefix, Properties in) throws GridClientException {
while (prefix.endsWith("."))
prefix = prefix.substring(0, prefix.length() - 1);
if (!prefix.isEmpty())
prefix += ".";
String balancer = in.getProperty(prefix + "balancer");
String connectTimeout = in.getProperty(prefix + "connectTimeout");
String cred = in.getProperty(prefix + "credentials");
String autoFetchMetrics = in.getProperty(prefix + "autoFetchMetrics");
String autoFetchAttrs = in.getProperty(prefix + "autoFetchAttributes");
String maxConnIdleTime = in.getProperty(prefix + "idleTimeout");
String proto = in.getProperty(prefix + "protocol");
String srvrs = in.getProperty(prefix + "servers");
String tcpNoDelay = in.getProperty(prefix + "tcp.noDelay");
String topRefreshFreq = in.getProperty(prefix + "topology.refresh");
String sslEnabled = in.getProperty(prefix + "ssl.enabled");
String sslProto = in.getProperty(prefix + "ssl.protocol", "TLS");
String sslKeyAlg = in.getProperty(prefix + "ssl.key.algorithm", "SunX509");
String keyStorePath = in.getProperty(prefix + "ssl.keystore.location");
String keyStorePwd = in.getProperty(prefix + "ssl.keystore.password");
String keyStoreType = in.getProperty(prefix + "ssl.keystore.type");
String trustStorePath = in.getProperty(prefix + "ssl.truststore.location");
String trustStorePwd = in.getProperty(prefix + "ssl.truststore.password");
String trustStoreType = in.getProperty(prefix + "ssl.truststore.type");
String dataCfgs = in.getProperty(prefix + "data.configurations");
setBalancer(resolveBalancer(balancer));
if (!isEmpty(connectTimeout))
setConnectTimeout(Integer.parseInt(connectTimeout));
setCredentials(isEmpty(cred) ? null : cred);
if (!isEmpty(autoFetchMetrics))
setAutoFetchMetrics(Boolean.parseBoolean(autoFetchMetrics));
if (!isEmpty(autoFetchAttrs))
setAutoFetchAttributes(Boolean.parseBoolean(autoFetchAttrs));
if (!isEmpty(maxConnIdleTime))
setMaxConnectionIdleTime(Integer.parseInt(maxConnIdleTime));
if (!isEmpty(proto))
setProtocol(GridClientProtocol.valueOf(proto));
if (!isEmpty(srvrs))
setServers(Arrays.asList(srvrs.replaceAll("\\s+", "").split(",")));
if (!isEmpty(tcpNoDelay))
setTcpNoDelay(Boolean.parseBoolean(tcpNoDelay));
if (!isEmpty(topRefreshFreq))
setTopologyRefreshFrequency(Long.parseLong(topRefreshFreq));
//
// SSL configuration section
//
if (!isEmpty(sslEnabled) && Boolean.parseBoolean(sslEnabled)) {
GridSslBasicContextFactory factory = new GridSslBasicContextFactory();
factory.setProtocol(isEmpty(sslProto) ? "TLS" : sslProto);
factory.setKeyAlgorithm(isEmpty(sslKeyAlg) ? "SunX509" : sslKeyAlg);
if (isEmpty(keyStorePath))
throw new IllegalArgumentException("SSL key store location is not specified.");
factory.setKeyStoreFilePath(keyStorePath);
if (keyStorePwd != null)
factory.setKeyStorePassword(keyStorePwd.toCharArray());
factory.setKeyStoreType(isEmpty(keyStoreType) ? "jks" : keyStoreType);
if (isEmpty(trustStorePath))
factory.setTrustManagers(GridSslBasicContextFactory.getDisabledTrustManager());
else {
factory.setTrustStoreFilePath(trustStorePath);
if (trustStorePwd != null)
factory.setTrustStorePassword(trustStorePwd.toCharArray());
factory.setTrustStoreType(isEmpty(trustStoreType) ? "jks" : trustStoreType);
}
setSslContextFactory(factory);
}
//
// Data configuration section
//
if (!isEmpty(dataCfgs)) {
String[] names = dataCfgs.replaceAll("\\s+", "").split(",");
Collection list = new ArrayList<>();
for (String cfgName : names) {
if (isEmpty(cfgName))
continue;
String name = in.getProperty(prefix + "data." + cfgName + ".name");
String bal = in.getProperty(prefix + "data." + cfgName + ".balancer");
String aff = in.getProperty(prefix + "data." + cfgName + ".affinity");
GridClientDataConfiguration dataCfg = new GridClientDataConfiguration();
dataCfg.setName(isEmpty(name) ? null : name);
dataCfg.setBalancer(resolveBalancer(bal));
dataCfg.setAffinity(resolveAffinity(aff));
list.add(dataCfg);
}
setDataConfigurations(list);
}
}
/**
* Resolve load balancer from string definition.
*
* @param balancer Load balancer string definition.
* @return Resolved load balancer.
* @throws GridClientException If loading failed.
*/
private static GridClientLoadBalancer resolveBalancer(String balancer) throws GridClientException {
if (isEmpty(balancer) || "random".equals(balancer))
return new GridClientRandomBalancer();
if ("roundrobin".equals(balancer))
return new GridClientRoundRobinBalancer();
return newInstance(GridClientLoadBalancer.class, balancer);
}
/**
* Resolve data affinity from string definition.
*
* @param affinity Data affinity string definition.
* @return Resolved data affinity.
* @throws GridClientException If loading failed.
*/
private static GridClientDataAffinity resolveAffinity(String affinity) throws GridClientException {
if (isEmpty(affinity))
return null;
if ("partitioned".equals(affinity))
return new GridClientPartitionAffinity();
return newInstance(GridClientDataAffinity.class, affinity);
}
/**
* Constructs new instance of the specified class.
*
* @param exp Expected class for the new instance.
* @param clsName Class name to create new instance for.
* @param Expected class type for the new instance.
* @return New instance of specified class.
* @throws GridClientException If loading failed.
*/
private static T newInstance(Class exp, String clsName) throws GridClientException {
Object obj;
try {
obj = Class.forName(clsName).newInstance();
}
// Catch all for convenience.
catch (Exception e) {
throw new GridClientException("Failed to create class instance: " + clsName, e);
}
return exp.cast(obj);
}
}