ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From anovi...@apache.org
Subject [18/26] incubator-ignite git commit: # sprint-2 - javadoc fixes.
Date Thu, 26 Mar 2015 07:46:54 GMT
# sprint-2 - javadoc fixes.


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/4d867a4e
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/4d867a4e
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/4d867a4e

Branch: refs/heads/sprint-3
Commit: 4d867a4ef06860032552c30c2a9a2d410fc3a2ec
Parents: 2871d5d
Author: Dmitiry Setrakyan <dsetrakyan@gridgain.com>
Authored: Wed Mar 25 23:58:58 2015 -0700
Committer: Dmitiry Setrakyan <dsetrakyan@gridgain.com>
Committed: Wed Mar 25 23:58:58 2015 -0700

----------------------------------------------------------------------
 .../src/main/java/org/apache/ignite/Ignite.java |  59 ++++----
 .../java/org/apache/ignite/IgniteCluster.java   |   4 +-
 .../java/org/apache/ignite/IgniteEvents.java    |  60 ++++----
 .../java/org/apache/ignite/IgniteMessaging.java |  56 ++++----
 .../java/org/apache/ignite/IgniteServices.java  |  40 +++---
 .../org/apache/ignite/cluster/ClusterGroup.java | 137 ++++++++++---------
 .../configuration/CacheConfiguration.java       |   3 -
 .../configuration/IgniteConfiguration.java      |  32 ++---
 .../org/apache/ignite/lang/IgnitePredicate.java |   3 +-
 .../apache/ignite/transactions/Transaction.java |   8 +-
 10 files changed, 213 insertions(+), 189 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/Ignite.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/Ignite.java b/modules/core/src/main/java/org/apache/ignite/Ignite.java
index 36b6011..c8eb874 100644
--- a/modules/core/src/main/java/org/apache/ignite/Ignite.java
+++ b/modules/core/src/main/java/org/apache/ignite/Ignite.java
@@ -36,9 +36,6 @@ import java.util.concurrent.*;
  * can have multiple instances of {@code Grid} running in the same VM by giving
  * each instance a different name.
  * <p>
- * Note that {@code Grid} extends {@link ClusterGroup} which means that it provides grid projection
- * functionality over the whole grid (instead of a subgroup of nodes).
- * <p>
  * In addition to {@link ClusterGroup} functionality, from here you can get the following:
  * <ul>
  * <li>{@link IgniteCache} - functionality for in-memory distributed cache.</li>
@@ -95,77 +92,89 @@ public interface Ignite extends AutoCloseable {
     public IgniteCluster cluster();
 
     /**
-     * Gets {@code compute} functionality over this grid projection. All operations
-     * on the returned {@link IgniteCompute} instance will only include nodes from
-     * this projection.
+     * Gets {@code compute} facade over all cluster nodes.
      *
-     * @return Compute instance over this grid projection.
+     * @return Compute instance over all cluster nodes.
      */
     public IgniteCompute compute();
 
     /**
-     * @param grp Cluster group..
+     * Gets {@code compute} facade over the specified cluster group. All operations
+     * on the returned {@link IgniteCompute} instance will only include nodes from
+     * this cluster group.
+     *
+     * @param grp Cluster group.
      * @return Compute instance over given cluster group.
      */
     public IgniteCompute compute(ClusterGroup grp);
 
     /**
-     * Gets {@code messaging} functionality over this grid projection. All operations
-     * on the returned {@link IgniteMessaging} instance will only include nodes from
-     * this projection.
+     * Gets {@code messaging} facade over all cluster nodes.
      *
-     * @return Messaging instance over this grid projection.
+     * @return Messaging instance over all cluster nodes.
      */
     public IgniteMessaging message();
 
     /**
+     * Gets {@code messaging} facade over nodes within the cluster group.  All operations
+     * on the returned {@link IgniteMessaging} instance will only include nodes from
+     * the specified cluster group.
+     *
      * @param grp Cluster group.
      * @return Messaging instance over given cluster group.
      */
     public IgniteMessaging message(ClusterGroup grp);
 
     /**
-     * Gets {@code events} functionality over this grid projection. All operations
-     * on the returned {@link IgniteEvents} instance will only include nodes from
-     * this projection.
+     * Gets {@code events} facade over all cluster nodes.
      *
-     * @return Events instance over this grid projection.
+     * @return Events instance over all cluster nodes.
      */
     public IgniteEvents events();
 
     /**
+     * Gets {@code events} facade over nodes within the cluster group. All operations
+     * on the returned {@link IgniteEvents} instance will only include nodes from
+     * the specified cluster group.
+     *
      * @param grp Cluster group.
      * @return Events instance over given cluster group.
      */
     public IgniteEvents events(ClusterGroup grp);
 
     /**
-     * Gets {@code services} functionality over this grid projection. All operations
-     * on the returned {@link IgniteMessaging} instance will only include nodes from
-     * this projection.
+     * Gets {@code services} facade over all cluster nodes.
      *
-     * @return Services instance over this grid projection.
+     * @return Services facade over all cluster nodes.
      */
     public IgniteServices services();
 
     /**
+     * Gets {@code services} facade over nodes within the cluster group. All operations
+     * on the returned {@link IgniteMessaging} instance will only include nodes from
+     * the specified cluster group.
+     *
      * @param grp Cluster group.
      * @return {@code Services} functionality over given cluster group.
      */
     public IgniteServices services(ClusterGroup grp);
 
     /**
-     * Creates new {@link ExecutorService} which will execute all submitted
-     * {@link Callable} and {@link Runnable} jobs on nodes in this grid projection.
-     * This essentially
-     * creates a <b><i>Distributed Thread Pool</i></b> that can be used as a
-     * replacement for local thread pools.
+     * Creates a new {@link ExecutorService} which will execute all submitted
+     * {@link Callable} and {@link Runnable} jobs on all cluster nodes.
+     * This essentially creates a <b><i>Distributed Thread Pool</i></b> that can
+     * be used as a replacement for local thread pools.
      *
      * @return Grid-enabled {@code ExecutorService}.
      */
     public ExecutorService executorService();
 
     /**
+     * Creates a new {@link ExecutorService} which will execute all submitted
+     * {@link Callable} and {@link Runnable} jobs on nodes in the specified cluster group.
+     * This essentially creates a <b><i>Distributed Thread Pool</i></b> that can be used as a
+     * replacement for local thread pools.
+     *
      * @param grp Cluster group.
      * @return {@link ExecutorService} which will execute jobs on nodes in given cluster group.
      */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java b/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
index 47930b1..7d7d2fb 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteCluster.java
@@ -42,9 +42,9 @@ public interface IgniteCluster extends ClusterGroup, IgniteAsyncSupport {
     public ClusterNode localNode();
 
     /**
-     * Gets monadic projection consisting from the local node.
+     * Gets a cluster group consisting from the local node.
      *
-     * @return Monadic projection consisting from the local node.
+     * @return Cluster group consisting from the local node.
      */
     public ClusterGroup forLocal();
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/IgniteEvents.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteEvents.java b/modules/core/src/main/java/org/apache/ignite/IgniteEvents.java
index 5a92900..1f36c00 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteEvents.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteEvents.java
@@ -26,19 +26,31 @@ import java.util.*;
 
 /**
  * Provides functionality for local and remote event notifications on nodes defined by {@link #clusterGroup()}.
- * There are {@code 2} ways to subscribe to event listening, {@code local} and {@code remote}. Instance
- * of {@code GridMessaging} is obtained from grid projection as follows:
- * <pre name="code" class="java">
- * GridEvents evts = Ignition.ignite().events();
- * </pre> * <p>
+ * There are {@code 2} ways to subscribe to event listening, {@code local} and {@code remote}.
+ * <p>
+ * Instance of {@code IgniteEvents} is obtained from {@link Ignite} as follows:
+ * <pre class="brush:java">
+ * Ignite ignite = Ignition.ignite();
+ *
+ * IgniteEvents evts = ignite.events();
+ * </pre>
+ * You can also obtain an instance of the events facade over a specific cluster group:
+ * <pre class="brush:java">
+ * // Cluster group over remote nodes (excluding the local node).
+ * ClusterGroup remoteNodes = ignite.cluster().forRemotes();
+ *
+ * // Events instance spanning all remote cluster nodes.
+ * IgniteEvents evts = ignite.events(remoteNodes);
+ * </pre>
+ * <p>
  * Local subscription, defined by {@link #localListen(IgnitePredicate, int...)} method, will add
  * a listener for specified events on local node only. This listener will be notified whenever any
  * of subscribed events happen on local node regardless of whether local node belongs to underlying
- * grid projection or not.
+ * cluster group or not.
  * <p>
  * Remote subscription, defined by {@link #remoteListen(IgniteBiPredicate, IgnitePredicate, int...)}, will add an
- * event listener for specified events on all nodes in the projection (possibly including local node if
- * it belongs to the projection as well). All projection nodes will then be notified of the subscribed events.
+ * event listener for specified events on all nodes in the cluster group (possibly including local node if
+ * it belongs to the cluster group as well). All cluster group nodes will then be notified of the subscribed events.
  * If the events pass the remote event filter, the events will be sent to local node for local listener notification.
  * <p>
  * Note that by default, all events in Ignite are disabled for performance reasons. You must only enable
@@ -53,17 +65,15 @@ import java.util.*;
  */
 public interface IgniteEvents extends IgniteAsyncSupport {
     /**
-     * Gets grid projection to which this {@code GridMessaging} instance belongs.
+     * Gets cluster group to which this {@code IgniteEvents} instance belongs.
      *
-     * @return Grid projection to which this {@code GridMessaging} instance belongs.
+     * @return Cluster group to which this {@code IgniteEvents} instance belongs.
      */
     public ClusterGroup clusterGroup();
 
     /**
-     * Queries nodes in this projection for events using passed in predicate filter for event
+     * Queries nodes in this cluster group for events using passed in predicate filter for event
      * selection.
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *
      * @param p Predicate filter used to query events on remote nodes.
      * @param timeout Maximum time to wait for result, {@code 0} to wait forever.
@@ -76,15 +86,13 @@ public interface IgniteEvents extends IgniteAsyncSupport {
         throws IgniteException;
 
     /**
-     * Adds event listener for specified events to all nodes in the projection (possibly including
-     * local node if it belongs to the projection as well). This means that all events occurring on
-     * any node within this grid projection that pass remove filter will be sent to local node for
-     * local listener notification.
+     * Adds event listener for specified events to all nodes in the cluster group (possibly including
+     * local node if it belongs to the cluster group as well). This means that all events occurring on
+     * any node within this cluster group that pass remote filter will be sent to local node for
+     * local listener notifications.
      * <p>
      * The listener can be unsubscribed automatically if local node stops, if {@code locLsnr} callback
      * returns {@code false} or if {@link #stopRemoteListen(UUID)} is called.
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *
      * @param locLsnr Listener callback that is called on local node. If {@code null}, this events will be handled
      *      on remote nodes by passed in {@code rmtFilter}.
@@ -106,9 +114,9 @@ public interface IgniteEvents extends IgniteAsyncSupport {
         throws IgniteException;
 
     /**
-     * Adds event listener for specified events to all nodes in the projection (possibly including
-     * local node if it belongs to the projection as well). This means that all events occurring on
-     * any node within this grid projection that pass remove filter will be sent to local node for
+     * Adds event listener for specified events to all nodes in the cluster group (possibly including
+     * local node if it belongs to the cluster group as well). This means that all events occurring on
+     * any node within this cluster group that pass remote filter will be sent to local node for
      * local listener notification.
      * <p>
      * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
@@ -125,7 +133,7 @@ public interface IgniteEvents extends IgniteAsyncSupport {
      * @param locLsnr Callback that is called on local node. If this predicate returns {@code true},
      *      the implementation will continue listening to events. Otherwise, events
      *      listening will be stopped and listeners will be unregistered on all nodes
-     *      in the projection. If {@code null}, this events will be handled on remote nodes by
+     *      in the cluster group. If {@code null}, this events will be handled on remote nodes by
      *      passed in {@code rmtFilter} until local node stops (if {@code 'autoUnsubscribe'} is {@code true})
      *      or until {@link #stopRemoteListen(UUID)} is called.
      * @param rmtFilter Filter callback that is called on remote node. Only events that pass the remote filter
@@ -204,7 +212,7 @@ public interface IgniteEvents extends IgniteAsyncSupport {
 
     /**
      * Adds an event listener for local events. Note that listener will be added regardless of whether
-     * local node is in this projection or not.
+     * local node is in this cluster group or not.
      *
      * @param lsnr Predicate that is called on each received event. If predicate returns {@code false},
      *      it will be unregistered and will stop receiving events.
@@ -226,7 +234,7 @@ public interface IgniteEvents extends IgniteAsyncSupport {
     /**
      * Enables provided events. Allows to start recording events that
      * were disabled before. Note that specified events will be enabled
-     * regardless of whether local node is in this projection or not.
+     * regardless of whether local node is in this cluster group or not.
      *
      * @param types Events to enable.
      */
@@ -235,7 +243,7 @@ public interface IgniteEvents extends IgniteAsyncSupport {
     /**
      * Disables provided events. Allows to stop recording events that
      * were enabled before. Note that specified events will be disabled
-     * regardless of whether local node is in this projection or not.
+     * regardless of whether local node is in this cluster group or not.
      *
      * @param types Events to disable.
      */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/IgniteMessaging.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteMessaging.java b/modules/core/src/main/java/org/apache/ignite/IgniteMessaging.java
index b7e71a9..03eb621 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteMessaging.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteMessaging.java
@@ -27,23 +27,35 @@ import java.util.*;
 /**
  * Provides functionality for topic-based message exchange among nodes defined by {@link #clusterGroup()}.
  * Users can send ordered and unordered messages to various topics. Note that same topic name
- * cannot be reused between ordered and unordered messages. Instance of {@code GridMessaging}
- * is obtained from grid projection as follows:
- * <pre name="code" class="java">
- * GridMessaging m = Ignition.ignite().message();
+ * cannot be reused between ordered and unordered messages.
+ * <p>
+ * Instance of {@code IgniteMessaging} is obtained from {@link Ignite} as follows:
+ * <pre class="brush:java">
+ * Ignite ignite = Ignition.ignite();
+ *
+ * // Messaging instance spanning all cluster nodes.
+ * IgniteMessaging m = ignite.message();
+ * </pre>
+ * You can also obtain an instance of messaging facade over a specific cluster group:
+ * <pre class="brush:java">
+ * // Cluster group over remote nodes (excluding the local node).
+ * ClusterGroup remoteNodes = ignite.cluster().forRemotes();
+ *
+ * // Messaging instance spanning all remote cluster nodes.
+ * IgniteMessaging m = ignite.message(remoteNodes);
  * </pre>
  * <p>
  * There are {@code 2} ways to subscribe to message listening, {@code local} and {@code remote}.
  * <p>
  * Local subscription, defined by {@link #localListen(Object, IgniteBiPredicate)} method, will add
  * a listener for a given topic on local node only. This listener will be notified whenever any
- * node within grid projection will send a message for a given topic to this node. Local listen
- * subscription will happen regardless of whether local node belongs to this grid projection or not.
+ * node within the underlying cluster group will send a message for a given topic to this node. Local listen
+ * subscription will happen regardless of whether the local node belongs to this cluster group or not.
  * <p>
  * Remote subscription, defined by {@link #remoteListen(Object, IgniteBiPredicate)}, will add a
- * message listener for a given topic to all nodes in the projection (possibly including this node if
- * it belongs to the projection as well). This means that any node within this grid projection can send
- * a message for a given topic and all nodes within projection will receive listener notification.
+ * message listener for a given topic to all nodes in the underlying cluster group (possibly including this node if
+ * it belongs to the cluster group as well). This means that any node within this cluster group can send
+ * a message for a given topic and all nodes within the cluster group will receive listener notifications.
  * <h1 class="header">Ordered vs Unordered</h1>
  * Ignite allows for sending ordered messages (see {@link #sendOrdered(Object, Object, long)}), i.e.
  * messages will be received in the same order they were sent. Ordered messages have a {@code timeout}
@@ -54,14 +66,14 @@ import java.util.*;
  */
 public interface IgniteMessaging extends IgniteAsyncSupport {
     /**
-     * Gets grid projection to which this {@code GridMessaging} instance belongs.
+     * Gets the cluster group to which this {@code GridMessaging} instance belongs.
      *
-     * @return Grid projection to which this {@code GridMessaging} instance belongs.
+     * @return Cluster group to which this {@code GridMessaging} instance belongs.
      */
     public ClusterGroup clusterGroup();
 
     /**
-     * Sends given message with specified topic to the nodes in this projection.
+     * Sends given message with specified topic to the nodes in the underlying cluster group.
      *
      * @param topic Topic to send to, {@code null} for default topic.
      * @param msg Message to send.
@@ -71,7 +83,7 @@ public interface IgniteMessaging extends IgniteAsyncSupport {
     public void send(@Nullable Object topic, Object msg) throws IgniteException;
 
     /**
-     * Sends given messages with specified topic to the nodes in this projection.
+     * Sends given messages with the specified topic to the nodes in the underlying cluster group.
      *
      * @param topic Topic to send to, {@code null} for default topic.
      * @param msgs Messages to send. Order of the sending is undefined. If the method produces
@@ -82,7 +94,7 @@ public interface IgniteMessaging extends IgniteAsyncSupport {
     public void send(@Nullable Object topic, Collection<?> msgs) throws IgniteException;
 
     /**
-     * Sends given message with specified topic to the nodes in this projection. Messages sent with
+     * Sends given message with specified topic to the nodes in the underlying cluster group. Messages sent with
      * this method will arrive in the same order they were sent. Note that if a topic is used
      * for ordered messages, then it cannot be reused for non-ordered messages.
      * <p>
@@ -102,8 +114,8 @@ public interface IgniteMessaging extends IgniteAsyncSupport {
 
     /**
      * Adds local listener for given topic on local node only. This listener will be notified whenever any
-     * node within grid projection will send a message for a given topic to this node. Local listen
-     * subscription will happen regardless of whether local node belongs to this grid projection or not.
+     * node within the cluster group will send a message for a given topic to this node. Local listen
+     * subscription will happen regardless of whether local node belongs to this cluster group or not.
      *
      * @param topic Topic to subscribe to.
      * @param p Predicate that is called on each received message. If predicate returns {@code false},
@@ -120,12 +132,10 @@ public interface IgniteMessaging extends IgniteAsyncSupport {
     public void stopLocalListen(@Nullable Object topic, IgniteBiPredicate<UUID, ?> p);
 
     /**
-     * Adds a message listener for a given topic to all nodes in the projection (possibly including
-     * this node if it belongs to the projection as well). This means that any node within this grid
-     * projection can send a message for a given topic and all nodes within projection will receive
-     * listener notification.
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
+     * Adds a message listener for a given topic to all nodes in the cluster group (possibly including
+     * this node if it belongs to the cluster group as well). This means that any node within this cluster
+     * group can send a message for a given topic and all nodes within the cluster group will receive
+     * listener notifications.
      *
      * @param topic Topic to subscribe to, {@code null} means default topic.
      * @param p Predicate that is called on each node for each received message. If predicate returns {@code false},
@@ -137,7 +147,7 @@ public interface IgniteMessaging extends IgniteAsyncSupport {
     public UUID remoteListen(@Nullable Object topic, IgniteBiPredicate<UUID, ?> p) throws IgniteException;
 
     /**
-     * Unregisters all listeners identified with provided operation ID on all nodes in this projection.
+     * Unregisters all listeners identified with provided operation ID on all nodes in the cluster group.
      * <p>
      * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/IgniteServices.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/IgniteServices.java b/modules/core/src/main/java/org/apache/ignite/IgniteServices.java
index 91f7a24..df20065 100644
--- a/modules/core/src/main/java/org/apache/ignite/IgniteServices.java
+++ b/modules/core/src/main/java/org/apache/ignite/IgniteServices.java
@@ -27,11 +27,23 @@ import org.jetbrains.annotations.*;
 import java.util.*;
 
 /**
- * Defines functionality necessary to deploy distributed services on the grid. Instance of
- * {@code GridServices} is obtained from grid projection as follows:
- * <pre name="code" class="java">
- * GridServices svcs = Ignition.ignite().services();
+ * Defines functionality necessary to deploy distributed services on the grid.
+ * <p>
+ * Instance of {@code IgniteServices} which spans all cluster nodes can be obtained from Ignite as follows:
+ * <pre class="brush:java">
+ * Ignite ignite = Ignition.ignite();
+ *
+ * IgniteServices svcs = ignite.services();
+ * </pre>
+ * You can also obtain an instance of the services facade over a specific cluster group:
+ * <pre class="brush:java">
+ * // Cluster group over remote nodes (excluding the local node).
+ * ClusterGroup remoteNodes = ignite.cluster().forRemotes();
+ *
+ * // Services instance spanning all remote cluster nodes.
+ * IgniteServices svcs = ignite.services(remoteNodes);
  * </pre>
+ * <p>
  * With distributed services you can do the following:
  * <ul>
  * <li>Automatically deploy any number of service instances on the grid.</li>
@@ -122,9 +134,9 @@ import java.util.*;
  */
 public interface IgniteServices extends IgniteAsyncSupport {
     /**
-     * Gets grid projection to which this {@code GridServices} instance belongs.
+     * Gets the cluster group to which this {@code GridServices} instance belongs.
      *
-     * @return Grid projection to which this {@code GridServices} instance belongs.
+     * @return Cluster group to which this {@code GridServices} instance belongs.
      */
     public ClusterGroup clusterGroup();
 
@@ -140,8 +152,6 @@ public interface IgniteServices extends IgniteAsyncSupport {
      * <p>
      * This method is analogous to calling
      * {@link #deployMultiple(String, org.apache.ignite.services.Service, int, int) deployMultiple(name, svc, 1, 1)} method.
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *
      * @param name Service name.
      * @param svc Service instance.
@@ -153,13 +163,11 @@ public interface IgniteServices extends IgniteAsyncSupport {
     /**
      * Deploys a per-node singleton service. Ignite will guarantee that there is always
      * one instance of the service running on each node. Whenever new nodes are started
-     * within this grid projection, Ignite will automatically deploy one instance of
+     * within the underlying cluster group, Ignite will automatically deploy one instance of
      * the service on every new node.
      * <p>
      * This method is analogous to calling
      * {@link #deployMultiple(String, org.apache.ignite.services.Service, int, int) deployMultiple(name, svc, 0, 1)} method.
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *
      * @param name Service name.
      * @param svc Service instance.
@@ -191,8 +199,6 @@ public interface IgniteServices extends IgniteAsyncSupport {
      *
      *     grid.services().deploy(cfg);
      * </pre>
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *
      * @param name Service name.
      * @param svc Service instance.
@@ -228,8 +234,6 @@ public interface IgniteServices extends IgniteAsyncSupport {
      *
      *     grid.services().deploy(cfg);
      * </pre>
-     * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
      *
      * @param name Service name.
      * @param svc Service instance.
@@ -255,14 +259,12 @@ public interface IgniteServices extends IgniteAsyncSupport {
      * <p>
      * If {@link org.apache.ignite.services.ServiceConfiguration#getNodeFilter() cfg.getNodeFilter()} is not {@code null}, then
      * Ignite will deploy service on all grid nodes for which the provided filter evaluates to {@code true}.
-     * The node filter will be checked in addition to the underlying grid projection filter, or the
-     * whole grid, if the underlying grid projection includes all grid nodes.
+     * The node filter will be checked in addition to the underlying cluster group filter, or the
+     * whole grid, if the underlying cluster group includes all the cluster nodes.
      * <p>
      * Note that at least one of {@code 'totalCnt'} or {@code 'maxPerNodeCnt'} parameters must have
      * value greater than {@code 0}.
      * <p>
-     * Supports asynchronous execution (see {@link IgniteAsyncSupport}).
-     * <p>
      * Here is an example of creating service deployment configuration:
      * <pre name="code" class="java">
      *     GridServiceConfiguration cfg = new GridServiceConfiguration();

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
index 6947f76..06854d4 100644
--- a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
+++ b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
@@ -61,67 +61,67 @@ public interface ClusterGroup {
     public Ignite ignite();
 
     /**
-     * Creates a grid projection over a given set of nodes.
+     * Creates a cluster group over a given set of nodes.
      *
-     * @param nodes Collection of nodes to create a projection from.
-     * @return Projection over provided grid nodes.
+     * @param nodes Collection of nodes to create the cluster group from.
+     * @return Cluster group for the provided grid nodes.
      */
     public ClusterGroup forNodes(Collection<? extends ClusterNode> nodes);
 
     /**
-     * Creates a grid projection for the given node.
+     * Creates a cluster group for the given node.
      *
-     * @param node Node to get projection for.
-     * @param nodes Optional additional nodes to include into projection.
-     * @return Grid projection for the given node.
+     * @param node Node to create cluster group for.
+     * @param nodes Optional additional nodes to include into the cluster group.
+     * @return Cluster group for the given nodes.
      */
     public ClusterGroup forNode(ClusterNode node, ClusterNode... nodes);
 
     /**
-     * Creates a grid projection for nodes other than given nodes.
+     * Creates a cluster group for nodes other than the given nodes.
      *
-     * @param node Node to exclude from new grid projection.
-     * @param nodes Optional additional nodes to exclude from projection.
-     * @return Projection that will contain all nodes that original projection contained excluding
-     *      given nodes.
+     * @param node Node to exclude from the new cluster group.
+     * @param nodes Optional additional nodes to exclude from the cluster group.
+     * @return Cluster group that will contain all nodes from the original cluster group excluding
+     *      the given nodes.
      */
     public ClusterGroup forOthers(ClusterNode node, ClusterNode... nodes);
 
     /**
-     * Creates a grid projection for nodes not included into given projection.
+     * Creates a cluster group for nodes not included into the given cluster group.
      *
-     * @param prj Projection to exclude from new grid projection.
-     * @return Projection for nodes not included into given projection.
+     * @param prj Cluster group to exclude from the new cluster group.
+     * @return Cluster group for nodes not included into the given cluster group.
      */
     public ClusterGroup forOthers(ClusterGroup prj);
 
     /**
-     * Creates a grid projection over nodes with specified node IDs.
+     * Creates a cluster group over nodes with specified node IDs.
      *
      * @param ids Collection of node IDs.
-     * @return Projection over nodes with specified node IDs.
+     * @return Cluster group over nodes with the specified node IDs.
      */
     public ClusterGroup forNodeIds(Collection<UUID> ids);
 
     /**
-     * Creates a grid projection for a node with specified ID.
+     * Creates a cluster group for a node with the specified ID.
      *
-     * @param id Node ID to get projection for.
-     * @param ids Optional additional node IDs to include into projection.
-     * @return Projection over node with specified node ID.
+     * @param id Node ID to get the cluster group for.
+     * @param ids Optional additional node IDs to include into the cluster group.
+     * @return Cluster group over the node with the specified node IDs.
      */
     public ClusterGroup forNodeId(UUID id, UUID... ids);
 
     /**
-     * Creates a grid projection which includes all nodes that pass the given predicate filter.
+     * Creates a new cluster group which includes all nodes that pass the given predicate filter.
      *
-     * @param p Predicate filter for nodes to include into this projection.
-     * @return Grid projection for nodes that passed the predicate filter.
+     * @param p Predicate filter for nodes to include into the cluster group.
+     * @return Cluster group for nodes that passed the predicate filter.
      */
     public ClusterGroup forPredicate(IgnitePredicate<ClusterNode> p);
 
     /**
-     * Creates projection for nodes containing given name and value
+     * Creates a new cluster group for nodes containing given name and value
      * specified in user attributes.
      * <p>
      * User attributes for every node are optional and can be specified in
@@ -130,7 +130,7 @@ public interface ClusterGroup {
      *
      * @param name Name of the attribute.
      * @param val Optional attribute value to match.
-     * @return Grid projection for nodes containing specified attribute.
+     * @return Cluster group for nodes containing specified attribute.
      */
     public ClusterGroup forAttribute(String name, @Nullable String val);
 
@@ -153,124 +153,125 @@ public interface ClusterGroup {
     public ClusterGroup forClients();
 
     /**
-     * Creates projection for all nodes that have cache with specified name running.
+     * Creates a cluster group for all nodes that have cache with specified name, either in client or server modes.
      *
      * @param cacheName Cache name.
-     * @return Projection over nodes that have specified cache running.
+     * @return Cluster group over nodes that have specified cache running.
      */
     public ClusterGroup forCacheNodes(String cacheName);
 
     /**
-     * Creates projection for all affinity nodes that have cache with specified name running.
+     * Creates a cluster group for all data nodes that have the cache with the specified name running.
      *
      * @param cacheName Cache name.
-     * @return Projection over nodes that have specified cache running.
+     * @return Cluster group over nodes that have the cache with the specified name running.
      */
     public ClusterGroup forDataNodes(String cacheName);
 
     /**
-     * Creates projection for all non-affinity nodes that have cache with specified name running.
+     * Creates a cluster group for all client nodes that access cache with the specified name.
      *
      * @param cacheName Cache name.
-     * @return Projection over nodes that have specified cache running.
+     * @return Cluster group over nodes that have the specified cache running.
      */
     public ClusterGroup forClientNodes(String cacheName);
 
     /**
-     * Gets grid projection consisting from the nodes in this projection excluding the local node.
+     * Gets cluster group consisting from the nodes in this cluster group excluding the local node.
      *
-     * @return Grid projection consisting from the nodes in this projection excluding the local node, if any.
+     * @return Cluster group consisting from the nodes in this cluster group excluding the local node.
      */
     public ClusterGroup forRemotes();
 
     /**
-     * Gets grid projection consisting from the nodes in this projection residing on the
-     * same host as given node.
+     * Gets cluster group consisting from the nodes in this cluster group residing on the
+     * same host as the given node.
      *
-     * @param node Node residing on the host for which projection is created.
-     * @return Projection for nodes residing on the same host as passed in node.
+     * @param node Node to select the host for.
+     * @return Cluster group for nodes residing on the same host as the specified node.
      */
     public ClusterGroup forHost(ClusterNode node);
 
     /**
-     * Gets projection consisting from the daemon nodes in this projection.
+     * Gets a cluster group consisting from the daemon nodes.
      * <p>
      * Daemon nodes are the usual grid nodes that participate in topology but not
-     * visible on the main APIs, i.e. they are not part of any projections. The only
+     * visible on the main APIs, i.e. they are not part of any cluster group. The only
      * way to see daemon nodes is to use this method.
      * <p>
      * Daemon nodes are used primarily for management and monitoring functionality that
-     * is build on Ignite and needs to participate in the topology but also needs to be
-     * excluded from "normal" topology so that it won't participate in task execution
+     * is build on Ignite and needs to participate in the topology, but also needs to be
+     * excluded from the "normal" topology, so that it won't participate in the task execution
      * or in-memory data grid storage.
      *
-     * @return Grid projection consisting from the daemon nodes in this projection.
+     * @return Cluster group consisting from the daemon nodes.
      */
     public ClusterGroup forDaemons();
 
     /**
-     * Creates grid projection with one random node from current projection.
+     * Creates a cluster group with one random node from the current cluster group.
      *
-     * @return Grid projection with one random node from current projection.
+     * @return Cluster group containing one random node from the current cluster group.
      */
     public ClusterGroup forRandom();
 
     /**
-     * Creates grid projection with one oldest node in the current projection.
-     * The resulting projection is dynamic and will always pick the next oldest
-     * node if the previous one leaves topology even after the projection has
+     * Creates a cluster group with one oldest node from the current cluster group.
+     * The resulting cluster group is dynamic and will always pick the next oldest
+     * node if the previous one leaves topology even after the cluster group has
      * been created.
+     * <p>
+     * Use {@link #node()} method to get the oldest node.
      *
-     * @return Grid projection with one oldest node from the current projection.
+     * @return Cluster group containing one oldest node from the current cluster group.
      */
     public ClusterGroup forOldest();
 
     /**
-     * Creates grid projection with one youngest node in the current projection.
-     * The resulting projection is dynamic and will always pick the newest
-     * node in the topology, even if more nodes entered after the projection
+     * Creates a cluster group with one youngest node in the current cluster group.
+     * The resulting cluster group is dynamic and will always pick the newest
+     * node in the topology, even if more nodes entered after the cluster group
      * has been created.
      *
-     * @return Grid projection with one youngest node from the current projection.
+     * @return Cluster group containing one youngest node from the current cluster group.
      */
     public ClusterGroup forYoungest();
 
     /**
-     * Gets read-only collections of nodes in this projection.
+     * Gets the read-only collection of nodes in this cluster group.
      *
-     * @return All nodes in this projection.
+     * @return All nodes in this cluster group.
      */
     public Collection<ClusterNode> nodes();
 
     /**
-     * Gets a node for given ID from this grid projection.
+     * Gets a node for given ID from this cluster group.
      *
      * @param nid Node ID.
-     * @return Node with given ID from this projection or {@code null} if such node does not exist in this
-     *      projection.
+     * @return Node with given ID from this cluster group or {@code null}, if such node does not exist.
      */
-    @Nullable public ClusterNode node(UUID nid);
+    public ClusterNode node(UUID nid);
 
     /**
-     * Gets first node from the list of nodes in this projection. This method is specifically
-     * useful for projection over one node only.
+     * Gets first node from the list of nodes in this cluster group. This method is specifically
+     * useful for cluster groups with one node only.
      *
-     * @return First node from the list of nodes in this projection or {@code null} if projection is empty.
+     * @return First node from the list of nodes in this cluster group or {@code null} if the cluster group is empty.
      */
-    @Nullable public ClusterNode node();
+    public ClusterNode node();
 
     /**
-     * Gets predicate that defines a subset of nodes for this projection.
+     * Gets predicate that defines a subset of nodes for this cluster group.
      *
-     * @return Predicate that defines a subset of nodes for this projection.
+     * @return Predicate that defines a subset of nodes for this cluster group.
      */
     public IgnitePredicate<ClusterNode> predicate();
 
     /**
-     * Gets a metrics snapshot for this projection.
+     * Gets a metrics snapshot for this cluster group.
      *
-     * @return Grid projection metrics snapshot.
-     * @throws IgniteException If projection is empty.
+     * @return Metrics snapshot.
+     * @throws IgniteException If this cluster group is empty.
      */
     public ClusterMetrics metrics() throws IgniteException;
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
index 0c253cc..19e9c62 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/CacheConfiguration.java
@@ -1016,9 +1016,6 @@ public class CacheConfiguration<K, V> extends MutableConfiguration<K, V> {
     /**
      * Flag indicating whether Ignite should use swap storage by default. By default
      * swap is disabled which is defined via {@link #DFLT_SWAP_ENABLED} constant.
-     * <p>
-     * Note that this flag may be overridden for cache projection created with flag
-     * {@link CacheFlag#SKIP_SWAP}.
      *
      * @return {@code True} if swap storage is enabled.
      */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
index 0ac1fd7..5baa42c 100644
--- a/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
+++ b/modules/core/src/main/java/org/apache/ignite/configuration/IgniteConfiguration.java
@@ -30,27 +30,27 @@ import org.apache.ignite.marshaller.*;
 import org.apache.ignite.marshaller.jdk.*;
 import org.apache.ignite.marshaller.optimized.*;
 import org.apache.ignite.plugin.*;
-import org.apache.ignite.spi.checkpoint.noop.*;
-import org.apache.ignite.spi.collision.noop.*;
-import org.apache.ignite.spi.communication.tcp.*;
-import org.apache.ignite.spi.deployment.local.*;
-import org.apache.ignite.spi.discovery.tcp.*;
-import org.apache.ignite.spi.eventstorage.memory.*;
-import org.apache.ignite.spi.failover.always.*;
-import org.apache.ignite.spi.indexing.*;
-import org.apache.ignite.spi.loadbalancing.roundrobin.*;
-import org.apache.ignite.spi.swapspace.file.*;
 import org.apache.ignite.plugin.segmentation.*;
 import org.apache.ignite.services.*;
 import org.apache.ignite.spi.checkpoint.*;
+import org.apache.ignite.spi.checkpoint.noop.*;
 import org.apache.ignite.spi.collision.*;
+import org.apache.ignite.spi.collision.noop.*;
 import org.apache.ignite.spi.communication.*;
+import org.apache.ignite.spi.communication.tcp.*;
 import org.apache.ignite.spi.deployment.*;
+import org.apache.ignite.spi.deployment.local.*;
 import org.apache.ignite.spi.discovery.*;
+import org.apache.ignite.spi.discovery.tcp.*;
 import org.apache.ignite.spi.eventstorage.*;
+import org.apache.ignite.spi.eventstorage.memory.*;
 import org.apache.ignite.spi.failover.*;
+import org.apache.ignite.spi.failover.always.*;
+import org.apache.ignite.spi.indexing.*;
 import org.apache.ignite.spi.loadbalancing.*;
+import org.apache.ignite.spi.loadbalancing.roundrobin.*;
 import org.apache.ignite.spi.swapspace.*;
+import org.apache.ignite.spi.swapspace.file.*;
 
 import javax.cache.event.*;
 import javax.cache.expiry.*;
@@ -486,12 +486,12 @@ public class IgniteConfiguration {
      * Whether or not this node should be a daemon node.
      * <p>
      * Daemon nodes are the usual grid nodes that participate in topology but not
-     * visible on the main APIs, i.e. they are not part of any projections. The only
+     * visible on the main APIs, i.e. they are not part of any cluster groups. The only
      * way to see daemon nodes is to use {@link ClusterGroup#forDaemons()} method.
      * <p>
      * Daemon nodes are used primarily for management and monitoring functionality that
-     * is build on Ignite and needs to participate in the topology but also needs to be
-     * excluded from "normal" topology so that it won't participate in task execution
+     * is build on Ignite and needs to participate in the topology, but also needs to be
+     * excluded from the "normal" topology, so that it won't participate in the task execution
      * or in-memory data grid storage.
      *
      * @return {@code True} if this node should be a daemon node, {@code false} otherwise.
@@ -505,12 +505,12 @@ public class IgniteConfiguration {
      * Sets daemon flag.
      * <p>
      * Daemon nodes are the usual grid nodes that participate in topology but not
-     * visible on the main APIs, i.e. they are not part of any projections. The only
+     * visible on the main APIs, i.e. they are not part of any cluster group. The only
      * way to see daemon nodes is to use {@link ClusterGroup#forDaemons()} method.
      * <p>
      * Daemon nodes are used primarily for management and monitoring functionality that
-     * is build on Ignite and needs to participate in the topology but also needs to be
-     * excluded from "normal" topology so that it won't participate in task execution
+     * is build on Ignite and needs to participate in the topology, but also needs to be
+     * excluded from the "normal" topology, so that it won't participate in the task execution
      * or in-memory data grid storage.
      *
      * @param daemon Daemon flag.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/lang/IgnitePredicate.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/lang/IgnitePredicate.java b/modules/core/src/main/java/org/apache/ignite/lang/IgnitePredicate.java
index 8572885..367a69d 100644
--- a/modules/core/src/main/java/org/apache/ignite/lang/IgnitePredicate.java
+++ b/modules/core/src/main/java/org/apache/ignite/lang/IgnitePredicate.java
@@ -20,8 +20,7 @@ package org.apache.ignite.lang;
 import java.io.*;
 
 /**
- * Defines a predicate which accepts a parameter and returns {@code true} or {@code false}. In
- * Ignite, predicates are generally used for filtering nodes within grid projections.
+ * Defines a predicate which accepts a parameter and returns {@code true} or {@code false}.
  *
  * @param <E> Type of predicate parameter.
  */

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/4d867a4e/modules/core/src/main/java/org/apache/ignite/transactions/Transaction.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/transactions/Transaction.java b/modules/core/src/main/java/org/apache/ignite/transactions/Transaction.java
index d3954ff..256dcb4 100644
--- a/modules/core/src/main/java/org/apache/ignite/transactions/Transaction.java
+++ b/modules/core/src/main/java/org/apache/ignite/transactions/Transaction.java
@@ -18,7 +18,6 @@
 package org.apache.ignite.transactions;
 
 import org.apache.ignite.*;
-import org.apache.ignite.internal.processors.cache.*;
 import org.apache.ignite.lang.*;
 
 import java.util.*;
@@ -27,8 +26,8 @@ import java.util.*;
  * Grid cache transaction. Cache transactions have a default 2PC (two-phase-commit) behavior and
  * can be plugged into ongoing {@code JTA} transaction by properly implementing
  * {@ignitelink org.apache.ignite.cache.jta.CacheTmLookup}
- * interface. Cache transactions can also be started explicitly directly from {@link CacheProjection} API
- * via any of the {@code 'CacheProjection.txStart(..)'} methods.
+ * interface. Cache transactions can also be started explicitly directly from {@link IgniteTransactions} API
+ * via any of the {@code 'IgniteTransactions.txStart(..)'} methods.
  * <p>
  * Cache transactions support the following isolation levels:
  * <ul>
@@ -66,8 +65,7 @@ import java.util.*;
  *  all nodes reply {@code 'OK'} (i.e. {@code Phase 1} completes successfully), a one-way' {@code 'COMMIT'}
  *  message is sent without waiting for reply. If it is necessary to know whenever remote nodes have committed
  *  as well, synchronous commit or synchronous rollback should be enabled via
- *  {@link org.apache.ignite.configuration.CacheConfiguration#setWriteSynchronizationMode}
- *  or by setting proper flags on cache projection, such as {@link org.apache.ignite.internal.processors.cache.CacheFlag#SYNC_COMMIT}.
+ *  {@link org.apache.ignite.configuration.CacheConfiguration#setWriteSynchronizationMode}.
  *  <p>
  *  Note that in this mode, optimistic failures are only possible in conjunction with
  *  {@link TransactionIsolation#SERIALIZABLE} isolation level. In all other cases, optimistic


Mime
View raw message