Repository: ignite Updated Branches: refs/heads/master 858d11b33 -> abb9d9428
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/master Commit: abb9d9428696ddb3a250e9a491d4abea437d2a38 Parents: 858d11b Author: dkarachentsev <[email protected]> Authored: Wed May 31 16:57:29 2017 +0300 Committer: dkarachentsev <[email protected]> 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);
