ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject incubator-ignite git commit: # ignite-648: improve framework (callable)
Date Fri, 03 Jul 2015 14:09:25 GMT
Repository: incubator-ignite
Updated Branches:
  refs/heads/ignite-648 48db19a26 -> 5b9e082be


# ignite-648: improve framework (callable)


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

Branch: refs/heads/ignite-648
Commit: 5b9e082be82ba108c5c2f1d38cd2d047efc51ce4
Parents: 48db19a
Author: ashutak <ashutak@gridgain.com>
Authored: Fri Jul 3 17:09:23 2015 +0300
Committer: ashutak <ashutak@gridgain.com>
Committed: Fri Jul 3 17:09:23 2015 +0300

----------------------------------------------------------------------
 .../cache/GridCacheAbstractFullApiSelfTest.java |  54 +++----
 .../testframework/junits/GridAbstractTest.java  | 139 +++++++++++--------
 2 files changed, 99 insertions(+), 94 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/5b9e082b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
index 8630ea7..7db882c 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/GridCacheAbstractFullApiSelfTest.java
@@ -4026,44 +4026,26 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
      * @return Collection of keys for which given cache is primary.
      */
     protected List<String> primaryKeysForCache(final IgniteCache<String, Integer>
cache, final int cnt, final int startFrom) {
-        Ignite grid = cache.unwrap(Ignite.class);
+        return executeOnLocalOrRemoteJvm(cache, new TestCacheCallable<String, Integer,
List<String>>() {
+            @Override public List<String> call(Ignite ignite, IgniteCache<String,
Integer> cache) throws Exception {
+                List<String> found = new ArrayList<>();
 
-        if (!(cache instanceof IgniteCacheProcessProxy))
-            return primaryKeysForCache0(grid.name(), cnt, startFrom);
-        else {
-            final IgniteProcessProxy proxy = (IgniteProcessProxy)grid;
-
-            final String name = proxy.name();
-
-            return proxy.remoteCompute().call(new IgniteCallable<List<String>>()
{
-                @Override public List<String> call() throws Exception {
-                    return primaryKeysForCache0(name, cnt, startFrom);
-                }
-            });
-        }
-    }
-
-    private List<String> primaryKeysForCache0(String name, int cnt, int startFrom)
{
-        List<String> found = new ArrayList<>();
+                Affinity<Object> affinity = ignite.affinity(cache.getName());
 
-        IgniteEx ignite = grid(name);
+                for (int i = startFrom; i < startFrom + 100_000; i++) {
+                    String key = "key" + i;
 
-        final IgniteCache<String, Integer> cache = ignite.cache(null);
+                    if (affinity.isPrimary(ignite.cluster().localNode(), key)) {
+                        found.add(key);
 
-        Affinity<Object> affinity = ignite.affinity(cache.getName());
-
-        for (int i = startFrom; i < startFrom + 100_000; i++) {
-            String key = "key" + i;
-
-            if (affinity.isPrimary(ignite.cluster().localNode(), key)) {
-                found.add(key);
+                        if (found.size() == cnt)
+                            return found;
+                    }
+                }
 
-                if (found.size() == cnt)
-                    return found;
+                throw new IgniteException("Unable to find " + cnt + " keys as primary for
cache.");
             }
-        }
-
-        throw new IgniteException("Unable to find " + cnt + " keys as primary for cache.");
+        });
     }
 
     /**
@@ -4255,14 +4237,14 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
      */
     private void checkIteratorsCleared() {
         for (int j = 0; j < gridCount(); j++) {
-            runOnLocalOrRemoteJvm(j, new IndexSerializableJob() {
-                @Override public void run(int i) throws Exception {
-                    GridCacheQueryManager queries = context(i).queries();
+            executeOnLocalOrRemoteJvm(j, new TestIgniteIdxRunnable() {
+                @Override public void run(int idx) throws Exception {
+                    GridCacheQueryManager queries = context(idx).queries();
 
                     Map map = GridTestUtils.getFieldValue(queries, GridCacheQueryManager.class,
"qryIters");
 
                     for (Object obj : map.values())
-                        assertEquals("Iterators not removed for grid " + i, 0, ((Map)obj).size());
+                        assertEquals("Iterators not removed for grid " + idx, 0, ((Map)obj).size());
                 }
             });
         }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/5b9e082b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
index 94fa248..6fb0b2b 100644
--- a/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/testframework/junits/GridAbstractTest.java
@@ -1368,12 +1368,9 @@ public abstract class GridAbstractTest extends TestCase {
      * @return <code>True</code> to run nodes in separate jvms.
      * @see IgniteNodeRunner
      * @see IgniteProcessProxy
-     * @see #runRemotely(int, IndexSerializableJob)
-     * @see #runRemotely(IgniteProcessProxy, IgniteSerializableJob)
-     * @see #runRemotely(IgniteCacheProcessProxy, CacheSerializiableJob)
-     * @see #runOnLocalOrRemoteJvm(int, IndexSerializableJob)
-     * @see #runOnLocalOrRemoteJvm(Ignite, IgniteSerializableJob)
-     * @see #runOnLocalOrRemoteJvm(IgniteCache, CacheSerializiableJob)
+     * @see #executeOnLocalOrRemoteJvm(int, TestIgniteIdxCallable)
+     * @see #executeOnLocalOrRemoteJvm(Ignite, TestIgniteCallable)
+     * @see #executeOnLocalOrRemoteJvm(IgniteCache, TestCacheCallable)
      */
     protected boolean isMultiJvm() {
         return false;
@@ -1424,18 +1421,18 @@ public abstract class GridAbstractTest extends TestCase {
      * @param idx Grid index.
      * @param job Job.
      */
-    public void runOnLocalOrRemoteJvm(final int idx, final IndexSerializableJob job) {
+    public <R> R executeOnLocalOrRemoteJvm(final int idx, final TestIgniteIdxCallable<R>
job) {
         IgniteEx ignite = grid(idx);
 
         if (!isMultiJvmObject(ignite))
             try {
-                job.run(idx);
+                return job.call(idx);
             }
             catch (Exception e) {
                 throw new IgniteException(e);
             }
         else
-            runRemotely(idx, job);
+            return executeRemotely(idx, job);
     }
 
     /**
@@ -1444,36 +1441,36 @@ public abstract class GridAbstractTest extends TestCase {
      * @param ignite Ignite.
      * @param job Job.
      */
-    public void runOnLocalOrRemoteJvm(Ignite ignite, final IgniteSerializableJob job) {
+    public <R> R executeOnLocalOrRemoteJvm(Ignite ignite, final TestIgniteCallable<R>
job) {
         if (!isMultiJvmObject(ignite))
             try {
-                job.run(ignite);
+                return job.call(ignite);
             }
             catch (Exception e) {
                 throw new IgniteException(e);
             }
         else
-            runRemotely((IgniteProcessProxy)ignite, job);
+            return executeRemotely((IgniteProcessProxy)ignite, job);
     }
 
     /**
-     * Runs job on local jvm or on remote jvm in multi jvm case.
+     * Calls job on local jvm or on remote jvm in multi jvm case.
      *
      * @param cache Cache.
      * @param job Job.
      */
-    public <K,V> void runOnLocalOrRemoteJvm(IgniteCache<K,V> cache, CacheSerializiableJob<K,V>
job) {
+    public <K,V,R> R executeOnLocalOrRemoteJvm(IgniteCache<K,V> cache, TestCacheCallable<K,V,R>
job) {
         Ignite ignite = cache.unwrap(Ignite.class);
 
         if (!isMultiJvmObject(ignite))
             try {
-                job.run(ignite, cache);
+                return job.call(ignite, cache);
             }
             catch (Exception e) {
                 throw new IgniteException(e);
             }
         else
-            runRemotely((IgniteCacheProcessProxy<K, V>)cache, job);
+            return executeRemotely((IgniteCacheProcessProxy<K, V>)cache, job);
     }
 
     /**
@@ -1482,7 +1479,7 @@ public abstract class GridAbstractTest extends TestCase {
      * @param idx Grid index.
      * @param job Job.
      */
-    public void runRemotely(final int idx, final IndexSerializableJob job) {
+    public <R> R executeRemotely(final int idx, final TestIgniteIdxCallable<R>
job) {
         IgniteEx ignite = grid(idx);
 
         if (!isMultiJvmObject(ignite))
@@ -1490,14 +1487,9 @@ public abstract class GridAbstractTest extends TestCase {
 
         IgniteProcessProxy proxy = (IgniteProcessProxy)ignite;
 
-        proxy.remoteCompute().run(new CAX() {
-            @Override public void applyx() throws IgniteCheckedException {
-                try {
-                    job.run(idx);
-                }
-                catch (Exception e) {
-                    throw new IgniteCheckedException(e);
-                }
+        return proxy.remoteCompute().call(new IgniteCallable<R>() {
+            @Override public R call() throws Exception {
+                return job.call(idx);
             }
         });
     }
@@ -1508,19 +1500,14 @@ public abstract class GridAbstractTest extends TestCase {
      * @param proxy Ignite.
      * @param job Job.
      */
-    public static void runRemotely(IgniteProcessProxy proxy, final IgniteSerializableJob
job) {
+    public static <R> R executeRemotely(IgniteProcessProxy proxy, final TestIgniteCallable<R>
job) {
         final UUID id = proxy.getId();
 
-        proxy.remoteCompute().run(new CAX() {
-            @Override public void applyx() throws IgniteCheckedException {
+        return proxy.remoteCompute().call(new IgniteCallable<R>() {
+            @Override public R call() throws Exception {
                 Ignite ignite = Ignition.ignite(id);
 
-                try {
-                    job.run(ignite);
-                }
-                catch (Exception e) {
-                    throw new IgniteCheckedException(e);
-                }
+                return job.call(ignite);
             }
         });
     }
@@ -1531,23 +1518,19 @@ public abstract class GridAbstractTest extends TestCase {
      * @param cache Cache.
      * @param job Job.
      */
-    public static <K, V> void runRemotely(IgniteCacheProcessProxy<K, V> cache,
final CacheSerializiableJob<K,V> job) {
+    public static <K, V, R> R executeRemotely(IgniteCacheProcessProxy<K, V> cache,
+        final TestCacheCallable<K, V, R> job) {
         IgniteProcessProxy proxy = (IgniteProcessProxy)cache.unwrap(Ignite.class);
 
         final UUID id = proxy.getId();
         final String cacheName = cache.getName();
 
-        proxy.remoteCompute().run(new CAX() {
-            @Override public void applyx() throws IgniteCheckedException {
+        return proxy.remoteCompute().call(new IgniteCallable<R>() {
+            @Override public R call() throws Exception {
                 Ignite ignite = Ignition.ignite(id);
                 IgniteCache<K,V> cache = ignite.cache(cacheName);
 
-                try {
-                    job.run(ignite, cache);
-                }
-                catch (Exception e) {
-                    throw new IgniteCheckedException(e);
-                }
+                return job.call(ignite, cache);
             }
         });
     }
@@ -1866,34 +1849,74 @@ public abstract class GridAbstractTest extends TestCase {
         }
     }
 
-    /**
-     * Serializable runnable.
-     */
-    public static interface IgniteSerializableJob extends Serializable {
+    /** */
+    public static interface TestIgniteCallable<R> extends Serializable {
         /**
          * @param ignite Ignite.
          */
-        void run(Ignite ignite) throws Exception;
+        R call(Ignite ignite) throws Exception;
     }
 
-    /**
-     * Serializiable runnable.
-     */
-    public static interface IndexSerializableJob extends Serializable {
+    /** */
+    public abstract static class TestIgniteRunnable implements TestIgniteCallable<Object>
{
+        /** {@inheritDoc} */
+        @Override public Object call(Ignite ignite) throws Exception {
+            run(ignite);
+
+            return null;
+        }
+
+        /**
+         * @param ignite Ignite.
+         */
+        public abstract void run(Ignite ignite) throws Exception;
+    }
+
+    /** */
+    public static interface TestIgniteIdxCallable<R> extends Serializable {
         /**
          * @param idx Grid index.
          */
-        void run(int idx) throws Exception;
+        R call(int idx) throws Exception;
     }
 
-    /**
-     * Serializiable runnable.
-     */
-    public static interface CacheSerializiableJob<K, V> extends Serializable {
+    /** */
+    public abstract static class TestIgniteIdxRunnable implements TestIgniteIdxCallable<Object>
{
+        /** {@inheritDoc} */
+        @Override public Object call(int idx) throws Exception {
+            run(idx);
+
+            return null;
+        }
+
+        /**
+         * @param idx Index.
+         */
+        public abstract void run(int idx) throws Exception;
+    }
+
+    /** */
+    public static interface TestCacheCallable<K, V, R> extends Serializable {
+        /**
+         * @param ignite Ignite.
+         * @param cache Cache.
+         */
+        R call(Ignite ignite, IgniteCache<K, V> cache) throws Exception;
+    }
+
+    /** */
+    public abstract static class TestTestCacheRunnable<K, V> implements TestCacheCallable<K,
V, Object> {
+        /** {@inheritDoc} */
+        @Override public Object call(Ignite ignite, IgniteCache cache) throws Exception {
+            run(ignite, cache);
+
+            return null;
+        }
+
         /**
          * @param ignite Ignite.
          * @param cache Cache.
          */
-        void run(Ignite ignite, IgniteCache<K, V> cache) throws Exception;
+        public abstract void run(Ignite ignite, IgniteCache<K, V> cache) throws Exception;
     }
 }


Mime
View raw message