ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [11/28] ignite git commit: IGNITE-5342 - Skip permission check for TASK_EXECUTE for service jobs
Date Thu, 01 Jun 2017 15:32:36 GMT
IGNITE-5342 - Skip permission check for TASK_EXECUTE for service jobs

(cherry picked from commit d77a134)


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

Branch: refs/heads/ignite-5075-pds
Commit: abb9d9428696ddb3a250e9a491d4abea437d2a38
Parents: 858d11b
Author: dkarachentsev <dkarachentsev@gridgain.com>
Authored: Wed May 31 16:57:29 2017 +0300
Committer: dkarachentsev <dkarachentsev@gridgain.com>
Committed: Wed May 31 16:57:29 2017 +0300

----------------------------------------------------------------------
 .../cache/CacheAffinitySharedManager.java       |  52 +--
 .../processors/cache/GridCacheProcessor.java    |  39 +-
 .../GridDhtPartitionsExchangeFuture.java        |   2 +-
 ...IgniteClientCacheInitializationFailTest.java | 367 +++++++++++++++++++
 .../testsuites/IgniteCacheTestSuite4.java       |   2 +
 5 files changed, 432 insertions(+), 30 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/abb9d942/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheAffinitySharedManager.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheAffinitySharedManager.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheAffinitySharedManager.java
index 889eeda..9063a12 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheAffinitySharedManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheAffinitySharedManager.java
@@ -396,40 +396,48 @@ public class CacheAffinitySharedManager<K, V> extends GridCacheSharedManagerAdap
                     CU.affinityNode(cctx.localNode(), req.startCacheConfiguration().getNodeFilter());
             }
 
-            if (startCache) {
-                cctx.cache().prepareCacheStart(cacheDesc, nearCfg, fut.topologyVersion());
+            try {
+                if (startCache) {
+                    cctx.cache().prepareCacheStart(cacheDesc, nearCfg, fut.topologyVersion());
 
-                if (fut.cacheAddedOnExchange(cacheDesc.cacheId(), cacheDesc.receivedFrom()))
{
-                    if (fut.discoCache().cacheAffinityNodes(req.cacheName()).isEmpty())
-                        U.quietAndWarn(log, "No server nodes found for cache client: " +
req.cacheName());
+                    if (fut.cacheAddedOnExchange(cacheDesc.cacheId(), cacheDesc.receivedFrom()))
{
+                        if (fut.discoCache().cacheAffinityNodes(req.cacheName()).isEmpty())
+                            U.quietAndWarn(log, "No server nodes found for cache client:
" + req.cacheName());
+                    }
                 }
-            }
 
-            if (!crd || !lateAffAssign) {
-                GridCacheContext cacheCtx = cctx.cacheContext(cacheDesc.cacheId());
+                if (!crd || !lateAffAssign) {
+                    GridCacheContext cacheCtx = cctx.cacheContext(cacheDesc.cacheId());
 
-                if (cacheCtx != null && !cacheCtx.isLocal()) {
-                    boolean clientCacheStarted =
-                        req.clientStartOnly() && req.initiatingNodeId().equals(cctx.localNodeId());
+                    if (cacheCtx != null && !cacheCtx.isLocal()) {
+                        boolean clientCacheStarted =
+                            req.clientStartOnly() && req.initiatingNodeId().equals(cctx.localNodeId());
 
-                    if (clientCacheStarted)
-                        initAffinity(cacheDesc, cacheCtx.affinity().affinityCache(), fut,
lateAffAssign);
-                    else if (!req.clientStartOnly()) {
-                        assert fut.topologyVersion().equals(cacheCtx.startTopologyVersion());
+                        if (clientCacheStarted)
+                            initAffinity(cacheDesc, cacheCtx.affinity().affinityCache(),
fut, lateAffAssign);
+                        else if (!req.clientStartOnly()) {
+                            assert fut.topologyVersion().equals(cacheCtx.startTopologyVersion());
 
-                        GridAffinityAssignmentCache aff = cacheCtx.affinity().affinityCache();
+                            GridAffinityAssignmentCache aff = cacheCtx.affinity().affinityCache();
 
-                        assert aff.lastVersion().equals(AffinityTopologyVersion.NONE) : aff.lastVersion();
+                            assert aff.lastVersion().equals(AffinityTopologyVersion.NONE)
: aff.lastVersion();
 
-                        List<List<ClusterNode>> assignment = aff.calculate(fut.topologyVersion(),
-                            fut.discoveryEvent(), fut.discoCache());
+                            List<List<ClusterNode>> assignment = aff.calculate(fut.topologyVersion(),
+                                fut.discoveryEvent(), fut.discoCache());
 
-                        aff.initialize(fut.topologyVersion(), assignment);
+                            aff.initialize(fut.topologyVersion(), assignment);
+                        }
                     }
                 }
+                else
+                    initStartedCacheOnCoordinator(fut, cacheDesc.cacheId());
+            }
+            catch (IgniteCheckedException e) {
+                U.error(log, "Failed to initialize cache. Will try to rollback cache start
routine. " +
+                    "[cacheName=" + req.cacheName() + ']', e);
+
+                cctx.cache().forceCloseCache(fut.topologyVersion(), action, e);
             }
-            else
-                initStartedCacheOnCoordinator(fut, cacheDesc.cacheId());
         }
 
         for (DynamicCacheChangeRequest req : exchActions.closeRequests(cctx.localNodeId()))
{

http://git-wip-us.apache.org/repos/asf/ignite/blob/abb9d942/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
index dbcddf4..c7e8670 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProcessor.java
@@ -1890,8 +1890,8 @@ public class GridCacheProcessor extends GridProcessorAdapter {
     /**
      * @param req Stop request.
      */
-    private void prepareCacheStop(DynamicCacheChangeRequest req) {
-        assert req.stop() || req.close() : req;
+    private void prepareCacheStop(DynamicCacheChangeRequest req, boolean forceClose) {
+        assert req.stop() || req.close() || forceClose : req;
 
         GridCacheAdapter<?, ?> cache = caches.remove(req.cacheName());
 
@@ -1907,6 +1907,27 @@ public class GridCacheProcessor extends GridProcessorAdapter {
     }
 
     /**
+     * Closes cache even if it's not fully initialized (e.g. fail on cache init stage).
+     *
+     * @param topVer Completed topology version.
+     * @param act Exchange action.
+     * @param err Error.
+     */
+    void forceCloseCache(
+        AffinityTopologyVersion topVer,
+        final ExchangeActions.ActionData act,
+        Throwable err
+    ) {
+        ExchangeActions actions = new ExchangeActions(){
+            @Override List<DynamicCacheChangeRequest> closeRequests(UUID nodeId) {
+                return Collections.singletonList(act.request());
+            }
+        };
+
+        onExchangeDone(topVer, actions, err, true);
+    }
+
+    /**
      * Callback invoked when first exchange future for dynamic cache is completed.
      *
      * @param topVer Completed topology version.
@@ -1917,7 +1938,8 @@ public class GridCacheProcessor extends GridProcessorAdapter {
     public void onExchangeDone(
         AffinityTopologyVersion topVer,
         @Nullable ExchangeActions exchActions,
-        Throwable err
+        Throwable err,
+        boolean forceClose
     ) {
         for (GridCacheAdapter<?, ?> cache : caches.values()) {
             GridCacheContext<?, ?> cacheCtx = cache.context();
@@ -1930,11 +1952,11 @@ public class GridCacheProcessor extends GridProcessorAdapter {
             }
         }
 
-        if (exchActions != null && err == null) {
+        if (exchActions != null && (err == null || forceClose)) {
             for (ExchangeActions.ActionData action : exchActions.cacheStopRequests()) {
                 stopGateway(action.request());
 
-                prepareCacheStop(action.request());
+                prepareCacheStop(action.request(), forceClose);
             }
 
             for (DynamicCacheChangeRequest req : exchActions.closeRequests(ctx.localNodeId()))
{
@@ -1955,9 +1977,12 @@ public class GridCacheProcessor extends GridProcessorAdapter {
 
                         proxy.context().gate().onStopped();
 
-                        prepareCacheStop(req);
+                        prepareCacheStop(req, forceClose);
                     }
                 }
+
+                if (forceClose)
+                    completeCacheStartFuture(req, false, err);
             }
         }
     }
@@ -1978,7 +2003,7 @@ public class GridCacheProcessor extends GridProcessorAdapter {
      * @param req Request to complete future for.
      * @param err Error if any.
      */
-    void completeCacheStartFuture(DynamicCacheChangeRequest req, boolean success, @Nullable
Exception err) {
+    void completeCacheStartFuture(DynamicCacheChangeRequest req, boolean success, @Nullable
Throwable err) {
         if (req.initiatingNodeId().equals(ctx.localNodeId())) {
             DynamicCacheStartFuture fut = (DynamicCacheStartFuture)pendingFuts.get(req.requestId());
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/abb9d942/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/preloader/GridDhtPartitionsExchangeFuture.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/preloader/GridDhtPartitionsExchangeFuture.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/preloader/GridDhtPartitionsExchangeFuture.java
index 72c5bbc..2cd5629 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/preloader/GridDhtPartitionsExchangeFuture.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/preloader/GridDhtPartitionsExchangeFuture.java
@@ -1170,7 +1170,7 @@ public class GridDhtPartitionsExchangeFuture extends GridFutureAdapter<AffinityT
             cacheValidRes = m;
         }
 
-        cctx.cache().onExchangeDone(exchId.topologyVersion(), exchActions, err);
+        cctx.cache().onExchangeDone(exchId.topologyVersion(), exchActions, err, false);
 
         cctx.exchange().onExchangeDone(this, err);
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/abb9d942/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
new file mode 100644
index 0000000..1d616f8
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/processors/cache/IgniteClientCacheInitializationFailTest.java
@@ -0,0 +1,367 @@
+/*
+ * 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.processors.cache;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import javax.cache.Cache;
+import javax.cache.CacheException;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.IgniteCheckedException;
+import org.apache.ignite.IgniteDataStreamer;
+import org.apache.ignite.cache.CacheAtomicityMode;
+import org.apache.ignite.cache.query.FieldsQueryCursor;
+import org.apache.ignite.cache.query.QueryCursor;
+import org.apache.ignite.cache.query.SqlFieldsQuery;
+import org.apache.ignite.cache.query.SqlQuery;
+import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.configuration.IgniteConfiguration;
+import org.apache.ignite.configuration.NearCacheConfiguration;
+import org.apache.ignite.internal.GridKernalContext;
+import org.apache.ignite.internal.processors.affinity.AffinityTopologyVersion;
+import org.apache.ignite.internal.processors.cache.version.GridCacheVersion;
+import org.apache.ignite.internal.processors.query.GridQueryCancel;
+import org.apache.ignite.internal.processors.query.GridQueryIndexing;
+import org.apache.ignite.internal.processors.query.GridQueryProcessor;
+import org.apache.ignite.internal.processors.query.GridQueryTypeDescriptor;
+import org.apache.ignite.internal.processors.query.GridRunningQueryInfo;
+import org.apache.ignite.internal.processors.query.QueryIndexDescriptorImpl;
+import org.apache.ignite.internal.processors.query.schema.SchemaIndexCacheVisitor;
+import org.apache.ignite.internal.util.GridSpinBusyLock;
+import org.apache.ignite.internal.util.lang.GridCloseableIterator;
+import org.apache.ignite.lang.IgniteBiTuple;
+import org.apache.ignite.lang.IgniteFuture;
+import org.apache.ignite.spi.indexing.IndexingQueryFilter;
+import org.apache.ignite.testframework.GridTestUtils;
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Test checks whether cache initialization error on client side
+ * doesn't causes hangs and doesn't impact other caches.
+ */
+public class IgniteClientCacheInitializationFailTest extends GridCommonAbstractTest {
+    /** Failed cache name. */
+    private static final String CACHE_NAME = "cache";
+
+    /** Atomic cache name. */
+    private static final String ATOMIC_CACHE_NAME = "atomic-cache";
+
+    /** Tx cache name. */
+    private static final String TX_CACHE_NAME = "tx-cache";
+
+    /** Near atomic cache name. */
+    private static final String NEAR_ATOMIC_CACHE_NAME = "near-atomic-cache";
+
+    /** Near tx cache name. */
+    private static final String NEAR_TX_CACHE_NAME = "near-tx-cache";
+
+    /** Failed caches. */
+    private static final Set<String> FAILED_CACHES;
+
+    static {
+        Set<String> set = new HashSet<>();
+
+        set.add(ATOMIC_CACHE_NAME);
+        set.add(TX_CACHE_NAME);
+        set.add(NEAR_ATOMIC_CACHE_NAME);
+        set.add(NEAR_TX_CACHE_NAME);
+
+        FAILED_CACHES = Collections.unmodifiableSet(set);
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void beforeTestsStarted() throws Exception {
+        startGrid("server");
+        startGrid("client");
+    }
+
+    /** {@inheritDoc} */
+    @Override protected void afterTestsStopped() throws Exception {
+        stopAllGrids();
+    }
+
+    /** {@inheritDoc} */
+    @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception
{
+        IgniteConfiguration cfg = super.getConfiguration(gridName);
+
+        if (gridName.contains("server")) {
+            CacheConfiguration<Integer, String> ccfg1 = new CacheConfiguration<>();
+
+            ccfg1.setIndexedTypes(Integer.class, String.class);
+            ccfg1.setName(ATOMIC_CACHE_NAME);
+            ccfg1.setAtomicityMode(CacheAtomicityMode.ATOMIC);
+
+            CacheConfiguration<Integer, String> ccfg2 = new CacheConfiguration<>();
+
+            ccfg2.setIndexedTypes(Integer.class, String.class);
+            ccfg2.setName(TX_CACHE_NAME);
+            ccfg2.setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL);
+
+            cfg.setCacheConfiguration(ccfg1, ccfg2);
+        }
+        else {
+            GridQueryProcessor.idxCls = FailedIndexing.class;
+
+            cfg.setClientMode(true);
+        }
+
+        return cfg;
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testAtomicCacheInitialization() throws Exception {
+        checkCacheInitialization(ATOMIC_CACHE_NAME);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testTransactionalCacheInitialization() throws Exception {
+        checkCacheInitialization(TX_CACHE_NAME);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testAtomicNearCacheInitialization() throws Exception {
+        checkCacheInitialization(NEAR_ATOMIC_CACHE_NAME);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    public void testTransactionalNearCacheInitialization() throws Exception {
+        checkCacheInitialization(NEAR_TX_CACHE_NAME);
+    }
+
+    /**
+     * @throws Exception If failed.
+     */
+    private void checkCacheInitialization(final String cacheName) throws Exception {
+        Ignite client = grid("client");
+
+        checkFailedCache(client, cacheName);
+
+        checkFineCache(client, CACHE_NAME + 1);
+
+        assertNull(client.cache(cacheName));
+        assertNull(client.getOrCreateCache(cacheName));
+
+        checkFineCache(client, CACHE_NAME + 2);
+    }
+
+    /**
+     * @param client Client.
+     * @param cacheName Cache name.
+     */
+    private void checkFineCache(Ignite client, String cacheName) {
+        IgniteCache<Integer, String> cache = client.getOrCreateCache(cacheName);
+
+        cache.put(1, "1");
+
+        assertEquals("1", cache.get(1));
+    }
+
+    /**
+     * @param client Client.
+     */
+    @SuppressWarnings("ThrowableNotThrown")
+    private void checkFailedCache(final Ignite client, final String cacheName) {
+        GridTestUtils.assertThrows(log, new Callable<Object>() {
+            @Override public Object call() throws Exception {
+                IgniteCache<Integer, String> cache;
+
+                // Start cache with near enabled.
+                if (NEAR_ATOMIC_CACHE_NAME.equals(cacheName) || NEAR_TX_CACHE_NAME.equals(cacheName))
{
+                    CacheConfiguration<Integer, String> ccfg = new CacheConfiguration<Integer,
String>(cacheName)
+                        .setNearConfiguration(new NearCacheConfiguration<Integer, String>());
+
+                    if (NEAR_TX_CACHE_NAME.equals(cacheName))
+                        ccfg.setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL);
+
+                    cache = client.getOrCreateCache(ccfg);
+                }
+                else
+                    cache = client.cache(cacheName);
+
+
+                cache.put(1, "1");
+
+                assertEquals("1", cache.get(1));
+
+                return null;
+            }
+        }, CacheException.class, null);
+    }
+
+    /**
+     * To fail on cache start.
+     */
+    private static class FailedIndexing implements GridQueryIndexing {
+        /** {@inheritDoc} */
+        @Override public void start(GridKernalContext ctx, GridSpinBusyLock busyLock) throws
IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void stop() throws IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public <K, V> QueryCursor<Cache.Entry<K, V>> queryDistributedSql(String
schemaName, SqlQuery qry,
+            boolean keepBinary, int mainCacheId) throws IgniteCheckedException {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public FieldsQueryCursor<List<?>> queryDistributedSqlFields(String
schemaName, SqlFieldsQuery qry,
+            boolean keepBinary, GridQueryCancel cancel, @Nullable Integer mainCacheId) throws
IgniteCheckedException {
+            return null;
+        }
+
+
+        /** {@inheritDoc} */
+        @Override public long streamUpdateQuery(String spaceName, String qry, @Nullable Object[]
params,
+            IgniteDataStreamer<?, ?> streamer) throws IgniteCheckedException {
+            return 0;
+        }
+
+        /** {@inheritDoc} */
+        @Override public <K, V> QueryCursor<Cache.Entry<K, V>> queryLocalSql(String
schemaName, SqlQuery qry,
+            IndexingQueryFilter filter, boolean keepBinary) throws IgniteCheckedException
{
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public FieldsQueryCursor<List<?>> queryLocalSqlFields(String
schemaName, SqlFieldsQuery qry,
+            boolean keepBinary, IndexingQueryFilter filter, GridQueryCancel cancel) throws
IgniteCheckedException {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public <K, V> GridCloseableIterator<IgniteBiTuple<K, V>>
queryLocalText(String spaceName, String qry,
+            String typeName, IndexingQueryFilter filter) throws IgniteCheckedException {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void dynamicIndexCreate(String spaceName, String tblName, QueryIndexDescriptorImpl
idxDesc,
+            boolean ifNotExists, SchemaIndexCacheVisitor cacheVisitor) throws IgniteCheckedException
{
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void dynamicIndexDrop(String spaceName, String idxName,
+            boolean ifExists) throws IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void registerCache(String cacheName, String schemaName,
+            GridCacheContext<?, ?> cctx) throws IgniteCheckedException {
+            if (FAILED_CACHES.contains(cctx.name()) && cctx.kernalContext().clientNode())
+                throw new IgniteCheckedException("Test query exception " + cctx.name() +
" " + new Random().nextInt());
+        }
+
+        /** {@inheritDoc} */
+        @Override public void unregisterCache(String spaceName) throws IgniteCheckedException
{
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean registerType(GridCacheContext cctx,
+            GridQueryTypeDescriptor desc) throws IgniteCheckedException {
+            return false;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void store(String cacheName, GridQueryTypeDescriptor type, KeyCacheObject
key, int partId,
+            CacheObject val, GridCacheVersion ver, long expirationTime, long link) throws
IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void remove(String spaceName, GridQueryTypeDescriptor type, KeyCacheObject
key, int partId,
+            CacheObject val, GridCacheVersion ver) throws IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void rebuildIndexesFromHash(GridCacheContext cctx, String schemaName,
+            String typeName) throws IgniteCheckedException {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void markForRebuildFromHash(String cacheName, String typeName) {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public IndexingQueryFilter backupFilter(AffinityTopologyVersion topVer,
int[] parts) {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void onDisconnected(IgniteFuture<?> reconnectFut) {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public PreparedStatement prepareNativeStatement(String space, String sql)
throws SQLException {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public Collection<GridRunningQueryInfo> runningQueries(long duration)
{
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public void cancelQueries(Collection<Long> queries) {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public void cancelAllQueries() {
+            // No-op
+        }
+
+        /** {@inheritDoc} */
+        @Override public String schema(String cacheName) {
+            return null;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean isInsertStatement(PreparedStatement nativeStmt) {
+            return false;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/abb9d942/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite4.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite4.java
b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite4.java
index 6370a10..23f8445 100644
--- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite4.java
+++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteCacheTestSuite4.java
@@ -71,6 +71,7 @@ import org.apache.ignite.internal.processors.cache.IgniteCacheTxNearPeekModesTes
 import org.apache.ignite.internal.processors.cache.IgniteCacheTxPeekModesTest;
 import org.apache.ignite.internal.processors.cache.IgniteCacheTxPreloadNoWriteTest;
 import org.apache.ignite.internal.processors.cache.IgniteCacheTxReplicatedPeekModesTest;
+import org.apache.ignite.internal.processors.cache.IgniteClientCacheInitializationFailTest;
 import org.apache.ignite.internal.processors.cache.IgniteDynamicCacheFilterTest;
 import org.apache.ignite.internal.processors.cache.IgniteDynamicCacheStartNoExchangeTimeoutTest;
 import org.apache.ignite.internal.processors.cache.IgniteDynamicCacheStartSelfTest;
@@ -227,6 +228,7 @@ public class IgniteCacheTestSuite4 extends TestSuite {
         suite.addTestSuite(CacheStartOnJoinTest.class);
         suite.addTestSuite(IgniteCacheStartTest.class);
         suite.addTestSuite(CacheDiscoveryDataConcurrentJoinTest.class);
+        suite.addTestSuite(IgniteClientCacheInitializationFailTest.class);
 
         suite.addTestSuite(GridCacheTxLoadFromStoreOnLockSelfTest.class);
 


Mime
View raw message