/** {@inheritDoc} */
  @Override
  public Map<?, ?> waitForAttributes(Collection<?> keys, long timeout) throws InterruptedException {
    A.notNull(keys, "keys");

    if (keys.isEmpty()) return Collections.emptyMap();

    if (timeout == 0) timeout = Long.MAX_VALUE;

    long now = System.currentTimeMillis();

    // Prevent overflow.
    long end = now + timeout < 0 ? Long.MAX_VALUE : now + timeout;

    // Don't wait longer than session timeout.
    if (end > endTime) end = endTime;

    synchronized (mux) {
      while (!closed && !attrs.keySet().containsAll(keys) && now < end) {
        mux.wait(end - now);

        now = System.currentTimeMillis();
      }

      if (closed) throw new InterruptedException("Session was closed: " + this);

      Map<Object, Object> retVal = new HashMap<Object, Object>(keys.size());

      for (Object key : keys) retVal.put(key, attrs.get(key));

      return retVal;
    }
  }
  /**
   * This constructor is meant for optimistic transactions.
   *
   * @param ldr Class loader.
   * @param nodeId Node ID.
   * @param nearNodeId Near node ID.
   * @param rmtThreadId Remote thread ID.
   * @param xidVer XID version.
   * @param commitVer Commit version.
   * @param sys System flag.
   * @param concurrency Concurrency level (should be pessimistic).
   * @param isolation Transaction isolation.
   * @param invalidate Invalidate flag.
   * @param timeout Timeout.
   * @param writeEntries Write entries.
   * @param ctx Cache registry.
   * @param txSize Expected transaction size.
   * @throws IgniteCheckedException If unmarshalling failed.
   */
  public GridNearTxRemote(
      GridCacheSharedContext ctx,
      ClassLoader ldr,
      UUID nodeId,
      UUID nearNodeId,
      long rmtThreadId,
      GridCacheVersion xidVer,
      GridCacheVersion commitVer,
      boolean sys,
      byte plc,
      TransactionConcurrency concurrency,
      TransactionIsolation isolation,
      boolean invalidate,
      long timeout,
      Collection<IgniteTxEntry> writeEntries,
      int txSize,
      @Nullable UUID subjId,
      int taskNameHash)
      throws IgniteCheckedException {
    super(
        ctx,
        nodeId,
        rmtThreadId,
        xidVer,
        commitVer,
        sys,
        plc,
        concurrency,
        isolation,
        invalidate,
        timeout,
        txSize,
        subjId,
        taskNameHash);

    assert nearNodeId != null;

    this.nearNodeId = nearNodeId;

    readMap = Collections.emptyMap();

    writeMap =
        new LinkedHashMap<>(
            writeEntries != null ? Math.max(txSize, writeEntries.size()) : txSize, 1.0f);

    if (writeEntries != null) {
      for (IgniteTxEntry entry : writeEntries) {
        entry.unmarshal(ctx, true, ldr);

        addEntry(entry);
      }
    }
  }
  /**
   * Parses HTTP parameters in an appropriate format and return back map of values to predefined
   * list of names.
   *
   * @param req Request.
   * @return Map of parsed parameters.
   */
  @SuppressWarnings({"unchecked"})
  private Map<String, Object> parameters(ServletRequest req) {
    Map<String, String[]> params = req.getParameterMap();

    if (F.isEmpty(params)) return Collections.emptyMap();

    Map<String, Object> map = U.newHashMap(params.size());

    for (Map.Entry<String, String[]> entry : params.entrySet())
      map.put(entry.getKey(), parameter(entry.getValue()));

    return map;
  }
  /** {@inheritDoc} */
  @Override
  public GridFuture<Map<K, V>> getAllAsync(
      @Nullable Collection<? extends K> keys,
      @Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
    ctx.denyOnFlag(LOCAL);

    if (F.isEmpty(keys))
      return new GridFinishedFuture<Map<K, V>>(ctx.kernalContext(), Collections.<K, V>emptyMap());

    GridCacheTxLocalAdapter<K, V> tx = ctx.tm().threadLocalTx();

    if (tx != null && !tx.implicit()) return ctx.wrapCloneMap(tx.getAllAsync(keys, filter));

    return loadAsync(keys, false, filter);
  }
  /**
   * @param keys Keys to load.
   * @param reload Reload flag.
   * @param filter Filter.
   * @return Loaded values.
   */
  public GridFuture<Map<K, V>> loadAsync(
      @Nullable Collection<? extends K> keys,
      boolean reload,
      @Nullable GridPredicate<? super GridCacheEntry<K, V>>[] filter) {
    if (F.isEmpty(keys))
      return new GridFinishedFuture<Map<K, V>>(ctx.kernalContext(), Collections.<K, V>emptyMap());

    GridNearGetFuture<K, V> fut = new GridNearGetFuture<K, V>(ctx, keys, reload, null, filter);

    // Register future for responses.
    ctx.mvcc().addFuture(fut);

    fut.init();

    return ctx.wrapCloneMap(fut);
  }
  /** {@inheritDoc} */
  @Override
  public boolean onDone(AffinityTopologyVersion res, Throwable err) {
    Map<Integer, Boolean> m = null;

    for (GridCacheContext cacheCtx : cctx.cacheContexts()) {
      if (cacheCtx.config().getTopologyValidator() != null && !CU.isSystemCache(cacheCtx.name())) {
        if (m == null) m = new HashMap<>();

        m.put(
            cacheCtx.cacheId(),
            cacheCtx.config().getTopologyValidator().validate(discoEvt.topologyNodes()));
      }
    }

    cacheValidRes = m != null ? m : Collections.<Integer, Boolean>emptyMap();

    cctx.cache().onExchangeDone(exchId.topologyVersion(), reqs, err);

    cctx.exchange().onExchangeDone(this, err);

    if (super.onDone(res, err) && !dummy && !forcePreload) {
      if (log.isDebugEnabled())
        log.debug(
            "Completed partition exchange [localNode="
                + cctx.localNodeId()
                + ", exchange= "
                + this
                + ']');

      initFut.onDone(err == null);

      GridTimeoutObject timeoutObj = this.timeoutObj;

      // Deschedule timeout object.
      if (timeoutObj != null) cctx.kernalContext().timeout().removeTimeoutObject(timeoutObj);

      if (exchId.isLeft()) {
        for (GridCacheContext cacheCtx : cctx.cacheContexts())
          cacheCtx.config().getAffinity().removeNode(exchId.nodeId());
      }

      return true;
    }

    return dummy;
  }
Beispiel #7
0
 /** {@inheritDoc} */
 @Override
 public Map<K, Collection<GridCacheMvccCandidate<K>>> localCandidates() {
   return Collections.emptyMap();
 }
  /**
   * Updates value for single partition.
   *
   * @param p Partition.
   * @param nodeId Node ID.
   * @param state State.
   * @param updateSeq Update sequence.
   */
  @SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"})
  private void updateLocal(int p, UUID nodeId, GridDhtPartitionState state, long updateSeq) {
    assert lock.isWriteLockedByCurrentThread();
    assert nodeId.equals(cctx.nodeId());

    // In case if node joins, get topology at the time of joining node.
    ClusterNode oldest = CU.oldestAliveCacheServerNode(cctx.shared(), topVer);

    assert oldest != null;

    // If this node became the oldest node.
    if (oldest.id().equals(cctx.nodeId())) {
      long seq = node2part.updateSequence();

      if (seq != updateSeq) {
        if (seq > updateSeq) {
          if (this.updateSeq.get() < seq) {
            // Update global counter if necessary.
            boolean b = this.updateSeq.compareAndSet(this.updateSeq.get(), seq + 1);

            assert b
                : "Invalid update sequence [updateSeq="
                    + updateSeq
                    + ", seq="
                    + seq
                    + ", curUpdateSeq="
                    + this.updateSeq.get()
                    + ", node2part="
                    + node2part.toFullString()
                    + ']';

            updateSeq = seq + 1;
          } else updateSeq = seq;
        }

        node2part.updateSequence(updateSeq);
      }
    }

    GridDhtPartitionMap map = node2part.get(nodeId);

    if (map == null)
      node2part.put(
          nodeId,
          map =
              new GridDhtPartitionMap(
                  nodeId,
                  updateSeq,
                  Collections.<Integer, GridDhtPartitionState>emptyMap(),
                  false));

    map.updateSequence(updateSeq);

    map.put(p, state);

    Set<UUID> ids = part2node.get(p);

    if (ids == null) part2node.put(p, ids = U.newHashSet(3));

    ids.add(nodeId);
  }
 /** @return Map of versions to be verified. */
 public Map<IgniteTxKey, GridCacheVersion> dhtVersions() {
   return dhtVers == null ? Collections.<IgniteTxKey, GridCacheVersion>emptyMap() : dhtVers;
 }
/** 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();
    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("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.
   */
  public void setServers(Collection<String> srvs) {
    this.srvs = srvs != null ? srvs : Collections.<String>emptySet();
  }

  /**
   * Sets list of routers this client should connect to.
   *
   * @param routers List of routers.
   */
  public void setRouters(Collection<String> routers) {
    this.routers = routers != null ? routers : Collections.<String>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)}
   *
   * <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.
   */
  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 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.
   */
  public void setSecurityCredentialsProvider(SecurityCredentialsProvider credProvider) {
    this.credProvider = credProvider;
  }

  /**
   * 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.
   */
  public void setDataConfigurations(Collection<? extends GridClientDataConfiguration> dataCfgs) {
    this.dataCfgs = U.newHashMap(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}.
   *
   * <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.
   */
  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}.
   *
   * <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.
   */
  public void setAutoFetchMetrics(boolean autoFetchMetrics) {
    this.autoFetchMetrics = autoFetchMetrics;
  }

  /**
   * 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.
   */
  public void setAutoFetchAttributes(boolean autoFetchAttrs) {
    this.autoFetchAttrs = autoFetchAttrs;
  }

  /**
   * 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.
   */
  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.
   *
   * <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.
   */
  public void setPingInterval(long pingInterval) {
    this.pingInterval = pingInterval;
  }

  /**
   * 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.
   */
  public void setPingTimeout(long pingTimeout) {
    this.pingTimeout = pingTimeout;
  }

  /**
   * 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.
   */
  public void setExecutorService(ExecutorService executor) {
    this.executor = executor;
  }

  /**
   * 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>{@code GridClientPortableMarshaller} - Marshaller that supports portable objects.
   *   <li>{@link org.apache.ignite.internal.client.marshaller.jdk.GridClientJdkMarshaller} - JDK
   *       marshaller (not recommended).
   * </ul>
   *
   * @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 (!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.
   */
  public void setDaemon(boolean daemon) {
    this.daemon = daemon;
  }

  /**
   * Get the daemon flag.
   *
   * @return Daemon flag.
   */
  public boolean isDaemon() {
    return daemon;
  }
}