/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration iCfg = super.getConfiguration(gridName);
((TcpDiscoverySpi) iCfg.getDiscoverySpi()).setIpFinder(ipFinder);
((TcpDiscoverySpi) iCfg.getDiscoverySpi()).setForceServerMode(true);
if (getTestGridName(10).equals(gridName)) iCfg.setClientMode(true);
CacheConfiguration<Integer, Integer> cachePCfg = new CacheConfiguration<>();
cachePCfg.setName(CACHE_NAME_DHT_PARTITIONED);
cachePCfg.setCacheMode(CacheMode.PARTITIONED);
cachePCfg.setRebalanceMode(CacheRebalanceMode.SYNC);
cachePCfg.setBackups(1);
cachePCfg.setRebalanceBatchSize(1);
cachePCfg.setRebalanceBatchesPrefetchCount(1);
cachePCfg.setRebalanceOrder(2);
CacheConfiguration<Integer, Integer> cachePCfg2 = new CacheConfiguration<>();
cachePCfg2.setName(CACHE_NAME_DHT_PARTITIONED_2);
cachePCfg2.setCacheMode(CacheMode.PARTITIONED);
cachePCfg2.setRebalanceMode(CacheRebalanceMode.SYNC);
cachePCfg2.setBackups(1);
cachePCfg2.setRebalanceOrder(2);
// cachePCfg2.setRebalanceDelay(5000);//Known issue, possible deadlock in case of low priority
// cache rebalancing delayed.
CacheConfiguration<Integer, Integer> cacheRCfg = new CacheConfiguration<>();
cacheRCfg.setName(CACHE_NAME_DHT_REPLICATED);
cacheRCfg.setCacheMode(CacheMode.REPLICATED);
cacheRCfg.setRebalanceMode(CacheRebalanceMode.SYNC);
cacheRCfg.setRebalanceBatchSize(1);
cacheRCfg.setRebalanceBatchesPrefetchCount(Integer.MAX_VALUE);
((TcpCommunicationSpi) iCfg.getCommunicationSpi())
.setSharedMemoryPort(-1); // Shmem fail fix for Integer.MAX_VALUE.
CacheConfiguration<Integer, Integer> cacheRCfg2 = new CacheConfiguration<>();
cacheRCfg2.setName(CACHE_NAME_DHT_REPLICATED_2);
cacheRCfg2.setCacheMode(CacheMode.REPLICATED);
cacheRCfg2.setRebalanceMode(CacheRebalanceMode.SYNC);
cacheRCfg2.setRebalanceOrder(4);
iCfg.setCacheConfiguration(cachePCfg, cachePCfg2, cacheRCfg, cacheRCfg2);
iCfg.setRebalanceThreadPoolSize(2);
return iCfg;
}
/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration cfg = super.getConfiguration(gridName);
assertNotNull(clientNodes);
((TcpDiscoverySpi) cfg.getDiscoverySpi()).setIpFinder(ipFinder);
boolean client = false;
for (Integer clientIdx : clientNodes) {
if (getTestGridName(clientIdx).equals(gridName)) {
client = true;
break;
}
}
cfg.setClientMode(client);
CacheConfiguration ccfg = new CacheConfiguration();
ccfg.setBackups(0);
ccfg.setRebalanceMode(SYNC);
cfg.setCacheConfiguration(ccfg);
return cfg;
}
/** @throws Exception If failed. */
public void testClientNodeNotInAffinity() throws Exception {
checkCache(CACHE1, 2);
checkCache(CACHE2, 2);
checkCache(CACHE3, 2);
checkCache(CACHE4, 3);
checkCache(CACHE5, 2);
Ignite client = ignite(NODE_CNT - 1);
CacheConfiguration ccfg = new CacheConfiguration();
ccfg.setBackups(0);
ccfg.setNodeFilter(new TestNodesFilter());
IgniteCache<Integer, Integer> cache = client.createCache(ccfg);
try {
checkCache(null, 1);
} finally {
cache.destroy();
}
cache = client.createCache(ccfg, new NearCacheConfiguration());
try {
checkCache(null, 1);
} finally {
cache.destroy();
}
}
/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration cfg = super.getConfiguration(gridName);
TcpDiscoverySpi disco = new TcpDiscoverySpi();
disco.setIpFinder(IP_FINDER);
cfg.getTransactionConfiguration().setTxSerializableEnabled(true);
cfg.setDiscoverySpi(disco);
BasicWarmupClosure warmupClosure = new BasicWarmupClosure();
warmupClosure.setGridCount(2);
warmupClosure.setIterationCount(10);
warmupClosure.setKeyRange(10);
cfg.setWarmupClosure(warmupClosure);
CacheConfiguration<Integer, Integer> cacheCfg = new CacheConfiguration<>();
cacheCfg.setCacheMode(CacheMode.PARTITIONED);
cacheCfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
cacheCfg.setBackups(1);
cacheCfg.setName("test");
cfg.setCacheConfiguration(cacheCfg);
return cfg;
}
/**
* @param gridName Grid name.
* @return Cache configuration.
* @throws Exception In case of error.
*/
@SuppressWarnings("unchecked")
protected CacheConfiguration cacheConfiguration(String gridName) throws Exception {
CacheConfiguration cfg = defaultCacheConfiguration();
CacheStore<?, ?> store = cacheStore();
if (store != null) {
cfg.setCacheStoreFactory(new TestStoreFactory());
cfg.setReadThrough(true);
cfg.setWriteThrough(true);
cfg.setLoadPreviousValue(true);
}
cfg.setSwapEnabled(swapEnabled());
cfg.setCacheMode(cacheMode());
cfg.setAtomicityMode(atomicityMode());
cfg.setWriteSynchronizationMode(writeSynchronization());
cfg.setNearConfiguration(nearConfiguration());
Class<?>[] idxTypes = indexedTypes();
if (!F.isEmpty(idxTypes)) cfg.setIndexedTypes(idxTypes);
if (cacheMode() == PARTITIONED) cfg.setBackups(1);
return cfg;
}
/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration cfg = super.getConfiguration(gridName);
((TcpDiscoverySpi) cfg.getDiscoverySpi()).setIpFinder(ipFinder);
CacheConfiguration ccfg1 = new CacheConfiguration();
ccfg1.setBackups(1);
ccfg1.setName(CACHE1);
ccfg1.setAffinity(new RendezvousAffinityFunction());
ccfg1.setNodeFilter(new TestNodesFilter());
CacheConfiguration ccfg2 = new CacheConfiguration();
ccfg2.setBackups(1);
ccfg2.setName(CACHE2);
ccfg2.setAffinity(new RendezvousAffinityFunction());
CacheConfiguration ccfg3 = new CacheConfiguration();
ccfg3.setBackups(1);
ccfg3.setName(CACHE3);
ccfg3.setAffinity(new FairAffinityFunction());
ccfg3.setNodeFilter(new TestNodesFilter());
CacheConfiguration ccfg4 = new CacheConfiguration();
ccfg4.setCacheMode(REPLICATED);
ccfg4.setName(CACHE4);
ccfg4.setNodeFilter(new TestNodesFilter());
CacheConfiguration ccfg5 = new CacheConfiguration();
ccfg5.setBackups(1);
ccfg5.setName(CACHE5);
if (gridName.equals(getTestGridName(NODE_CNT - 1))) {
cfg.setClientMode(true);
cfg.setCacheConfiguration(ccfg5);
} else cfg.setCacheConfiguration(ccfg1, ccfg2, ccfg3, ccfg4);
return cfg;
}
/** Configure cacheEmployee. */
private static <K, V> CacheConfiguration<K, V> cacheEmployee() {
CacheConfiguration<K, V> ccfg = cacheConfiguration(EMPLOYEE_CACHE_NAME);
ccfg.setAtomicityMode(CacheAtomicityMode.TRANSACTIONAL);
ccfg.setBackups(1);
// Configure cacheEmployee types.
Collection<QueryEntity> qryEntities = new ArrayList<>();
// EMPLOYEE.
QueryEntity type = new QueryEntity();
qryEntities.add(type);
type.setKeyType(Integer.class.getName());
type.setValueType(Employee.class.getName());
// Query fields for EMPLOYEE.
LinkedHashMap<String, String> qryFlds = new LinkedHashMap<>();
qryFlds.put("id", "java.lang.Integer");
qryFlds.put("departmentId", "java.lang.Integer");
qryFlds.put("managerId", "java.lang.Integer");
qryFlds.put("firstName", "java.lang.String");
qryFlds.put("lastName", "java.lang.String");
qryFlds.put("email", "java.lang.String");
qryFlds.put("phoneNumber", "java.lang.String");
qryFlds.put("hireDate", "java.sql.Date");
qryFlds.put("job", "java.lang.String");
qryFlds.put("salary", "java.lang.Double");
type.setFields(qryFlds);
// Indexes for EMPLOYEE.
Collection<QueryIndex> indexes = new ArrayList<>();
QueryIndex idx = new QueryIndex();
idx.setName("EMP_NAMES");
idx.setIndexType(QueryIndexType.SORTED);
LinkedHashMap<String, Boolean> indFlds = new LinkedHashMap<>();
indFlds.put("firstName", Boolean.FALSE);
indFlds.put("lastName", Boolean.FALSE);
idx.setFields(indFlds);
indexes.add(idx);
indexes.add(new QueryIndex("salary", QueryIndexType.SORTED, false, "EMP_SALARY"));
type.setIndexes(indexes);
ccfg.setQueryEntities(qryEntities);
return ccfg;
}
/**
* @return Cache configuration.
* @throws Exception In case of error.
*/
protected CacheConfiguration cacheConfiguration() throws Exception {
CacheConfiguration cfg = defaultCacheConfiguration();
cfg.setCacheMode(PARTITIONED);
cfg.setBackups(1);
cfg.setWriteSynchronizationMode(FULL_SYNC);
cfg.setRebalanceMode(SYNC);
return cfg;
}
/**
* Gets cache configuration.
*
* @return Cache configuration.
*/
private CacheConfiguration cacheConfiguration() {
CacheConfiguration cacheCfg = defaultCacheConfiguration();
cacheCfg.setCacheMode(PARTITIONED);
cacheCfg.setBackups(1);
cacheCfg.setWriteSynchronizationMode(FULL_SYNC);
if (noNodesFilter) cacheCfg.setNodeFilter(F.alwaysFalse());
return cacheCfg;
}
/**
* Start grid with IGFS.
*
* @param gridName Grid name.
* @param igfsName IGFS name
* @param mode IGFS mode.
* @param secondaryFs Secondary file system (optional).
* @param restCfg Rest configuration string (optional).
* @return Started grid instance.
* @throws Exception If failed.
*/
protected Ignite startGridWithIgfs(
String gridName,
String igfsName,
IgfsMode mode,
@Nullable IgfsSecondaryFileSystem secondaryFs,
@Nullable IgfsIpcEndpointConfiguration restCfg)
throws Exception {
FileSystemConfiguration igfsCfg = new FileSystemConfiguration();
igfsCfg.setDataCacheName("dataCache");
igfsCfg.setMetaCacheName("metaCache");
igfsCfg.setName(igfsName);
igfsCfg.setBlockSize(IGFS_BLOCK_SIZE);
igfsCfg.setDefaultMode(mode);
igfsCfg.setIpcEndpointConfiguration(restCfg);
igfsCfg.setSecondaryFileSystem(secondaryFs);
igfsCfg.setPrefetchBlocks(PREFETCH_BLOCKS);
igfsCfg.setSequentialReadsBeforePrefetch(SEQ_READS_BEFORE_PREFETCH);
CacheConfiguration dataCacheCfg = defaultCacheConfiguration();
dataCacheCfg.setName("dataCache");
dataCacheCfg.setCacheMode(PARTITIONED);
dataCacheCfg.setNearConfiguration(null);
dataCacheCfg.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC);
dataCacheCfg.setAffinityMapper(new IgfsGroupDataBlocksKeyMapper(2));
dataCacheCfg.setBackups(0);
dataCacheCfg.setAtomicityMode(TRANSACTIONAL);
dataCacheCfg.setOffHeapMaxMemory(0);
CacheConfiguration metaCacheCfg = defaultCacheConfiguration();
metaCacheCfg.setName("metaCache");
metaCacheCfg.setCacheMode(REPLICATED);
metaCacheCfg.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC);
metaCacheCfg.setAtomicityMode(TRANSACTIONAL);
IgniteConfiguration cfg = new IgniteConfiguration();
cfg.setGridName(gridName);
TcpDiscoverySpi discoSpi = new TcpDiscoverySpi();
discoSpi.setIpFinder(new TcpDiscoveryVmIpFinder(true));
cfg.setDiscoverySpi(discoSpi);
cfg.setCacheConfiguration(dataCacheCfg, metaCacheCfg);
cfg.setFileSystemConfiguration(igfsCfg);
cfg.setLocalHost("127.0.0.1");
cfg.setConnectorConfiguration(null);
return G.start(cfg);
}
/** @return Cache configuration. */
protected CacheConfiguration cacheConfiguration() {
CacheConfiguration cfg = defaultCacheConfiguration();
cfg.setCacheMode(PARTITIONED);
cfg.setBackups(1);
cfg.setNearConfiguration(nearConfiguration());
cfg.setWriteSynchronizationMode(FULL_SYNC);
cfg.setAtomicityMode(atomicityMode);
return cfg;
}
/**
* @param name Cache name.
* @param cacheMode Cache mode.
* @param parts Number of partitions.
* @return Cache configuration.
*/
private CacheConfiguration cacheConfiguration(String name, CacheMode cacheMode, int parts) {
CacheConfiguration ccfg = new CacheConfiguration();
ccfg.setName(name);
ccfg.setCacheMode(cacheMode);
ccfg.setAtomicityMode(TRANSACTIONAL);
ccfg.setWriteSynchronizationMode(FULL_SYNC);
if (cacheMode == PARTITIONED) ccfg.setBackups(1);
ccfg.setAffinity(new RendezvousAffinityFunction(false, parts));
return ccfg;
}
/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration c = super.getConfiguration(gridName);
TcpDiscoverySpi disco = new TcpDiscoverySpi();
disco.setIpFinder(ipFinder);
c.setDiscoverySpi(disco);
CacheConfiguration<?, ?> cc = defaultCacheConfiguration();
cc.setCacheMode(PARTITIONED);
cc.setBackups(1);
cc.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC);
cc.setAtomicityMode(TRANSACTIONAL);
cc.setIndexedTypes(Integer.class, Integer.class);
c.setCacheConfiguration(cc);
return c;
}
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration cfg = super.getConfiguration(gridName);
((TcpCommunicationSpi) cfg.getCommunicationSpi()).setSharedMemoryPort(-1);
OptimizedMarshaller marsh = new OptimizedMarshaller();
marsh.setRequireSerializable(false);
cfg.setMarshaller(marsh);
CacheConfiguration ccfg = defaultCacheConfiguration();
ccfg.setCacheMode(CacheMode.PARTITIONED);
ccfg.setBackups(1);
ccfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
ccfg.setWriteSynchronizationMode(PRIMARY_SYNC);
ccfg.setNearConfiguration(null);
cfg.setCacheConfiguration(ccfg);
return cfg;
}
/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration cfg = super.getConfiguration(gridName);
CacheConfiguration<?, ?> cache = defaultCacheConfiguration();
cache.setCacheMode(PARTITIONED);
cache.setBackups(1);
cache.setWriteSynchronizationMode(FULL_SYNC);
cache.setIndexedTypes(Integer.class, TestObject.class);
cfg.setCacheConfiguration(cache);
TcpDiscoverySpi disco = new TcpDiscoverySpi();
disco.setIpFinder(IP_FINDER);
cfg.setDiscoverySpi(disco);
cfg.setConnectorConfiguration(new ConnectorConfiguration());
return cfg;
}
/** {@inheritDoc} */
@Override
protected IgniteConfiguration getConfiguration(String gridName) throws Exception {
IgniteConfiguration cfg = super.getConfiguration(gridName);
TcpDiscoverySpi spi = new TcpDiscoverySpi();
spi.setIpFinder(IP_FINDER);
cfg.setDiscoverySpi(spi);
cfg.setIncludeProperties();
cfg.setIncludeEventTypes(EVT_TASK_FAILED, EVT_TASK_FINISHED, EVT_JOB_MAPPED);
cfg.setConnectorConfiguration(null);
cfg.setPeerClassLoadingEnabled(true);
if (useCache) {
CacheConfiguration cc = defaultCacheConfiguration();
cc.setCacheMode(PARTITIONED);
cc.setNearConfiguration(null);
cc.setWriteSynchronizationMode(FULL_SYNC);
cc.setStartSize(ENTRY_CNT / GRID_CNT);
cc.setSwapEnabled(false);
cc.setBackups(1);
cfg.setCacheSanityCheckEnabled(false);
cfg.setCacheConfiguration(cc);
} else cfg.setCacheConfiguration();
return cfg;
}