| /* |
| * 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.ignite.internal.client; |
| |
| import java.net.Socket; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.concurrent.ExecutorService; |
| import org.apache.ignite.internal.client.balancer.GridClientLoadBalancer; |
| import org.apache.ignite.internal.client.balancer.GridClientRandomBalancer; |
| import org.apache.ignite.internal.client.balancer.GridClientRoundRobinBalancer; |
| import org.apache.ignite.internal.client.marshaller.GridClientMarshaller; |
| import org.apache.ignite.internal.client.marshaller.optimized.GridClientOptimizedMarshaller; |
| import org.apache.ignite.internal.client.ssl.GridSslBasicContextFactory; |
| import org.apache.ignite.internal.client.ssl.GridSslContextFactory; |
| import org.apache.ignite.internal.util.typedef.F; |
| import org.apache.ignite.internal.util.typedef.internal.U; |
| import org.apache.ignite.plugin.security.SecurityCredentials; |
| import org.apache.ignite.plugin.security.SecurityCredentialsBasicProvider; |
| import org.apache.ignite.plugin.security.SecurityCredentialsProvider; |
| import org.jetbrains.annotations.Nullable; |
| |
| /** |
| * 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<String> srvs = Collections.emptySet(); |
| |
| /** List of routers to connect to. */ |
| private Collection<String> 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<String, GridClientDataConfiguration> dataCfgs = Collections.emptyMap(); |
| |
| /** Credentials. */ |
| private SecurityCredentialsProvider credProvider; |
| |
| /** Executor. */ |
| private ExecutorService executor; |
| |
| /** Marshaller. */ |
| private GridClientMarshaller marshaller = new GridClientOptimizedMarshaller(U.allPluginProviders()); |
| |
| /** Daemon flag. */ |
| private boolean daemon; |
| |
| /** |
| * 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(); |
| credProvider = cfg.getSecurityCredentialsProvider(); |
| enableAttrsCache = cfg.isEnableAttributesCache(); |
| enableMetricsCache = cfg.isEnableMetricsCache(); |
| executor = cfg.getExecutorService(); |
| marshaller = cfg.getMarshaller(); |
| 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(); |
| daemon = cfg.isDaemon(); |
| |
| 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("ignite.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, Ignite will get |
| * a full view on grid topology and will be able to connect to |
| * any available remote node. |
| * <p> |
| * 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<String> getServers() { |
| return Collections.unmodifiableCollection(srvs); |
| } |
| |
| /** |
| * Collection of {@code 'host:port'} pairs representing |
| * grid routers used to establish connection to the grid. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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<String> getRouters() { |
| return routers; |
| } |
| |
| /** |
| * Sets list of servers this client should connect to. |
| * |
| * @param srvs List of servers. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setServers(Collection<String> srvs) { |
| this.srvs = srvs != null ? srvs : Collections.<String>emptySet(); |
| |
| return this; |
| } |
| |
| /** |
| * Sets list of routers this client should connect to. |
| * |
| * @param routers List of routers. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setRouters(Collection<String> routers) { |
| this.routers = routers != null ? routers : Collections.<String>emptySet(); |
| |
| return this; |
| } |
| |
| /** |
| * 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 |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setProtocol(GridClientProtocol proto) { |
| this.proto = proto; |
| |
| return this; |
| } |
| |
| /** |
| * 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)} |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setTcpNoDelay(boolean tcpNoDelay) { |
| this.tcpNoDelay = tcpNoDelay; |
| |
| return this; |
| } |
| |
| /** |
| * Sets timeout for socket connect operation. |
| * |
| * @param connectTimeout Connect timeout in milliseconds. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setConnectTimeout(int connectTimeout) { |
| this.connectTimeout = connectTimeout; |
| |
| return this; |
| } |
| |
| /** |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setSslContextFactory(GridSslContextFactory sslCtxFactory) { |
| this.sslCtxFactory = sslCtxFactory; |
| |
| return this; |
| } |
| |
| /** |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setBalancer(GridClientLoadBalancer balancer) { |
| this.balancer = balancer; |
| |
| return this; |
| } |
| |
| /** |
| * Gets client credentials provider to authenticate with. |
| * |
| * @return Credentials provider. |
| */ |
| public SecurityCredentialsProvider getSecurityCredentialsProvider() { |
| return credProvider; |
| } |
| |
| /** |
| * Sets client credentials provider used in authentication process. |
| * |
| * @param credProvider Client credentials provider. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setSecurityCredentialsProvider(SecurityCredentialsProvider credProvider) { |
| this.credProvider = credProvider; |
| |
| return this; |
| } |
| |
| /** |
| * Gets a collection of data configurations specified by user. |
| * |
| * @return Collection of data configurations (possibly empty). |
| */ |
| public Collection<GridClientDataConfiguration> getDataConfigurations() { |
| return dataCfgs.values(); |
| } |
| |
| /** |
| * Sets data configurations. |
| * |
| * @param dataCfgs Data configurations. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setDataConfigurations(Collection<? extends GridClientDataConfiguration> dataCfgs) { |
| this.dataCfgs = U.newHashMap(dataCfgs.size()); |
| |
| for (GridClientDataConfiguration dataCfg : dataCfgs) |
| this.dataCfgs.put(dataCfg.getName(), new GridClientDataConfiguration(dataCfg)); |
| |
| return this; |
| } |
| |
| /** |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setEnableMetricsCache(boolean enableMetricsCache) { |
| this.enableMetricsCache = enableMetricsCache; |
| |
| return this; |
| } |
| |
| /** |
| * 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}. |
| * <p> |
| * Note that topology is refreshed automatically every {@link #getTopologyRefreshFrequency()} |
| * interval, and if {@link #isAutoFetchMetrics()} enabled then metrics will be updated |
| * with that frequency. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setEnableAttributesCache(boolean enableAttrsCache) { |
| this.enableAttrsCache = enableAttrsCache; |
| |
| return this; |
| } |
| |
| /** |
| * 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}. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setAutoFetchMetrics(boolean autoFetchMetrics) { |
| this.autoFetchMetrics = autoFetchMetrics; |
| |
| return this; |
| } |
| |
| /** |
| * Allows client to fetch node metrics automatically with background topology refresh. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setAutoFetchAttributes(boolean autoFetchAttrs) { |
| this.autoFetchAttrs = autoFetchAttrs; |
| |
| return this; |
| } |
| |
| /** |
| * Allows client to fetch node attributes automatically with background topology refresh. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setTopologyRefreshFrequency(long topRefreshFreq) { |
| this.topRefreshFreq = topRefreshFreq; |
| |
| return this; |
| } |
| |
| /** |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setMaxConnectionIdleTime(long maxConnIdleTime) { |
| this.maxConnIdleTime = maxConnIdleTime; |
| |
| return this; |
| } |
| |
| /** |
| * Gets time interval in milliseconds between ping requests. Default is defined |
| * by {@link #DFLT_PING_INTERVAL} constant. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setPingInterval(long pingInterval) { |
| this.pingInterval = pingInterval; |
| |
| return this; |
| } |
| |
| /** |
| * Gets ping timeout. Default is defined by {@link #DFLT_PING_TIMEOUT} constant. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setPingTimeout(long pingTimeout) { |
| this.pingTimeout = pingTimeout; |
| |
| return this; |
| } |
| |
| /** |
| * Gets {@link ExecutorService} where client could run asynchronous operations. |
| * <p> |
| * When using {@link GridClientProtocol#TCP} this executor should be able to serve at least |
| * {@code Runtime.getRuntime().availableProcessors()} parallel tasks. |
| * <p> |
| * 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. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setExecutorService(ExecutorService executor) { |
| this.executor = executor; |
| |
| return this; |
| } |
| |
| /** |
| * Gets the marshaller, that is used to communicate between client and server. |
| * <p> |
| * Options, that can be used out-of-the-box: |
| * <ul> |
| * <li>{@link GridClientOptimizedMarshaller} (default) - Ignite's optimized marshaller.</li> |
| * <li>{@code GridClientBinaryMarshaller} - Marshaller that supports binary objects.</li> |
| * <li>{@link org.apache.ignite.internal.client.marshaller.jdk.GridClientJdkMarshaller} - JDK marshaller (not recommended).</li> |
| * </ul> |
| * |
| * @return A marshaller to use. |
| */ |
| public GridClientMarshaller getMarshaller() { |
| return marshaller; |
| } |
| |
| /** |
| * Sets the marshaller to use for communication. |
| * |
| * @param marshaller A marshaller to use. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setMarshaller(GridClientMarshaller marshaller) { |
| this.marshaller = marshaller; |
| |
| return this; |
| } |
| |
| /** |
| * 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 (!F.isEmpty(connectTimeout)) |
| setConnectTimeout(Integer.parseInt(connectTimeout)); |
| |
| if (!F.isEmpty(cred)) { |
| int idx = cred.indexOf(':'); |
| |
| if (idx >= 0 && idx < cred.length() - 1) { |
| setSecurityCredentialsProvider(new SecurityCredentialsBasicProvider( |
| new SecurityCredentials(cred.substring(0, idx), cred.substring(idx + 1)))); |
| } |
| else { |
| setSecurityCredentialsProvider(new SecurityCredentialsBasicProvider( |
| new SecurityCredentials(null, null, cred))); |
| } |
| } |
| |
| if (!F.isEmpty(autoFetchMetrics)) |
| setAutoFetchMetrics(Boolean.parseBoolean(autoFetchMetrics)); |
| |
| if (!F.isEmpty(autoFetchAttrs)) |
| setAutoFetchAttributes(Boolean.parseBoolean(autoFetchAttrs)); |
| |
| if (!F.isEmpty(maxConnIdleTime)) |
| setMaxConnectionIdleTime(Integer.parseInt(maxConnIdleTime)); |
| |
| if (!F.isEmpty(proto)) |
| setProtocol(GridClientProtocol.valueOf(proto)); |
| |
| if (!F.isEmpty(srvrs)) |
| setServers(Arrays.asList(srvrs.replaceAll("\\s+", "").split(","))); |
| |
| if (!F.isEmpty(tcpNoDelay)) |
| setTcpNoDelay(Boolean.parseBoolean(tcpNoDelay)); |
| |
| if (!F.isEmpty(topRefreshFreq)) |
| setTopologyRefreshFrequency(Long.parseLong(topRefreshFreq)); |
| |
| // |
| // SSL configuration section |
| // |
| |
| if (!F.isEmpty(sslEnabled) && Boolean.parseBoolean(sslEnabled)) { |
| GridSslBasicContextFactory factory = new GridSslBasicContextFactory(); |
| |
| factory.setProtocol(F.isEmpty(sslProto) ? "TLS" : sslProto); |
| factory.setKeyAlgorithm(F.isEmpty(sslKeyAlg) ? "SunX509" : sslKeyAlg); |
| |
| if (F.isEmpty(keyStorePath)) |
| throw new IllegalArgumentException("SSL key store location is not specified."); |
| |
| factory.setKeyStoreFilePath(keyStorePath); |
| |
| if (keyStorePwd != null) |
| factory.setKeyStorePassword(keyStorePwd.toCharArray()); |
| |
| factory.setKeyStoreType(F.isEmpty(keyStoreType) ? "jks" : keyStoreType); |
| |
| if (F.isEmpty(trustStorePath)) |
| factory.setTrustManagers(GridSslBasicContextFactory.getDisabledTrustManager()); |
| else { |
| factory.setTrustStoreFilePath(trustStorePath); |
| |
| if (trustStorePwd != null) |
| factory.setTrustStorePassword(trustStorePwd.toCharArray()); |
| |
| factory.setTrustStoreType(F.isEmpty(trustStoreType) ? "jks" : trustStoreType); |
| } |
| |
| setSslContextFactory(factory); |
| } |
| |
| // |
| // Data configuration section |
| // |
| |
| if (!F.isEmpty(dataCfgs)) { |
| String[] names = dataCfgs.replaceAll("\\s+", "").split(","); |
| Collection<GridClientDataConfiguration> list = new ArrayList<>(); |
| |
| for (String cfgName : names) { |
| if (F.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(F.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 (F.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 (F.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 <T> Expected class type for the new instance. |
| * @return New instance of specified class. |
| * @throws GridClientException If loading failed. |
| */ |
| private static <T> T newInstance(Class<T> 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); |
| } |
| |
| /** |
| * Set the daemon flag value. Communication threads will be created as daemons if this flag is set. |
| * |
| * @param daemon Daemon flag. |
| * @return {@code this} for chaining. |
| */ |
| public GridClientConfiguration setDaemon(boolean daemon) { |
| this.daemon = daemon; |
| |
| return this; |
| } |
| |
| /** |
| * Get the daemon flag. |
| * |
| * @return Daemon flag. |
| */ |
| public boolean isDaemon() { |
| return daemon; |
| } |
| } |