Java Code Examples for org.apache.ignite.IgniteCache

@PostConstruct
    public void start() {
        log.info("Application is started for Node:" + ignite.cluster().nodes());
        CollectionConfiguration cfg = new CollectionConfiguration();
        IgniteQueue<Object> queue = ignite.queue("main", 0, cfg);
        IgniteCache<UUID, Operation> operationCache = ignite.cache("operationCache");
        log.info("Application is started for KeySizes:" + operationCache.size(CachePeekMode.PRIMARY));
        ArrayList<Event> events = new ArrayList<>();
        events.add(new Event(UUID.randomUUID(), IEventType.EXECUTE, EventState.CREATED, new String[]{"firstpar1","firstpar2"}));
        operationCache.put(UUID.randomUUID(), new Operation("TEST_CREATE", events, TransactionState.RUNNING));
        log.info("Application is started for KeySizes:" + operationCache.size(CachePeekMode.PRIMARY));
/*        Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                kafkaTemplate.send("operation-events",UUID.randomUUID(),
                        new Operation("blaaggre",Arrays.asList(new Event()),TransactionState.RUNNING));

            }
        }, 3,3, TimeUnit.SECONDS);*/

//        log.info(transactionCache.get(UUID.fromString("4447a089-e5f7-477c-9807-79210fafa296")).toString());
    }
 

/**
 * method assumes ChromosomeCriteria is set.
 * 
 * @param k
 *            - gene index in Chromosome.
 * @return
 */
private long selectGeneByChromsomeCriteria(int k) {
    List<Gene> genes = new ArrayList();

    StringBuffer sbSqlClause = new StringBuffer("_val like '");
    sbSqlClause.append("%");
    sbSqlClause.append(config.getChromosomeCritiera().getCriteria().get(k));
    sbSqlClause.append("%'");

    IgniteCache<Long, Gene> cache = ignite.cache(GAGridConstants.GENE_CACHE);

    SqlQuery sql = new SqlQuery(Gene.class, sbSqlClause.toString());

    try (QueryCursor<Entry<Long, Gene>> cursor = cache.query(sql)) {
        for (Entry<Long, Gene> e : cursor)
            genes.add(e.getValue());
    }

    int idx = selectRandomIndex(genes.size());

    Gene gene = genes.get(idx);
    return gene.id();
}
 

@Scheduled(initialDelayString = "${initialDelay}", fixedDelayString = "${fixedDelay}")
public void cleanExpiredRecords(){
    // query the matching records first
    logger.debug("Starting the clean up job to clear the expired records");
    long towMinutesRange = System.currentTimeMillis()-900000;
    final IgniteCache<String, List<AlertEntry>> alertsCache = getAlertsCache();
    final String sql = "select * from AlertEntry where timestamp <= ?";
    SqlQuery<String,AlertEntry> query = new SqlQuery(AlertEntry.class,sql);
    query.setArgs(towMinutesRange);
    final List<Cache.Entry<String, AlertEntry>> toDeleteAlerts = alertsCache.query(query).getAll();
    // then call remove all as this will remove the records from the cache and the persistent file system as sql delete will just delete it from the cache layer not the file system
    // or the persistent store
    if(toDeleteAlerts!=null && !toDeleteAlerts.isEmpty()){
        logger.debug("Finished cleaning out {} records",toDeleteAlerts.size());
        alertsCache.removeAll(new HashSet(toDeleteAlerts
                .stream()
                .map(Cache.Entry::getKey)
                .collect(Collectors.toList())));

    }

}
 

@Override
public void onAfterPut(Cache.Entry<Long, JournalItem> entry) {
    IgniteCache<String, Long> sequenceNumberTrack = ignite.getOrCreateCache("sequenceNumberTrack");
    sequenceNumberTrack.invoke(entry.getValue().getPersistenceId(), (mutableEntry, objects) -> {
        if (mutableEntry.exists() && mutableEntry.getValue() != null) {
            // if it is less than the new sequence value , use it
            if (mutableEntry.getValue() < entry.getKey()) {
                mutableEntry.setValue(entry.getKey());
            }
        } else {
            // if does not exist , just use it
            mutableEntry.setValue(entry.getKey());
        }
        // by api design nothing needed here
        return null;
    });
}
 

/**
 * @param config      the akka configuration object
 * @param actorSystem the akk actor system
 * @return the created snapshot ignite cache
 */
@Override
public IgniteCache<Long, SnapshotItem> apply(Config config, ActorSystem actorSystem) {
    final IgniteExtension extension = IgniteExtensionProvider.EXTENSION.get(actorSystem);
    final String cachePrefix = config.getString(CACHE_PREFIX_PROPERTY);
    final int cacheBackups = config.getInt(CACHE_BACKUPS);
    final CacheConfiguration<Long, SnapshotItem> eventStore = new CacheConfiguration();
    eventStore.setCopyOnRead(false);
    if (cacheBackups > 0) {
        eventStore.setBackups(cacheBackups);
    } else {
        eventStore.setBackups(1);
    }
    eventStore.setAtomicityMode(CacheAtomicityMode.ATOMIC);
    eventStore.setName(cachePrefix + "_SNAPSHOT");
    eventStore.setCacheMode(CacheMode.PARTITIONED);
    eventStore.setReadFromBackup(true);
    eventStore.setIndexedTypes(Long.class, SnapshotItem.class);
    eventStore.setIndexedTypes(String.class, SnapshotItem.class);
    return extension.getIgnite().getOrCreateCache(eventStore);
}
 

/**
 * Distributed matrix get.
 *
 * @param a Row or column index.
 * @param b Row or column index.
 * @return Matrix value at (a, b) index.
 */
private double matrixGet(int a, int b) {
    // Remote get from the primary node (where given row or column is stored locally).
    return ignite().compute(getClusterGroupForGivenKey(CACHE_NAME, getBlockId(a, b))).call(() -> {
        IgniteCache<MatrixBlockKey, MatrixBlockEntry> cache = Ignition.localIgnite().getOrCreateCache(CACHE_NAME);

        MatrixBlockKey key = getCacheKey(getBlockId(a, b));

        // Local get.
        MatrixBlockEntry block = cache.localPeek(key, CachePeekMode.PRIMARY);

        if (block == null)
            block = cache.get(key);

        return block == null ? 0.0 : block.get(a % block.rowSize(), b % block.columnSize());
    });
}
 

/**
 * method assumes ChromosomeCriteria is set.
 * 
 * @param k - gene index in Chromosome.
 *            
 * @return long
 */
private long selectGeneByChromsomeCriteria(int k) {
    List<Gene> genes = new ArrayList();

    StringBuffer sbSqlClause = new StringBuffer("_val like '");
    sbSqlClause.append("%");
    sbSqlClause.append(config.getChromosomeCritiera().getCriteria().get(k));
    sbSqlClause.append("%'");

    IgniteCache<Long, Gene> cache = ignite.cache(GAGridConstants.GENE_CACHE);

    SqlQuery sql = new SqlQuery(Gene.class, sbSqlClause.toString());

    try (QueryCursor<Entry<Long, Gene>> cursor = cache.query(sql)) {
        for (Entry<Long, Gene> e : cursor)
            genes.add(e.getValue());
    }

    int idx = selectRandomIndex(genes.size());

    Gene gene = genes.get(idx);
    return gene.id();
}
 

private Chromosome getChromosome(Long key) {
    IgniteCache<Long, Chromosome> cache = ignite.cache(GAGridConstants.POPULATION_CACHE);
    StringBuffer sbSqlClause = new StringBuffer();
    sbSqlClause.append("_key IN (");
    sbSqlClause.append(key);
    sbSqlClause.append(")");

    Chromosome chromosome = null;

    SqlQuery sql = new SqlQuery(Chromosome.class, sbSqlClause.toString());

    try (QueryCursor<Entry<Long, Chromosome>> cursor = cache.query(sql)) {
        for (Entry<Long, Chromosome> e : cursor)
            chromosome = (e.getValue())

            ;
    }

    return chromosome;
}
 

@Test(dataProvider = DataProviders.KV_META_LIST_PROVIDER)
public void loadAllPersons(List<KeyValueAndMetadata> kvMetas, String dbMode) throws SQLException {
    JDBCUtil.setDBMode(dataSource, dbMode);
    JDBCUtil.applyInConnection(dataSource, connection -> {
        for (KeyValueAndMetadata kvMeta : kvMetas) {
            JDBCUtil.insertIntoDB(connection, kvMeta);
        }
    });
    Map<Integer, Object> expectedResults = kvMetas
            .stream()
            .collect(Collectors.toMap(KeyValueAndMetadata::getKey, KeyValueAndMetadata::getUnwrappedValue));
    String cacheName = kvMetas.get(0).getCacheName();
    IgniteCache<Integer, Object> cache = ignite().cache(cacheName);
    Map<Integer, Object> results = cache.getAll(expectedResults.keySet());

    assertEquals(results, expectedResults);
}
 

@Test
public void gapDetectionProcessFillsGaps() throws Exception {
    int firstKey = 1;
    PrimitivesHolder firstValue = new PrimitivesHolder();
    IgniteCache<Integer, PrimitivesHolder> cache = ignite().cache(PrimitivesHolder.CACHE);
    cache.put(firstKey, firstValue);

    long missedTx = createGap();
    int lastKey = 2;
    PrimitivesHolder lastValue = new PrimitivesHolder(true, (byte) 1, (short) 1, 1, 1, 1, 1);
    cache.put(lastKey, lastValue);

    awaitReconciliationOnTransaction(missedTx);
    awaitTransactions();
    Map<Integer, PrimitivesHolder> expected = new LinkedHashMap<>();
    expected.put(firstKey, firstValue);
    expected.put(lastKey, lastValue);
    assertObjectsInDB(expected, false);
}
 

public static <V> Reference<V> getReference(Ignite ignite, final String name, boolean create) {
    final IgniteCache<Object, Object> cache = create ? ignite.getOrCreateCache(NAME) : ignite.cache(NAME);
    return new Reference<V>() {
        @Override
        public V get() {
            return cache == null ? null : (V) cache.get(name);
        }

        @Override
        public void set(V value) {
            if (value == null) {
                cache.remove(name);
            } else {
                cache.put(name, value);
            }
        }
    };
}
 

/** */
private static double queryAccountBalance(Account account,
    IgniteCache<AccountTransactionKey, AccountTransaction> accountTxCache) {
    double result = 0;
    int accountId = account.getAccountKey().getAccountId();

    for (AccountTransactionKey txKey : account.getTransactionKeys().values()) {
        AccountTransaction transaction = accountTxCache.get(txKey);

        if (accountId == transaction.getFromAccountId()) {
            result -= transaction.getMoneyAmount();
        }
        else {
            result += transaction.getMoneyAmount();
        }
    }
    return result;
}
 

/** {@inheritDoc} */
@Override public void process(final Map<?, ?> entries) {
    long processingStartTime = System.currentTimeMillis();
    ignite.compute().run(new IgniteRunnable() {
        @IgniteInstanceResource
        private Ignite localIgnite;

        @Override public void run() {
            IgniteCache cache = localIgnite.cache(cacheName);

            if (transactional) {
                try (Transaction tx = localIgnite.transactions().txStart()) {
                    process(cache, entries);
                }
            }
            else {
                process(cache, entries);
            }
        }
    });
    Statistics.recordOperation(System.currentTimeMillis() - processingStartTime);
}
 

/**
 * Creates cache with full configuration. Active store is used.
 *
 * @param cacheName name of cache.
 * @param atomicityMode atomicity.
 * @param cacheMode mode.
 * @param writeBehindEnabled should write behind be used for active store.
 * @param flushFreq flush frequency for write behind.
 * @param base configuration to copy settings from.
 * @param <K> type of key.
 * @param <V> type of value
 * @return cache instance.
 */
@SuppressWarnings("unchecked")
public <K, V> IgniteCache<K, V> createCache(String cacheName, CacheAtomicityMode atomicityMode, CacheMode cacheMode,
    boolean writeBehindEnabled, int flushFreq,
    CacheConfiguration<K, V> base) {
    CacheConfiguration<K, V> realConfiguration = base == null
        ? new CacheConfiguration<K, V>()
        : new CacheConfiguration<K, V>(base);
    realConfiguration.setName(cacheName);
    realConfiguration.setAtomicityMode(atomicityMode);
    realConfiguration.setCacheMode(cacheMode);
    realConfiguration.setBackups(2);
    realConfiguration.setWriteThrough(true);
    realConfiguration.setReadThrough(true);
    realConfiguration.setWriteBehindEnabled(writeBehindEnabled);
    realConfiguration.setWriteBehindFlushFrequency(flushFreq);
    realConfiguration.setCacheStoreFactory(activeStoreConfiguration.activeCacheStoreFactory());
    return ignite().createCache(realConfiguration);
}
 

/** */
@Test
public void testRead() {
    initializeKV();

    Object[] result = resource.ignite().compute().call(new IgniteCallable<Object[]>() {
        @Override public Object[] call() throws Exception {
            IgniteCache<Object, Object> cache = Ignition.localIgnite().cache(firstCache);
            return new Object[] {
                cache.get("a"),
                cache.get("b"),
                cache.get("c"),
                cache.get("d"),
                cache.get("e")
            };
        }
    });

    Assert.assertEquals("1", result[0]);
    Assert.assertEquals("3", result[1]);
    Assert.assertEquals("4", result[2]);
    Assert.assertNull(result[3]);
    Assert.assertNull(result[4]);
}
 

/**
 * @param cacheName Cache name.
 * @param fun An operation that accepts a cache entry and processes it.
 * @param ignite Ignite.
 * @param keysGen Keys generator.
 * @param <K> Cache key object type.
 * @param <V> Cache value object type.
 */
public static <K, V> void update(String cacheName, Ignite ignite, IgniteConsumer<Cache.Entry<K, V>> fun,
    IgniteSupplier<Set<K>> keysGen) {
    bcast(cacheName, ignite, () -> {
        Ignite ig = Ignition.localIgnite();
        IgniteCache<K, V> cache = ig.getOrCreateCache(cacheName);

        Affinity<K> affinity = ig.affinity(cacheName);
        ClusterNode locNode = ig.cluster().localNode();

        Collection<K> ks = affinity.mapKeysToNodes(keysGen.get()).get(locNode);

        if (ks == null)
            return;

        Map<K, V> m = new ConcurrentHashMap<>();

        for (K k : ks) {
            V v = cache.localPeek(k);
            fun.accept(new CacheEntryImpl<>(k, v));
            m.put(k, v);
        }

        cache.putAll(m);
    });
}
 

private static double queryAccountBalance(
    Account account,
    IgniteCache<AccountTransactionKey, AccountTransaction> accountTxCache
) {
    double result = 0;
    int accountId = account.getAccountKey().getAccountId();

    for (AccountTransactionKey txKey : account.getTransactionKeys().values()) {
        AccountTransaction transaction = accountTxCache.get(txKey);

        if (accountId == transaction.getFromAccountId()) {
            result -= transaction.getMoneyAmount();
        }
        else {
            result += transaction.getMoneyAmount();
        }
    }
    return result;
}
 

private <K, V> IgniteCache<K, V> getCache(String entityCacheName, boolean keepBinary) {
	IgniteCache<K, V> cache = null;
	try {
		cache = cacheManager.cache( entityCacheName );
	}
	catch (IllegalStateException ex) {
		if ( Ignition.state( gridName ) == IgniteState.STOPPED ) {
			log.stoppedIgnite();
			restart();
			cache = cacheManager.cache( entityCacheName );
		}
		else {
			throw ex;
		}

	}
	if ( cache == null ) {
		throw log.cacheNotFound( entityCacheName );
	}
	if ( keepBinary ) {
		cache = cache.withKeepBinary();
	}
	return cache;
}
 

/**
 * Constructs input for {@link ColumnDecisionTreeTrainer}.
 *
 * @param c Cache.
 * @param valuesMapper Function for mapping cache entry to stream used by {@link ColumnDecisionTreeTrainer}.
 * @param labelsMapper Function used for mapping cache value to labels array.
 * @param keyMapper Function used for mapping feature index to the cache key.
 * @param catFeaturesInfo Information about which features are categorical in form of feature index -> number of
 * categories.
 * @param featuresCnt Count of features.
 * @param samplesCnt Count of samples.
 */
// TODO: IGNITE-5724 think about boxing/unboxing
public CacheColumnDecisionTreeTrainerInput(IgniteCache<K, V> c,
    IgniteSupplier<Stream<K>> labelsKeys,
    IgniteFunction<Cache.Entry<K, V>, Stream<IgniteBiTuple<Integer, Double>>> valuesMapper,
    IgniteFunction<V, DoubleStream> labelsMapper,
    IgniteFunction<Integer, Stream<K>> keyMapper,
    Map<Integer, Integer> catFeaturesInfo,
    int featuresCnt, int samplesCnt) {

    cacheName = c.getName();
    this.labelsKeys = labelsKeys;
    this.valuesMapper = valuesMapper;
    this.labelsMapper = labelsMapper;
    this.keyMapper = keyMapper;
    this.catFeaturesInfo = catFeaturesInfo;
    this.samplesCnt = samplesCnt;
    this.featuresCnt = featuresCnt;
}
 

@Override
public Map<String, Object> extractEntityTuple(Session session, EntityKey key) {
	SessionFactoryImplementor sessionFactory = (SessionFactoryImplementor) session.getSessionFactory();
	IgniteCache<Object, BinaryObject> cache = getEntityCache( sessionFactory, key.getMetadata() );
	Object cacheKey = getProvider( sessionFactory ).createKeyObject( key );

	Map<String, Object> result = new HashMap<>();
	BinaryObject po = cache.get( cacheKey );

	TupleSnapshot snapshot = new IgniteTupleSnapshot( cacheKey, po, key.getMetadata() );
	for ( String fieldName : snapshot.getColumnNames() ) {
		result.put( fieldName, snapshot.get( fieldName ) );
	}

	return result;
}
 

/**
 * Distributed matrix set.
 *
 * @param a Row or column index.
 * @param b Row or column index.
 * @param v New value to set.
 */
private void matrixSet(int a, int b, double v) {
    IgnitePair<Long> blockId = getBlockId(a, b);
    // Remote set on the primary node (where given row or column is stored locally).
    ignite().compute(getClusterGroupForGivenKey(CACHE_NAME, blockId)).run(() -> {
        IgniteCache<MatrixBlockKey, MatrixBlockEntry> cache = Ignition.localIgnite().getOrCreateCache(CACHE_NAME);

        MatrixBlockKey key = getCacheKey(blockId.get1(), blockId.get2());

        // Local get.
        MatrixBlockEntry block = getEntryById(blockId);

        block.set(a % block.rowSize(), b % block.columnSize(), v);

        // Local put.
        cache.put(key, block);
    });
}
 

@Override
public void updateAlertEntry(String serviceId, String serviceCode, AlertEntry alertEntry) {
    final IgniteCache<String, AlertEntry> alertsCache = getAlertsCache();
    // update the alert entry via cache invoke for atomicity
    alertsCache.invoke(alertEntry.getAlertId(), (mutableEntry, objects) -> {
        if (mutableEntry.exists() && mutableEntry.getValue() != null) {
            logger.debug("updating alert entry into the cache store invoke: {},{}", serviceId, serviceCode);
            mutableEntry.setValue(alertEntry);
        } else {
            throw new ResourceNotFoundException(String.format("Alert for %s with %s not found", serviceId, serviceCode));
        }
        // by api design nothing needed here
        return null;
    });
}
 

/**
 * @param size Vector size.
 * @param cache Ignite cache.
 * @param keyMapper {@link VectorKeyMapper} to validate cache key.
 * @param valMapper {@link ValueMapper} to obtain value for given cache key.
 */
public CacheVectorStorage(int size, IgniteCache<K, V> cache, VectorKeyMapper<K> keyMapper,
    ValueMapper<V> valMapper) {
    assert size > 0;
    assert cache != null;
    assert keyMapper != null;
    assert valMapper != null;

    this.size = size;
    this.cache = cache;
    this.keyMapper = keyMapper;
    this.valMapper = valMapper;
}
 

@Before
public void setUp() throws Exception {
    when(ignite.getOrCreateCache(anyString())).thenReturn(IgniteCache);
    List<AlertEntry> entries=new ArrayList<>();
    entries.add(AlertEntry.builder().errorCode("errorCode").build());
    when(IgniteCache.get(anyString())).thenReturn(entries);
}
 

/**
 * @param args
 */
public static void main(String[] args) {
    Ignition.setClientMode(true);

    try (Ignite ignite = Ignition.start("config/ignite-config.xml")) {
        IgniteCache<BinaryObject, BinaryObject> cityCacheBinary = ignite.cache(CITY_CACHE_NAME).withKeepBinary();

        accessCityCache(ignite, cityCacheBinary);

        migrateBetweenCities(ignite, cityCacheBinary);
    }
}
 

/**
 * 
 * Retrieve genes in order
 * 
 * @param ignite
 * @param chromosome
 * @return List<Gene>
 */

public static List<Gene> getGenesInOrderForChromosome(Ignite ignite, Chromosome chromosome) {
    List<Gene> genes = new ArrayList();
    IgniteCache<Long, Gene> cache = ignite.cache(GAGridConstants.GENE_CACHE);
  
    long[] primaryKeys = chromosome.getGenes();
    
    for (int k =0; k< primaryKeys.length; k++)
    {
    
      StringBuffer sbSqlClause = new StringBuffer();
      sbSqlClause.append("_key IN ");
      sbSqlClause.append("(");
      sbSqlClause.append(primaryKeys[k]);
      sbSqlClause.append(")");
      
      SqlQuery sql = new SqlQuery(Gene.class, sbSqlClause.toString());

       try (QueryCursor<Entry<Long, Gene>> cursor = cache.query(sql)) {
        for (Entry<Long, Gene> e : cursor)
            genes.add(e.getValue());
        }
    }
   
    return genes;
}
 

@Test(dataProvider = DataProviders.KV_META_PROVIDER)
public void partiallyFoundLoadAll(KeyValueAndMetadata kvMeta, String dbMode) throws SQLException {
    JDBCUtil.setDBMode(dataSource, dbMode);
    JDBCUtil.insertIntoDB(dataSource, kvMeta);

    IgniteCache<Integer, Object> cache = ignite().cache(kvMeta.getCacheName());

    Map<Integer, Object> results = cache.getAll(DataProviders.KEYS);
    Map<Integer, Object> expected = Collections.singletonMap(kvMeta.getKey(), kvMeta.getUnwrappedValue());

    assertEquals(results, expected);
}
 

@Test(dataProvider = DataProviders.KV_META_PROVIDER)
public void loadPerson(KeyValueAndMetadata kvMeta, String dbMode) throws SQLException {
    JDBCUtil.setDBMode(dataSource, dbMode);
    JDBCUtil.insertIntoDB(dataSource, kvMeta);

    IgniteCache<Integer, Object> cache = ignite().cache(kvMeta.getCacheName());

    Object result = cache.get(kvMeta.getKey());
    Object expected = kvMeta.getUnwrappedValue();

    assertEquals(result, expected);
}
 

@Test(dataProvider = CACHE_INFO_PROVIDER)
public void sequentialTransactions(String cacheName, boolean asBinary) throws Exception {
    IgniteCache<Integer, PrimitivesHolder> cache = ignite().cache(cacheName);
    PrimitivesHolder first = DataProviders.PH_1;
    PrimitivesHolder second = DataProviders.PH_2;

    cache.put(1, first);
    cache.put(1, second);
    awaitTransactions();

    assertObjectsInDB(Collections.singletonMap(1, second), asBinary);
}
 

/**
 * Construct an input for {@link ColumnDecisionTreeTrainer}.
 *
 * @param cache Bi-indexed cache.
 * @param catFeaturesInfo Information about categorical feature in the form (feature index -> number of
 * categories).
 * @param samplesCnt Count of samples.
 * @param featuresCnt Count of features.
 */
public BiIndexedCacheColumnDecisionTreeTrainerInput(IgniteCache<BiIndex, Double> cache,
    Map<Integer, Integer> catFeaturesInfo, int samplesCnt, int featuresCnt) {
    super(cache,
        () -> IntStream.range(0, samplesCnt).mapToObj(s -> new BiIndex(s, featuresCnt)),
        e -> Stream.of(new IgniteBiTuple<>(e.getKey().row(), e.getValue())),
        DoubleStream::of,
        fIdx -> IntStream.range(0, samplesCnt).mapToObj(s -> new BiIndex(s, fIdx)),
        catFeaturesInfo,
        featuresCnt,
        samplesCnt);
}
 

/**
 * Distributed matrix get.
 *
 * @param a Row or column index.
 * @param b Row or column index.
 * @return Matrix value at (a, b) index.
 */
private double matrixGet(int a, int b) {
    // Remote get from the primary node (where given row or column is stored locally).
    return ignite().compute(getClusterGroupForGivenKey(CACHE_NAME, a)).call(() -> {
        IgniteCache<RowColMatrixKey, Map<Integer, Double>> cache = Ignition.localIgnite().getOrCreateCache(CACHE_NAME);

        // Local get.
        Map<Integer, Double> map = cache.localPeek(getCacheKey(a), CachePeekMode.PRIMARY);

        if (map == null)
            map = cache.get(getCacheKey(a));

        return (map == null || !map.containsKey(b)) ? 0.0 : map.get(b);
    });
}
 

/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public void process(IgniteCache cache, Map<?, ?> entries) {
    for (Map.Entry<?, ?> entry : entries.entrySet()) {
        cache.get(entry.getKey());
    }
}
 

/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public void process(IgniteCache cache, Map<?, ?> entries) {
    cache.getAll(entries.keySet());
}
 

/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public void process(IgniteCache cache, Map<?, ?> entries) {
    for (Map.Entry<?, ?> entry : entries.entrySet()) {
        cache.put(entry.getKey(), entry.getValue());
    }
}
 

/**
 * Creates cache with minimal configuration. Active store is not used.
 *
 * @param cacheName name of cache.
 * @param atomicityMode atomicity.
 * @param cacheMode mode.
 * @param base configuration to copy settings from.
 * @param <K> type of key.
 * @param <V> type of value
 * @return cache instance.
 */
public <K, V> IgniteCache<K, V> createSimpleCache(String cacheName, CacheAtomicityMode atomicityMode,
    CacheMode cacheMode, CacheConfiguration<K, V> base) {
    CacheConfiguration<K, V> realConfiguration = base == null
        ? new CacheConfiguration<K, V>()
        : new CacheConfiguration<K, V>(base);
    realConfiguration.setName(cacheName);
    realConfiguration.setAtomicityMode(atomicityMode);
    realConfiguration.setCacheMode(cacheMode);
    realConfiguration.setBackups(2);
    return ignite().createCache(realConfiguration);
}
 

/** */
protected Map<Object, Object> readFromCache(final String cacheName, final String... keys) {
    return resource.ignite().compute().call(new IgniteCallable<Map<Object, Object>>() {
        @Override public Map<Object, Object> call() throws Exception {
            IgniteCache<Object, Object> cache = Ignition.localIgnite().cache(cacheName);
            return cache.getAll(Sets.newHashSet(keys));
        }
    });
}
 

/**
 * Construct an instance of this class.
 *
 * @param cache Cache on which training is performed.
 * @param ignite Ignite instance.
 */
GroupTrainer(
    IgniteCache<GroupTrainerCacheKey<K>, V> cache,
    Ignite ignite) {
    this.cache = cache;
    this.ignite = ignite;
}
 

/**
 * Moving people between cities using transactions.
 *
 * @param ignite Ignite connection reference.
 * @param cityCache City cache.
 */
private static void migrateBetweenCities(Ignite ignite, IgniteCache<CityKey, City> cityCache) {
    IgniteTransactions igniteTx = ignite.transactions();

    /** Amsterdam Key. */
    CityKey amKey = new CityKey(5, "NLD");

    /** Berlin Key. */
    CityKey berKey = new CityKey(3068, "DEU");

    System.out.println();
    System.out.println(">> Moving people between Amsterdam and Berlin");

    try (Transaction tx = igniteTx.txStart(TransactionConcurrency.PESSIMISTIC,TransactionIsolation.REPEATABLE_READ)) {
        City amsterdam = cityCache.get(amKey);
        City berlin = cityCache.get(berKey);

        System.out.println(">> Before update:");
        System.out.println(amsterdam);
        System.out.println(berlin);

        /** Moving people between cities. **/
        amsterdam.setPopulation(amsterdam.getPopulation() + 100_000);
        berlin.setPopulation(berlin.getPopulation() - 100_000);

        /** Applying changes in a transactional fashion. */
        cityCache.put(amKey, amsterdam);
        cityCache.put(berKey, berlin);
    }

    City amsterdam = cityCache.get(amKey);
    City berlin = cityCache.get(berKey);

    System.out.println(">> After update:");
    System.out.println(amsterdam);
    System.out.println(berlin);
}
 

Map<Integer, Integer> readValuesFromCache(Ignite ignite) {
    IgniteCache<Integer, Integer> cache = ignite.cache(CACHE_NAME);
    Set<Integer> keys = new HashSet<>();
    for (int i = startIndex; i < endIndex; i++) {
        keys.add(i);
    }
    return cache.getAll(keys);
}
 

void writeValuesToCache(Ignite ignite, boolean withReplication, int startIdx, int endIdx, int modifier) {
    try (Transaction tx = ignite.transactions().txStart()) {
        IgniteCache<Integer, Integer> cache = ignite.cache(CACHE_NAME);
        if (!withReplication) {
            cache = cache.withSkipStore();
        }
        for (int i = startIdx; i < endIdx; i++) {
            cache.put(i, i + modifier);
        }
        tx.commit();
    }
}
 

private Ignite getIgnite(Map<String, Integer> actual) {
    IgniteCache cache = mock(IgniteCache.class);
    doAnswer(new OnPutAnswer(actual)).when(cache).put(any(String.class), any(Integer.class));
    doAnswer(new OnRemoveAnswer(actual)).when(cache).remove(any(String.class));

    IgniteTransactions transactions = mock(IgniteTransactions.class);
    doReturn(mock(Transaction.class)).when(transactions).txStart();

    Ignite ignite = mock(Ignite.class);
    doReturn(cache).when(ignite).cache(CACHE_NAME);
    doReturn(transactions).when(ignite).transactions();
    return ignite;
}
 

/**
 * Moving people between cities using transactions.
 *
 * @param ignite Ignite connection reference.
 * @param cityCache City cache.
 */
private static void migrateBetweenCities(Ignite ignite, IgniteCache<BinaryObject, BinaryObject> cityCache) {
    IgniteTransactions igniteTx = ignite.transactions();

    BinaryObjectBuilder cityKeyBuilder = ignite.binary().builder("demo.model.CityKey");

    /** Amsterdam Key. */

    cityKeyBuilder.setField("ID", 5);
    cityKeyBuilder.setField("COUNTRYCODE", "NLD");

    BinaryObject amKey = cityKeyBuilder.build();

    /** Berlin Key. */
    cityKeyBuilder.setField("ID", 3068);
    cityKeyBuilder.setField("COUNTRYCODE", "DEU");

    BinaryObject berKey = cityKeyBuilder.build();

    System.out.println();
    System.out.println(">> Moving people between Amsterdam and Berlin");

    try (Transaction tx = igniteTx.txStart(TransactionConcurrency.PESSIMISTIC, TransactionIsolation.REPEATABLE_READ)) {
        /** Moving people between cities using EntryProcessor (collocated processing). */
        cityCache.invoke(amKey, new CityEntryProcessor(true, 100_000));

        cityCache.invoke(berKey, new CityEntryProcessor(false, 100_000));
    }

    BinaryObject amsterdam = cityCache.get(amKey);
    BinaryObject berlin = cityCache.get(berKey);

    System.out.println(">> After update:");
    System.out.println(amsterdam);
    System.out.println(berlin);
}
 

/**
 * Sets vector element by index
 *
 * @param i Vector element index.
 * @param v Value to set at given index.
 */
@Override public void set(int i, double v) {
    // Remote set on the primary node (where given row or column is stored locally).
    ignite().compute(getClusterGroupForGivenKey(CACHE_NAME, getCacheKey(i))).run(() -> {
        IgniteCache<RowColMatrixKey, Double> cache = Ignition.localIgnite().getOrCreateCache(CACHE_NAME);

        RowColMatrixKey cacheKey = getCacheKey(i);

        if (v != 0.0)
            cache.put(cacheKey, v);
        else if (cache.containsKey(cacheKey)) // remove zero elements
            cache.remove(cacheKey);

    });
}
 

@Test(expected = CacheException.class)
public void testTableNameNotNull() {
  HBaseCacheStoreSessionListener cssl = new HBaseCacheStoreSessionListener(null);
  applyHBaseConfiguration(cssl);
  IgniteConfiguration cfg = prepareConfig(cssl);
  IgniteConfiguration cfg2 = new IgniteConfiguration(cfg);
  cfg.setGridName("first");
  cfg2.setGridName("second");
  try (Ignite ignite = Ignition.getOrStart(cfg); Ignite ignite2 = Ignition.getOrStart(cfg2)) {
    IgniteCache<String, String> cache = ignite.getOrCreateCache("myCache");
    cache.put("Hello", "World");
  }
}
 

@SuppressWarnings("unchecked")
@Override
public List<T> call() throws Exception {
	IgniteCache<Object, BinaryObject> cache = ignite.cache( cacheName );
	if ( cache == null ) {
		throw new IgniteException( "Cache '" + cacheName + "' not found" );
	}
	cache = cache.withKeepBinary();
	return (List<T>) cache.query( query ).getAll();
}
 

/**
 * Finds key type name for cache for entities with composite id
 * @param keyMetadata
 * @return
 */
private String findKeyType(EntityKeyMetadata keyMetadata) {
	String result = compositeIdTypes.get( keyMetadata.getTable() );
	if ( result == null ) {
		String cacheType = getEntityTypeName( keyMetadata.getTable() );
		IgniteCache<Object, BinaryObject> cache = getEntityCache( keyMetadata );
		CacheConfiguration cacheConfig = cache.getConfiguration( CacheConfiguration.class );
		if ( cacheConfig.getQueryEntities() != null ) {
			for ( QueryEntity qe : (Collection<QueryEntity>) cacheConfig.getQueryEntities() ) {
				if ( qe.getValueType() != null && cacheType.equalsIgnoreCase( qe.getValueType() ) ) {
					result = qe.getKeyType();
					break;
				}
			}
		}
		if ( result == null ) {
			if ( cacheConfig.getKeyType() != null ) {
				result = cacheConfig.getKeyType().getSimpleName();
			}
			if ( result == null ) {
				// if nothing found we use id field name
				result = StringHelper.stringBeforePoint( keyMetadata.getColumnNames()[0] );
				result = StringUtils.capitalize( result );
			}
		}
		compositeIdTypes.put( keyMetadata.getTable(), result );
	}
	return result;
}
 

@Override
public Tuple getTuple(EntityKey key, OperationContext operationContext) {
	IgniteCache<Object, BinaryObject> entityCache = provider.getEntityCache( key.getMetadata() );
	if ( entityCache == null ) {
		throw log.cacheNotFound( key.getMetadata().getTable() );
	}
	Object id = provider.createKeyObject( key );
	BinaryObject po = entityCache.get( id );
	if ( po != null ) {
		return new Tuple( new IgniteTupleSnapshot( id, po, key.getMetadata() ), SnapshotType.UPDATE );
	}
	else {
		return null;
	}
}
 

@Override
public Tuple createTuple(EntityKey key, OperationContext operationContext) {
	IgniteCache<Object, BinaryObject> entityCache = provider.getEntityCache( key.getMetadata() );
	if ( entityCache == null ) {
		throw log.cacheNotFound( key.getMetadata().getTable() );
	}
	Object id = provider.createKeyObject( key );
	return new Tuple( new IgniteTupleSnapshot( id, null, key.getMetadata() ), SnapshotType.INSERT );
}
 

@Override
public void insertOrUpdateTuple(EntityKey key, TuplePointer tuplePointer, TupleContext tupleContext) throws TupleAlreadyExistsException {
	IgniteCache<Object, BinaryObject> entityCache = provider.getEntityCache( key.getMetadata() );
	Tuple tuple = tuplePointer.getTuple();

	Object keyObject = null;
	BinaryObjectBuilder builder = null;
	IgniteTupleSnapshot tupleSnapshot = (IgniteTupleSnapshot) tuple.getSnapshot();
	keyObject = tupleSnapshot.getCacheKey();
	if ( tuple.getSnapshotType() == SnapshotType.UPDATE ) {
		builder = provider.createBinaryObjectBuilder( tupleSnapshot.getCacheValue() );
	}
	else {
		builder = provider.createBinaryObjectBuilder( provider.getEntityTypeName( key.getMetadata().getTable() ) );
	}
	for ( String columnName : tuple.getColumnNames() ) {
		Object value = tuple.get( columnName );
		if ( value != null ) {
			builder.setField( StringHelper.realColumnName( columnName ), value );
		}
		else {
			builder.removeField( StringHelper.realColumnName( columnName ) );
		}
	}
	BinaryObject valueObject = builder.build();
	entityCache.put( keyObject, valueObject );
	tuplePointer.setTuple( new Tuple( new IgniteTupleSnapshot( keyObject, valueObject, key.getMetadata() ), SnapshotType.UPDATE ) );
}
 

/**
 * @param args
 */
public static void main(String[] args) {
    Ignition.setClientMode(true);

    try (Ignite ignite = Ignition.start("config/ignite-config.xml")) {
        IgniteCache cityCache = ignite.cache(CITY_CACHE_NAME);
        IgniteCache countryCache = ignite.cache(COUNTRY_CACHE_NAME);
        IgniteCache languageCache = ignite.cache(COUNTRY_LANGUAGE_CACHE_NAME);

        getMostPopulatedCities(countryCache);
        getTopCitiesInThreeCountries(countryCache);
        getCityDetails(cityCache, 5);
    }
}
 

@Override
public long getNumberOfEntities(SessionFactory sessionFactory) {
	int entityCount = 0;
	Set<IgniteCache<?, ?>> processedCaches = Collections.newSetFromMap( new IdentityHashMap<IgniteCache<?, ?>, Boolean>() );
	for ( EntityPersister entityPersister : ( (SessionFactoryImplementor) sessionFactory ).getEntityPersisters().values() ) {
		IgniteCache<?, ?> entityCache = getEntityCache( sessionFactory, ( (OgmEntityPersister) entityPersister ).getEntityKeyMetadata() );
		if ( !processedCaches.contains( entityCache ) ) {
			entityCount += entityCache.size( CachePeekMode.ALL );
			processedCaches.add( entityCache );
		}
	}
	return entityCount;
}
 

public static <K> Map<K, BinaryObject> find(SessionFactory sessionFactory, Class<?> class1, K... ids) {
	OgmEntityPersister entityPersister = (OgmEntityPersister) ( (SessionFactoryImplementor) sessionFactory ).getEntityPersister( Poem.class.getName() );
	IgniteCache<K, BinaryObject> entityCache = getEntityCache( sessionFactory, entityPersister.getEntityKeyMetadata() );
	Map<K, BinaryObject> missingIds = new HashMap<>();
	for ( K id : ids ) {
		BinaryObject binaryObject = entityCache.get( id );
		if ( binaryObject != null ) {
			missingIds.put( id, binaryObject );
		}
	}
	return missingIds;
}
 

/**
 * Creates new matrix over existing cache.
 *
 * @param rows Amount of rows in matrix.
 * @param cols Amount of columns in matrix.
 * @param cache Ignite cache.
 * @param keyMapper {@link MatrixKeyMapper} to validate cache key.
 * @param valMapper {@link ValueMapper} to obtain value for given cache key.
 */
public CacheMatrix(
    int rows,
    int cols,
    IgniteCache<K, V> cache,
    MatrixKeyMapper<K> keyMapper,
    ValueMapper<V> valMapper) {
    assert rows > 0;
    assert cols > 0;
    assert cache != null;
    assert keyMapper != null;
    assert valMapper != null;

    setStorage(new CacheMatrixStorage<>(rows, cols, cache, keyMapper, valMapper));
}
 

/**
 * Processes data stored in a cache with key-value APIs.
 *
 * @param cityCache City cache.
 */
private static void accessCityCache(IgniteCache<CityKey, City> cityCache) {
    CityKey key = new CityKey(5, "NLD");
    City city = cityCache.get(key);

    System.out.println(">> Getting Amsterdam Record:");
    System.out.println(city);

    System.out.println(">> Updating Amsterdam record:");
    city.setPopulation(city.getPopulation() - 10_000);

    cityCache.put(key, city);

    System.out.println(cityCache.get(key));
}
 

/**
 * @param rows Amount of rows in matrix.
 * @param cols Amount of columns in matrix.
 * @param cache Ignite cache.
 * @param keyMapper {@link MatrixKeyMapper} to validate cache key.
 * @param valMapper {@link ValueMapper} to obtain value for given cache key.
 */
public CacheMatrixStorage(int rows, int cols, IgniteCache<K, V> cache, MatrixKeyMapper<K> keyMapper,
    ValueMapper<V> valMapper) {
    assert rows > 0;
    assert cols > 0;
    assert cache != null;
    assert keyMapper != null;
    assert valMapper != null;

    this.rows = rows;
    this.cols = cols;
    this.cache = cache;
    this.keyMapper = keyMapper;
    this.valMapper = valMapper;
}
 

public void setServiceTicketsCache(final IgniteCache<String, ServiceTicket> serviceTicketsCache) {
    this.serviceTicketsCache = serviceTicketsCache;
}
 

public void setTicketGrantingTicketsCache(final IgniteCache<String, TicketGrantingTicket> ticketGrantingTicketsCache) {
    this.ticketGrantingTicketsCache = ticketGrantingTicketsCache;
}
 

private static void runServer() throws Exception {
    System.setProperty("IGNITE_QUIET", "false");

    Ignite ignite = Ignition.start(IgniteConfig.getIgniteConfig(false));

    IgniteCache<Long, EntityWithMapField> cache = ignite.getOrCreateCache(IgniteConfig.CACHE_NAME);

    Map<String, String> attrs = new HashMap<>(2);

    attrs.put("1", "one");
    attrs.put("2", "two");

    cache.put(1L, new EntityWithMapField(attrs));

    System.out.println(cache.get(1L));
}
 

public void setTicketIgniteCache(final IgniteCache<String, Ticket> ticketIgniteCache) {
    this.ticketIgniteCache = ticketIgniteCache;
}
 

@Override
public void deleteAlertEntry(String alertId) {
    final IgniteCache<String, AlertEntry> alertsCache = getAlertsCache();
    alertsCache.remove(alertId);
}