ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [26/50] [abbrv] incubator-ignite git commit: Merge branch 'sprint-1' into ignite-128
Date Wed, 11 Feb 2015 09:22:57 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientCompute.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/client/GridClientCompute.java
index 5dc8a9f,0000000..e26c004
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientCompute.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientCompute.java
@@@ -1,419 -1,0 +1,476 @@@
 +/*
 + * 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 org.apache.ignite.internal.client.balancer.*;
 +import org.jetbrains.annotations.*;
 +
 +import java.util.*;
 +
 +/**
 + * A compute projection of grid client. Contains various methods for task execution, full and partial (per node)
 + * topology refresh, and log viewing. An initial instance of compute projection over the whole remote grid is
 + * provided via {@link GridClient#compute()} method. Further sub-projections may be created via
 + * any of the {@code projection(...)} methods on this API.
 + * <p>
 + * You can create custom client projections based on any user-defined filtering. For example you can create
 + * a projection over a certain group of nodes, or over all nodes that have a certain attribute. Once projection
 + * is created, only nodes that belong to this projection will be contacted on remote grid for any operation.
 + * This essentially allows users to create virtual subgrids for remote task execution.
 + * <p>
 + * Use any of the {@code execute(...)} methods to execute tasks on remote grid. Note that tasks need
 + * to be deployed to remote grid first prior to execution. You can also use any of the
 + * {@code affinityExecute(...)} methods to execute tasks on node that have affinity with some data key.
 + * This way you can collocate your computation with the data cached on remote nodes.
 + * <p>
 + * You can also use any of the {@code refreshNode(...)} or {@code refreshTopology(...)} methods
 + * to eagerly refresh metrics or attributes on remote nodes (note that attributes are static,
 + * so it is sufficient to fetch and cache them only once). Metrics and attributes will be
 + * cached in {@link GridClientNode} instances automatically if {@link GridClientConfiguration#isEnableMetricsCache()}
 + * or {@link GridClientConfiguration#isEnableAttributesCache()} property is set to {@code true}.
 + * <p>
 + * Compute client also allows fetching contents of remote log files (including backwards mode) via any of
 + * the provided {@code log(...)} methods.
 + * <h1 class="header">Affinity Awareness</h1>
-  * One of the unique properties of the GridGain remote clients is that they are
++ * One of the unique properties of the Ignite remote clients is that they are
 + * affinity aware. In other words, both compute and data APIs will optionally
 + * contact exactly the node where the data is cached based on some affinity key.
 + * This allows for collocation of computations and data and avoids extra network
 + * hops that would be necessary if non-affinity nodes were contacted. Use
 + * {@link #affinityExecute(String, String, Object, Object)} and
 + * {@link #affinityExecuteAsync(String, String, Object, Object)} to synchronously
 + * or asynchronously execute remote tasks on affinity nodes based on provided
 + * affinity keys.
 + */
 +public interface GridClientCompute {
 +    /**
 +     * Creates a projection that will communicate only with specified remote node.
 +     * <p>
 +     * If current projection is dynamic projection, then this method will check is passed node is in topology.
 +     * If any filters were specified in current topology, this method will check if passed node is accepted by
 +     * the filter. If current projection was restricted to any subset of nodes, this method will check if
 +     * passed node is in that subset. If any of the checks fails an exception will be thrown.
 +     *
 +     * @param node Single node to which this projection will be restricted.
 +     * @return Resulting static projection that is bound to a given node.
 +     * @throws GridClientException If resulting projection is empty.
 +     */
 +    public GridClientCompute projection(GridClientNode node) throws GridClientException;
 +
 +    /**
 +     * Creates a projection that will communicate only with nodes that are accepted by the passed filter.
 +     * <p>
 +     * If current projection is dynamic projection, then filter will be applied to the most relevant
 +     * topology snapshot every time a node to communicate is selected. If current projection is a static projection,
 +     * then resulting projection will only be restricted to nodes that were in parent projection and were
 +     * accepted by the passed filter. If any of the checks fails an exception will be thrown.
 +     *
 +     * @param filter Filter that will select nodes for projection. If {@code null},
 +     *      then no filter would be applied to nodes in projection.
 +     * @return Resulting projection (static or dynamic, depending in parent projection type).
 +     * @throws GridClientException If resulting projection is empty.
 +     */
 +    public GridClientCompute projection(GridClientPredicate<? super GridClientNode> filter) throws GridClientException;
 +
 +    /**
 +     * Creates a projection that will communicate only with specified remote nodes. For any particular call
 +     * a node to communicate will be selected with balancer of this projection.
 +     * <p>
 +     * If current projection is dynamic projection, then this method will check is passed nodes are in topology.
 +     * If any filters were specified in current topology, this method will check if passed nodes are accepted by
 +     * the filter. If current projection was restricted to any subset of nodes, this method will check if
 +     * passed nodes are in that subset (i.e. calculate the intersection of two collections).
 +     * If any of the checks fails an exception will be thrown.
 +     *
 +     * @param nodes Collection of nodes to which this projection will be restricted. If {@code null},
 +     *      created projection is dynamic and will take nodes from topology.
 +     * @return Resulting static projection that is bound to a given nodes.
 +     * @throws GridClientException If resulting projection is empty.
 +     */
 +    public GridClientCompute projection(Collection<GridClientNode> nodes) throws GridClientException;
 +
 +    /**
 +     * Creates a projection that will communicate only with nodes that are accepted by the passed filter. The
 +     * balancer passed will override default balancer specified in configuration.
 +     * <p>
 +     * If current projection is dynamic projection, then filter will be applied to the most relevant
 +     * topology snapshot every time a node to communicate is selected. If current projection is a static projection,
 +     * then resulting projection will only be restricted to nodes that were in parent projection and were
 +     * accepted by the passed filter. If any of the checks fails an exception will be thrown.
 +     *
 +     * @param filter Filter that will select nodes for projection. If {@code null},
 +     *      then no filter would be applied to nodes in projection.
 +     * @param balancer Balancer that will select balanced node in resulting projection. If {@code null},
 +     *      then balancer which was specified while projection construction will be used.
 +     * @return Resulting projection (static or dynamic, depending in parent projection type).
 +     * @throws GridClientException If resulting projection is empty.
 +     */
 +    public GridClientCompute projection(GridClientPredicate<? super GridClientNode> filter,
 +        GridClientLoadBalancer balancer) throws GridClientException;
 +
 +    /**
 +     * Creates a projection that will communicate only with specified remote nodes. For any particular call
 +     * a node to communicate will be selected with passed balancer..
 +     * <p>
 +     * If current projection is dynamic projection, then this method will check is passed nodes are in topology.
 +     * If any filters were specified in current topology, this method will check if passed nodes are accepted by
 +     * the filter. If current projection was restricted to any subset of nodes, this method will check if
 +     * passed nodes are in that subset (i.e. calculate the intersection of two collections).
 +     * If any of the checks fails an exception will be thrown.
 +     *
 +     * @param nodes Collection of nodes to which this projection will be restricted. If {@code null},
 +     *      then no filter would be applied to nodes in projection.
 +     * @param balancer Balancer that will select nodes in resulting projection. If {@code null},
 +     *      then balancer which was specified while projection construction will be used.
 +     * @return Resulting static projection that is bound to a given nodes.
 +     * @throws GridClientException If resulting projection is empty.
 +     */
 +    public GridClientCompute projection(Collection<GridClientNode> nodes, GridClientLoadBalancer balancer)
 +        throws GridClientException;
 +
 +    /**
 +     * Gets load balancer used by this projection. By default, the balancer specified
 +     * in {@link GridClientConfiguration#getBalancer()} property is used. User can
 +     * provide custom balancers for different projections via
 +     * {@link #projection(GridClientPredicate, GridClientLoadBalancer)} method.
 +     *
 +     * @return Instance of {@link GridClientLoadBalancer} used by this projection.
 +     */
 +    public GridClientLoadBalancer balancer();
 +
 +    /**
 +     * Executes task on remote grid. Only nodes included into this projection will
 +     * be contacted. Note that task must be deployed on remote grid prior to the
 +     * execution.
 +     *
 +     * @param taskName Task name or task class name.
 +     * @param taskArg Optional task argument.
 +     * @return Task execution result.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <R> R execute(String taskName, Object taskArg) throws GridClientException;
 +
 +    /**
 +     * Asynchronously executes task on remote grid. Only nodes included into this projection will
 +     * be contacted. Note that task must be deployed on remote grid prior to the
 +     * execution.
 +     *
 +     * @param taskName Task name or task class name.
 +     * @param taskArg Optional task argument.
 +     * @return Future for remote execution.
 +     */
 +    public <R> GridClientFuture<R> executeAsync(String taskName, Object taskArg);
 +
 +    /**
 +     * Executes task using cache affinity key for routing. This way the task will start executing
 +     * exactly on the node where this affinity key is cached hence allowing for
 +     * collocation of computations and data.
 +     *
 +     * @param taskName Task name or task class name.
 +     * @param cacheName Name of the cache on which affinity should be calculated.  If {@code null},
 +     *      then default cache will be used.
 +     * @param affKey Affinity key.
 +     * @param taskArg Optional task argument.
 +     * @return Task execution result.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <R> R affinityExecute(String taskName, String cacheName, Object affKey, Object taskArg)
 +        throws GridClientException;
 +
 +    /**
 +     * Asynchronously executes task using cache affinity key for routing. This way
 +     * the task will start executing exactly on the node where this affinity key is cached
 +     * hence allowing for collocation of computations and data.
 +     *
 +     * @param taskName Task name or task class name.
 +     * @param cacheName Name of the cache on which affinity should be calculated.  If {@code null},
 +     *      then balancer which was specified while projection construction will be used.
 +     * @param affKey Affinity key.
 +     * @param taskArg Optional task argument.
 +     * @return Future for the remote execution.
 +     */
 +    public <R> GridClientFuture<R> affinityExecuteAsync(String taskName, String cacheName, Object affKey,
 +        Object taskArg);
 +
 +    /**
 +     * Gets most recently refreshed topology (only non-daemon nodes included).
 +     * If this compute instance is a projection, then only nodes that
 +     * satisfy projection criteria will be returned.
 +     *
 +     * @return Most recently refreshed topology.
 +     * @throws GridClientException If client doesn't have an actual topology version.
 +     */
 +    public Collection<GridClientNode> nodes() throws GridClientException;
 +
 +    /**
 +     * Gets cached node with given id from most recently refreshed topology.
 +     *
 +     * @param id Node ID.
 +     * @return Node for given ID or {@code null} if node with given id was not found.
 +     * @throws GridClientException If client doesn't have an actual topology version.
 +     */
 +     public GridClientNode node(UUID id) throws GridClientException;
 +
 +    /**
 +     * Gets cached nodes for the given IDs based on most recently refreshed topology.
 +     * If this compute instance is a projection, then only nodes that passes projection
 +     * criteria will be returned.
 +     *
 +     * @param ids Node IDs.
 +     * @return Collection of nodes for provided IDs.
 +     * @throws GridClientException If client doesn't have an actual topology version.
 +     */
 +    public Collection<GridClientNode> nodes(Collection<UUID> ids) throws GridClientException;
 +
 +    /**
 +     * Gets all cached nodes that pass the filter. If this compute instance is a projection, then only
 +     * nodes that passes projection criteria will be passed to the filter.
 +     *
 +     * @param filter Node filter.
 +     * @return Collection of nodes that satisfy provided filter.
 +     * @throws GridClientException If client doesn't have an actual topology version.
 +     */
 +    public Collection<GridClientNode> nodes(GridClientPredicate<GridClientNode> filter)
 +        throws GridClientException;
 +
 +    /**
 +     * Gets most recently refreshed set of daemon nodes. If this compute instance is a projection,
 +     * then only nodes that satisfy projection criteria will be returned.
 +     *
 +     * @return Daemon nodes in most recently refreshed topology.
 +     * @throws GridClientException If client doesn't have an actual topology version.
 +     */
 +    public Collection<GridClientNode> daemonNodes() throws GridClientException;
 +
 +    /**
 +     * Refreshes and returns node by its ID from remote grid. Use {@code includeAttrs} and
 +     * {@code includeMetrics} parameters to automatically fetch remote node attributes and
 +     * metrics.
 +     * <p>
 +     * Note that fetched attributes and metrics may or may note be cached in {@link GridClientNode}
 +     * based on {@link GridClientConfiguration#isEnableMetricsCache()} and
 +     * {@link GridClientConfiguration#isEnableAttributesCache()} parameters. Even though topology
 +     * is refreshed automatically every {@link GridClientConfiguration#getTopologyRefreshFrequency()}
 +     * interval, node metrics and attributes will be fetched in background only if
 +     * {@link GridClientConfiguration#isAutoFetchMetrics()} or
 +     * {@link GridClientConfiguration#isAutoFetchAttributes()} set to true.
 +     * <p>
 +     * Also note that node attributes are static and, if cached, there is no need
 +     * to refresh them again.
 +     *
 +     * @param id Node ID.
 +     * @param includeAttrs Whether to include node attributes.
 +     * @param includeMetrics Whether to include node metrics.
 +     * @return Node descriptor or {@code null} if node doesn't exist.
 +     * @throws GridClientException In case request failed.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public GridClientNode refreshNode(UUID id, boolean includeAttrs, boolean includeMetrics) throws GridClientException;
 +
 +    /**
 +     * Asynchronously refreshes and returns node by its ID from remote grid. Use {@code includeAttrs} and
 +     * {@code includeMetrics} parameters to automatically fetch remote node attributes and
 +     * metrics.
 +     * <p>
 +     * Note that fetched attributes and metrics may or may note be cached in {@link GridClientNode}
 +     * based on {@link GridClientConfiguration#isEnableMetricsCache()} and
 +     * {@link GridClientConfiguration#isEnableAttributesCache()} parameters. Even though topology
 +     * is refreshed automatically every {@link GridClientConfiguration#getTopologyRefreshFrequency()}
 +     * interval, node metrics and attributes will be fetched in background only if
 +     * {@link GridClientConfiguration#isAutoFetchMetrics()} or
 +     * {@link GridClientConfiguration#isAutoFetchAttributes()} set to true.
 +     * <p>
 +     * Also note that node attributes are static and, if cached, there is no need
 +     * to refresh them again.
 +     *
 +     * @param id Node ID.
 +     * @param includeAttrs Whether to include node attributes.
 +     * @param includeMetrics Whether to include node metrics.
 +     * @return Future for the refresh
 +     */
 +    public GridClientFuture<GridClientNode> refreshNodeAsync(UUID id, boolean includeAttrs, boolean includeMetrics);
 +
 +    /**
 +     * Refreshes and returns node by its IP address from remote grid. All possible IP addresses
 +     * of a node will be checked. If there is more than one node for given IP address, then
 +     * first found node will be refreshed. Use {@code includeAttrs} and
 +     * {@code includeMetrics} parameters to automatically fetch remote node attributes and
 +     * metrics.
 +     * <p>
 +     * Note that fetched attributes and metrics may or may note be cached in {@link GridClientNode}
 +     * based on {@link GridClientConfiguration#isEnableMetricsCache()} and
 +     * {@link GridClientConfiguration#isEnableAttributesCache()} parameters. Even though topology
 +     * is refreshed automatically every {@link GridClientConfiguration#getTopologyRefreshFrequency()}
 +     * interval, node metrics and attributes will be fetched in background only if
 +     * {@link GridClientConfiguration#isAutoFetchMetrics()} or
 +     * {@link GridClientConfiguration#isAutoFetchAttributes()} set to true.
 +     * <p>
 +     * Also note that node attributes are static and, if cached, there is no need
 +     * to refresh them again.
 +     *
 +     * @param ip IP address.
 +     * @param includeAttrs Whether to include node attributes.
 +     * @param includeMetrics Whether to include node metrics.
 +     * @return Node descriptor or {@code null} if node doesn't exist.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    @Nullable public GridClientNode refreshNode(String ip, boolean includeAttrs, boolean includeMetrics)
 +        throws GridClientException;
 +
 +    /**
 +     * Asynchronously refreshes and returns node by its IP address from remote grid. All possible IP addresses
 +     * of a node will be checked. If there is more than one node for given IP address, then
 +     * first found node will be refreshed. Use {@code includeAttrs} and
 +     * {@code includeMetrics} parameters to automatically fetch remote node attributes and
 +     * metrics.
 +     * <p>
 +     * Note that fetched attributes and metrics may or may note be cached in {@link GridClientNode}
 +     * based on {@link GridClientConfiguration#isEnableMetricsCache()} and
 +     * {@link GridClientConfiguration#isEnableAttributesCache()} parameters. Even though topology
 +     * is refreshed automatically every {@link GridClientConfiguration#getTopologyRefreshFrequency()}
 +     * interval, node metrics and attributes will be fetched in background only if
 +     * {@link GridClientConfiguration#isAutoFetchMetrics()} or
 +     * {@link GridClientConfiguration#isAutoFetchAttributes()} set to true.
 +     * <p>
 +     * Also note that node attributes are static and, if cached, there is no need
 +     * to refresh them again.
 +     *
 +     * @param ip IP address.
 +     * @param includeAttrs Whether to include node attributes.
 +     * @param includeMetrics Whether to include node metrics.
 +     * @return Future for the refresh operation.
 +     */
 +    public GridClientFuture<GridClientNode> refreshNodeAsync(String ip, boolean includeAttrs, boolean includeMetrics);
 +
 +    /**
 +     * Refreshes and returns all nodes within topology. Use {@code includeAttrs} and
 +     * {@code includeMetrics} parameters to automatically fetch remote node attributes and
 +     * metrics.
 +     * <p>
 +     * Note that fetched attributes and metrics may or may note be cached in {@link GridClientNode}
 +     * based on {@link GridClientConfiguration#isEnableMetricsCache()} and
 +     * {@link GridClientConfiguration#isEnableAttributesCache()} parameters. Even though topology
 +     * is refreshed automatically every {@link GridClientConfiguration#getTopologyRefreshFrequency()}
 +     * interval, node metrics and attributes will be fetched in background only if
 +     * {@link GridClientConfiguration#isAutoFetchMetrics()} or
 +     * {@link GridClientConfiguration#isAutoFetchAttributes()} set to {@code true}.
 +     * <p>
 +     * Also note that node attributes are static and, if cached, there is no need
 +     * to refresh them again.
 +     *
 +     * @param includeAttrs Whether to include node attributes.
 +     * @param includeMetrics Whether to include node metrics.
 +     * @return Node descriptors.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public List<GridClientNode> refreshTopology(boolean includeAttrs, boolean includeMetrics)
 +        throws GridClientException;
 +
 +    /**
 +     * Asynchronously refreshes and returns all nodes within topology. Use {@code includeAttrs} and
 +     * {@code includeMetrics} parameters to automatically fetch remote node attributes and
 +     * metrics.
 +     * <p>
 +     * Note that fetched attributes and metrics may or may note be cached in {@link GridClientNode}
 +     * based on {@link GridClientConfiguration#isEnableMetricsCache()} and
 +     * {@link GridClientConfiguration#isEnableAttributesCache()}parameters. Even though topology
 +     * is refreshed automatically every {@link GridClientConfiguration#getTopologyRefreshFrequency()}
 +     * interval, node metrics and attributes will be fetched in background only if
 +     * {@link GridClientConfiguration#isAutoFetchMetrics()} or
 +     * {@link GridClientConfiguration#isAutoFetchAttributes()} set to {@code true}.
 +     * <p>
 +     * Also note that node attributes are static and, if cached, there is no need
 +     * to refresh them again.
 +     *
 +     * @param includeAttrs Whether to include node attributes.
 +     * @param includeMetrics Whether to include node metrics.
 +     * @return Future.
 +     */
 +    public GridClientFuture<List<GridClientNode>> refreshTopologyAsync(boolean includeAttrs, boolean includeMetrics);
 +
 +    /**
++     * Gets contents of default log file ({@code IGNITE_HOME/work/log/gridgain.log}).
++     * Note that backward reading (with negative line indexes) supported for only 8-bit character encodings.
++     *
++     * @param lineFrom Index of line from which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @param lineTo Index of line to which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @return Log contents.
++     * @throws GridClientException In case of error.
++     * @throws GridServerUnreachableException If none of the servers can be reached.
++     * @throws GridClientClosedException If client was closed manually.
++     */
++    public List<String> log(int lineFrom, int lineTo) throws GridClientException;
++
++    /**
++     * Asynchronously gets contents of default log file
++     * ({@code IGNITE_HOME/work/log/gridgain.log}).
++     * Note that backward reading (with negative line indexes) supported for only 8-bit character encodings.
++     *
++     * @param lineFrom Index of line from which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @param lineTo Index of line to which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @return Future for this operation.
++     */
++    public GridClientFuture<List<String>> logAsync(int lineFrom, int lineTo);
++
++    /**
++     * Gets contents of custom log file, i.e. log file in a non-default location.
++     * Note that backward reading (with negative line indexes) supported for only 8-bit character encodings.
++     *
++     * @param path Log file path. Can be absolute or relative to IGNITE_HOME.
++     * @param lineFrom Index of line from which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @param lineTo Index of line to which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @return Log contents.
++     * @throws GridClientException In case of error.
++     * @throws GridServerUnreachableException If none of the servers can be reached.
++     * @throws GridClientClosedException If client was closed manually.
++     */
++    public List<String> log(String path, int lineFrom, int lineTo) throws GridClientException;
++
++    /**
++     * Asynchronously gets contents of custom log file.
++     * Note that backward reading (with negative line indexes) supported for only 8-bit character encodings.
++     *
++     * @param path Log file path. Can be absolute or relative to IGNITE_HOME.
++     * @param lineFrom Index of line from which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @param lineTo Index of line to which log is get, inclusive. Negative values mean line numbers
++     *      from the end of the file.
++     * @return Future.
++     */
++    public GridClientFuture<List<String>> logAsync(String path, int lineFrom, int lineTo);
++
++    /**
 +     * Sets keep portables flag for the next task execution in the current thread.
 +     */
 +    public GridClientCompute withKeepPortables();
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientConfiguration.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/client/GridClientConfiguration.java
index 330fca8,0000000..55b1f3a
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientConfiguration.java
@@@ -1,867 -1,0 +1,846 @@@
 +/*
 + * 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 org.apache.ignite.internal.client.balancer.*;
 +import org.apache.ignite.internal.client.marshaller.*;
 +import org.apache.ignite.internal.client.marshaller.optimized.*;
 +import org.apache.ignite.internal.client.ssl.*;
 +import org.apache.ignite.portables.*;
 +import org.apache.ignite.plugin.security.*;
 +import org.apache.ignite.internal.util.typedef.*;
 +import org.apache.ignite.internal.util.typedef.internal.*;
++import org.apache.ignite.plugin.security.*;
 +import org.jetbrains.annotations.*;
 +
 +import java.net.*;
 +import java.util.*;
 +import java.util.concurrent.*;
 +
 +/**
 + * 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 GridSecurityCredentialsProvider credProvider;
 +
 +    /** Executor. */
 +    private ExecutorService executor;
 +
 +    /** Marshaller. */
 +    private GridClientMarshaller marshaller = new GridClientOptimizedMarshaller();
 +
 +    /** Daemon flag. */
 +    private boolean daemon;
 +
-     /** Portable configuration. */
-     private PortableConfiguration portableCfg;
- 
 +    /**
 +     * 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();
-         portableCfg = cfg.getPortableConfiguration();
 +
 +        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
++     * 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 GridSecurityCredentialsProvider getSecurityCredentialsProvider() {
 +        return credProvider;
 +    }
 +
 +    /**
 +     * Sets client credentials provider used in authentication process.
 +     *
 +     * @param credProvider Client credentials provider.
 +     */
 +    public void setSecurityCredentialsProvider(GridSecurityCredentialsProvider 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) - GridGain's optimized marshaller.</li>
++     *     <li>{@link GridClientOptimizedMarshaller} (default) - Ignite's optimized marshaller.</li>
 +     *     <li>{@code GridClientPortableMarshaller} - Marshaller that supports portable 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.
 +     */
 +    public void setMarshaller(GridClientMarshaller marshaller) {
 +        this.marshaller = marshaller;
 +    }
 +
 +    /**
-      * Gets portable configuration.
-      *
-      * @return Portable configuration.
-      */
-     public PortableConfiguration getPortableConfiguration() {
-         return portableCfg;
-     }
- 
-     /**
-      * Sets portable configuration.
-      *
-      * @param portableCfg Portable configuration.
-      */
-     public void setPortableConfiguration(@Nullable PortableConfiguration portableCfg) {
-         this.portableCfg = portableCfg;
-     }
- 
-     /**
 +     * 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 GridSecurityCredentialsBasicProvider(
 +                    new GridSecurityCredentials(cred.substring(0, idx), cred.substring(idx + 1))));
 +            }
 +            else {
 +                setSecurityCredentialsProvider(new GridSecurityCredentialsBasicProvider(
 +                    new GridSecurityCredentials(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;
 +    }
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientData.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/client/GridClientData.java
index 79d5c5c,0000000..73fa06f
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientData.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientData.java
@@@ -1,443 -1,0 +1,443 @@@
 +/*
 + * 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.util.*;
 +
 +/**
 + * A data projection of grid client. Contains various methods for cache operations and metrics retrieval.
 + * An instance of data projection over some remote cache is provided via
 + * {@link GridClient#data(String)} method.
 + * <h1 class="header">Affinity Awareness</h1>
-  * One of the unique properties of the GridGain remote clients is that they are
++ * One of the unique properties of the Ignite remote clients is that they are
 + * affinity aware. In other words, both compute and data APIs will optionally
 + * contact exactly the node where the data is cached based on some affinity key.
 + * This allows for collocation of computations and data and avoids extra network
 + * hops that would be necessary if non-affinity nodes were contacted. By default
 + * all operations on {@code GridClientData} API will be affinity-aware unless
 + * such behavior is overridden by pinning one or more remote nodes
 + * (see {@link #pinNodes(GridClientNode, GridClientNode...)} for more information).
 + */
 +public interface GridClientData {
 +    /**
 +     * Gets name of the remote cache. The cache name for this projection was specified
 +     * via {@link GridClient#data(String)} method at the time of creation.
 +     *
 +     * @return Name of the remote cache.
 +     */
 +    public String cacheName();
 +
 +    /**
 +     * Gets client data projection which will only contact specified remote grid node. By default, remote
 +     * node is determined based on {@link GridClientDataAffinity} provided - this method allows
 +     * to override default behavior and use only specified server for all cache operations.
 +     * <p>
 +     * Use this method when there are other than {@code key-affinity} reasons why a certain
 +     * node should be contacted.
 +     *
 +     * @param node Node to be contacted (optional).
 +     * @param nodes Additional nodes (optional).
 +     * @return Client data which will only contact server with given node ID.
 +     * @throws GridClientException If resulting projection is empty.
 +     */
 +    public GridClientData pinNodes(GridClientNode node, GridClientNode... nodes) throws GridClientException;
 +
 +    /**
 +     * Gets pinned node or {@code null} if no nodes were pinned.
 +     *
 +     * @return Pinned node.
 +     */
 +    public Collection<GridClientNode> pinnedNodes();
 +
 +    /**
 +     * Puts value to cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to put in cache.
 +     * @param val Value to put in cache.
 +     * @return Whether value was actually put to cache.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K, V> boolean put(K key, V val) throws GridClientException;
 +
 +    /**
 +     * Asynchronously puts value to cache on remote node.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to put in cache.
 +     * @param val Value to put in cache.
 +     * @return Future whether value was actually put to cache.
 +     */
 +    public <K, V> GridClientFuture<Boolean> putAsync(K key, V val);
 +
 +    /**
 +     * Puts entries to cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote nodes on which these keys are supposed to be cached (unless
 +     * some nodes were {@code pinned}). If entries do not map to one node, then the node
 +     * which has most mapped entries will be contacted.
 +     *
 +     * @param entries Entries to put in cache.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K, V> void putAll(Map<K, V> entries) throws GridClientException;
 +
 +    /**
 +     * Asynchronously puts entries to cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote nodes on which these keys are supposed to be cached (unless
 +     * some nodes were {@code pinned}). If entries do not map to one node, then the node
 +     * which has most mapped entries will be contacted.
 +     *
 +     * @param entries Entries to put in cache.
 +     * @return Future whether this operation completes.
 +     */
 +    public <K, V> GridClientFuture<?> putAllAsync(Map<K, V> entries);
 +
 +    /**
 +     * Gets value from cache on remote node.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to get from cache.
 +     * @return Value for given key or {@code null} if no value was cached.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K, V> V get(K key) throws GridClientException;
 +
 +    /**
 +     * Asynchronously gets value from cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to get from cache.
 +     * @return Future with value for given key or with {@code null} if no value was cached.
 +     */
 +    public <K, V> GridClientFuture<V> getAsync(K key);
 +
 +    /**
 +     * Gets entries from cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote nodes on which these keys are supposed to be cached (unless
 +     * some nodes were {@code pinned}). If entries do not map to one node, then the node
 +     * which has most mapped entries will be contacted.
 +     *
 +     * @param keys Keys to get.
 +     * @throws GridClientException In case of error.
 +     * @return Entries retrieved from remote cache nodes.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K, V> Map<K, V> getAll(Collection<K> keys) throws GridClientException;
 +
 +    /**
 +     * Asynchronously gets entries from cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote nodes on which these keys are supposed to be cached (unless
 +     * some nodes were {@code pinned}). If entries do not map to one node, then the node
 +     * which has most mapped entries will be contacted.
 +     *
 +     * @param keys Keys to get.
 +     * @return Future with entries retrieved from remote cache nodes.
 +     */
 +    public <K, V> GridClientFuture<Map<K, V>> getAllAsync(Collection<K> keys);
 +
 +    /**
 +     * Removes value from cache on remote node.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to remove.
 +     * @return Whether value was actually removed.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K> boolean remove(K key) throws GridClientException;
 +
 +    /**
 +     * Asynchronously removes value from cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to remove.
 +     * @return Future whether value was actually removed.
 +     */
 +    public <K> GridClientFuture<Boolean> removeAsync(K key);
 +
 +    /**
 +     * Removes entries from cache on remote node.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote nodes on which these keys are supposed to be cached (unless
 +     * some nodes were {@code pinned}). If entries do not map to one node, then the node
 +     * which has most mapped entries will be contacted.
 +     *
 +     * @param keys Keys to remove.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K> void removeAll(Collection<K> keys) throws GridClientException;
 +
 +    /**
 +     * Asynchronously removes entries from cache on remote grid.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote nodes on which these keys are supposed to be cached (unless
 +     * some nodes were {@code pinned}). If entries do not map to one node, then the node
 +     * which has most mapped entries will be contacted.
 +     *
 +     * @param keys Keys to remove.
 +     * @return Future whether operation finishes.
 +     */
 +    public <K> GridClientFuture<?> removeAllAsync(Collection<K> keys);
 +
 +    /**
 +     * Replaces value in cache on remote grid only if there was a {@code non-null}
 +     * value associated with this key.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to replace.
 +     * @param val Value to replace.
 +     * @return Whether value was actually replaced.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K, V> boolean replace(K key, V val) throws GridClientException;
 +
 +    /**
 +     * Asynchronously replaces value in cache on remote grid only if there was a {@code non-null}
 +     * value associated with this key.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to replace.
 +     * @param val Value to replace.
 +     * @return Future whether value was actually replaced.
 +     */
 +    public <K, V> GridClientFuture<Boolean> replaceAsync(K key, V val);
 +
 +    /**
 +     * Sets entry value to {@code val1} if current value is {@code val2} with
 +     * following conditions:
 +     * <ul>
 +     * <li>
 +     * If {@code val1} is {@code null} and {@code val2} is equal to current value,
 +     * entry is removed from cache.
 +     * </li>
 +     * <li>
 +     * If {@code val2} is {@code null}, entry is created if it doesn't exist.
 +     * </li>
 +     * <li>
 +     * If both {@code val1} and {@code val2} are {@code null}, entry is removed.
 +     * </li>
 +     * </ul>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to set.
 +     * @param val1 Value to set.
 +     * @param val2 Check value.
 +     * @return Whether value of entry was changed.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public <K, V> boolean cas(K key, V val1, V val2) throws GridClientException;
 +
 +    /**
 +     * Asynchronously sets entry value to {@code val1} if current value is {@code val2}
 +     * with following conditions:
 +     * <ul>
 +     * <li>
 +     * If {@code val1} is {@code null} and {@code val2} is equal to current value,
 +     * entry is removed from cache.
 +     * </li>
 +     * <li>
 +     * If {@code val2} is {@code null}, entry is created if it doesn't exist.
 +     * </li>
 +     * <li>
 +     * If both {@code val1} and {@code val2} are {@code null}, entry is removed.
 +     * </li>
 +     * </ul>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to set.
 +     * @param val1 Value to set.
 +     * @param val2 Check value.
 +     * @return Future whether value of entry was changed.
 +     */
 +    public <K, V> GridClientFuture<Boolean> casAsync(K key, V val1, V val2);
 +
 +    /**
 +     * Gets affinity node ID for provided key. This method will return {@code null} if no
 +     * affinity was configured for the given cache for this client or there are no nodes in topology with
 +     * cache enabled.
 +     *
 +     * @param key Key.
 +     * @return Node ID.
 +     * @throws GridClientException In case of error.
 +     */
 +    public <K> UUID affinity(K key) throws GridClientException;
 +
 +    /**
 +     * Fetches metrics for cache from remote grid.
 +     *
 +     * @return Cache metrics.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public GridClientDataMetrics metrics() throws GridClientException;
 +
 +    /**
 +     * Asynchronously fetches metrics for cache from remote grid.
 +     *
 +     * @return Future with cache metrics.
 +     */
 +    public GridClientFuture<GridClientDataMetrics> metricsAsync();
 +
 +    /**
 +     * Tries to get metrics from local cache.
 +     * <p>
 +     * Local cache is updated on every {@link #metrics()} or {@link #metricsAsync()} call
 +     * if {@link GridClientConfiguration#isEnableMetricsCache()} is enabled. If it is
 +     * disabled then this method will always return {@code null}.
 +     *
 +     * @return Cached metrics or {@code null} if no cached metrics available.
 +     * @throws GridClientException In case of error.
 +     * @throws GridServerUnreachableException If none of the servers can be reached.
 +     * @throws GridClientClosedException If client was closed manually.
 +     */
 +    public GridClientDataMetrics cachedMetrics() throws GridClientException;
 +
 +    /**
 +     * Append requested value to already cached one. This method supports work with strings, lists and maps.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to manipulate cache value for.
 +     * @param val Value to append to the cached one.
 +     * @return Whether value of entry was changed.
 +     * @throws GridClientException In case of error.
 +     */
 +    public <K, V> boolean append(K key, V val) throws GridClientException;
 +
 +    /**
 +     * Append requested value to already cached one. This method supports work with strings, lists and maps.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to manipulate cache value for.
 +     * @param val Value to append to the cached one.
 +     * @return Future whether value of entry was changed.
 +     * @throws GridClientException In case of error.
 +     */
 +    public <K, V> GridClientFuture<Boolean> appendAsync(K key, V val) throws GridClientException;
 +
 +    /**
 +     * Prepend requested value to already cached one. This method supports work with strings, lists and maps.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to manipulate cache value for.
 +     * @param val Value to prepend to the cached one.
 +     * @return Whether value of entry was changed.
 +     * @throws GridClientException In case of error.
 +     */
 +    public <K, V> boolean prepend(K key, V val) throws GridClientException;
 +
 +    /**
 +     * Prepend requested value to already cached one. This method supports work with strings, lists and maps.
 +     * <p>
 +     * Note that this operation is affinity-aware and will immediately contact
 +     * exactly the remote node on which this key is supposed to be cached (unless
 +     * some nodes were {@code pinned}).
 +     *
 +     * @param key Key to manipulate cache value for.
 +     * @param val Value to prepend to the cached one.
 +     * @return Future whether value of entry was changed.
 +     * @throws GridClientException In case of error.
 +     */
 +    public <K, V> GridClientFuture<Boolean> prependAsync(K key, V val) throws GridClientException;
 +
 +    /**
 +     * Gets cache flags enabled on this data projection.
 +     *
 +     * @return Flags for this data projection (empty set if no flags have been set).
 +     */
 +    public Set<GridClientCacheFlag> flags();
 +
 +    /**
 +     * Creates new client data object with enabled cache flags.
 +     *
 +     * @param flags Optional cache flags to be enabled.
 +     * @return New client data object.
 +     * @throws GridClientException In case of error.
 +     */
 +    public GridClientData flagsOn(GridClientCacheFlag... flags) throws GridClientException;
 +
 +    /**
 +     * Creates new client data object with disabled cache flags.
 +     *
 +     * @param flags Cache flags to be disabled.
 +     * @return New client data object.
 +     * @throws GridClientException In case of error.
 +     */
 +    public GridClientData flagsOff(GridClientCacheFlag... flags) throws GridClientException;
 +}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/0a1b1b7a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientFactory.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/client/GridClientFactory.java
index 0160159,0000000..1616d0a
mode 100644,000000..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientFactory.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/client/GridClientFactory.java
@@@ -1,138 -1,0 +1,138 @@@
 +/*
 + * 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 org.apache.ignite.internal.client.impl.*;
 +
 +import java.util.*;
 +import java.util.concurrent.*;
 +import java.util.concurrent.locks.*;
 +
 +/**
 + * Client factory opens and closes clients. It also tracks all currently opened clients as well.
 + */
 +public class GridClientFactory {
 +    /** Map that contain all opened clients. */
 +    private static ConcurrentMap<UUID, GridClientImpl> openClients = new ConcurrentHashMap<>();
 +
 +    /** Lock to prevent concurrent adding of clients while stopAll is working. */
 +    private static ReadWriteLock busyLock = new ReentrantReadWriteLock();
 +
 +    /**
 +     * Ensure singleton.
 +     */
 +    private GridClientFactory() {
 +        // No-op.
 +    }
 +
 +    /**
 +     * Starts a client with given configuration. Starting client will be assigned a randomly generated
 +     * UUID which can be obtained by {@link GridClient#id()} method.
 +     *
 +     * @param cfg Client configuration.
 +     * @return Started client.
 +     * @throws GridClientException If client could not be created.
 +     */
 +    public static GridClient start(GridClientConfiguration cfg) throws GridClientException {
 +        busyLock.readLock().lock();
 +
 +        try {
 +            UUID clientId = UUID.randomUUID();
 +
-             GridClientImpl client = new GridClientImpl(clientId, cfg);
++            GridClientImpl client = new GridClientImpl(clientId, cfg, false);
 +
 +            GridClientImpl old = openClients.putIfAbsent(clientId, client);
 +
 +            assert old == null : "Random unique UUID generation failed.";
 +
 +            return client;
 +        }
 +        finally {
 +            busyLock.readLock().unlock();
 +        }
 +    }
 +
 +    /**
 +     * Waits for all open clients to finish their operations and stops them, This method
 +     * is equivalent to {@code stopAll(true)} method invocation.
 +     *
 +     * @see #stopAll(boolean)
 +     */
 +    public static void stopAll() {
 +        stopAll(true);
 +    }
 +
 +    /**
 +     * Stops all currently open clients.
 +     *
 +     * @param wait If {@code true} then each client will wait to finish all ongoing requests before
 +     *      closing (however, no new requests will be accepted). If {@code false}, clients will be
 +     *      closed immediately and all ongoing requests will be failed.
 +     */
 +    @SuppressWarnings("TooBroadScope")
 +    public static void stopAll(boolean wait) {
 +        ConcurrentMap<UUID, GridClientImpl> old;
 +
 +        busyLock.writeLock().lock();
 +
 +        try {
 +            old = openClients;
 +
 +            openClients = new ConcurrentHashMap<>();
 +        }
 +        finally {
 +            busyLock.writeLock().unlock();
 +        }
 +
 +        for (GridClientImpl client : old.values())
 +            client.stop(wait);
 +    }
 +
 +    /**
 +     * Waits for all pending requests for a particular client to be completed (no new requests will be
 +     * accepted) and then closes the client. This method is equivalent to {@code stop(clientId, true)}.
 +     *
 +     * @param clientId Identifier of client to close.
 +     * @see #stop(UUID, boolean)
 +     */
 +    public static void stop(UUID clientId) {
 +        stop(clientId, true);
 +    }
 +
 +    /**
 +     * Stops particular client.
 +     *
 +     * @param clientId Client identifier to close.
 +     * @param wait If {@code true} then client will wait to finish all ongoing requests before
 +     *      closing (however, no new requests will be accepted). If {@code false}, client will be
 +     *      closed immediately and all ongoing requests will be failed.
 +     */
 +    public static void stop(UUID clientId, boolean wait) {
 +        busyLock.readLock().lock();
 +
 +        try {
 +            GridClientImpl client = openClients.remove(clientId);
 +
 +            if (client != null)
 +                client.stop(wait);
 +        }
 +        finally {
 +            busyLock.readLock().unlock();
 +        }
 +    }
 +}


Mime
View raw message