Java CacheMode.REPLICATED属性代码示例

/**
 * Creates new cache configuration.
 *
 * @param name Cache name.
 * @param mode Cache mode.
 * @param clsK Key class.
 * @param clsV Value class.
 * @return Cache configuration.
 */
private static CacheConfiguration createCache(String name, CacheMode mode, Class<?> clsK, Class<?> clsV) {
    CacheConfiguration<?,?> cc = defaultCacheConfiguration();

    cc.setName(name);
    cc.setCacheMode(mode);
    cc.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC);
    cc.setRebalanceMode(SYNC);
    cc.setAtomicityMode(TRANSACTIONAL);
    cc.setIndexedTypes(clsK, clsV);

    if ((mode != CacheMode.PARTITIONED) && (mode != CacheMode.REPLICATED))
        throw new IllegalStateException("mode: " + mode);

    return cc;
}
 

/** @throws Exception If failed. */
public void testOneAsyncOpReplicated() throws Exception {
    mode = CacheMode.REPLICATED;

    startGrids(2);

    try {
        checkReferenceCleanup(oneAsyncOpCallable());
    }
    finally {
        stopAllGrids();
    }
}
 

/** @throws Exception If failed. */
public void testAsyncOpsAsyncCommitReplicated() throws Exception {
    mode = CacheMode.REPLICATED;

    startGrids(2);

    try {
        checkReferenceCleanup(asyncOpsAsyncCommitCallable());
    }
    finally {
        stopAllGrids();
    }
}
 

/**
 * @throws Exception If failed.
 */
public void testMisses() throws Exception {
    IgniteCache<Integer, Integer> cache = grid(0).cache(DEFAULT_CACHE_NAME);

    int keyCnt = keyCount();

    int expReads = 0;

    // Get a few keys missed keys.
    for (int i = 0; i < keyCnt; i++) {
        assertNull("Value is not null for key: " + i, cache.get(i));

        if (cache.getConfiguration(CacheConfiguration.class).getCacheMode() == CacheMode.REPLICATED ||
            affinity(cache).isPrimary(grid(0).localNode(), i))
            expReads++;
        else
            expReads += 2;
    }

    // Check metrics for the whole cache.
    long puts = 0;
    long reads = 0;
    long hits = 0;
    long misses = 0;

    for (int i = 0; i < gridCount(); i++) {
        CacheMetrics m = grid(i).cache(DEFAULT_CACHE_NAME).localMetrics();

        puts += m.getCachePuts();
        reads += m.getCacheGets();
        hits += m.getCacheHits();
        misses += m.getCacheMisses();
    }

    assertEquals(0, puts);
    assertEquals(expReads, reads);
    assertEquals(0, hits);
    assertEquals(expReads, misses);
}
 

/** @throws Exception If failed. */
public void testSyncOpAsyncCommitReplicated() throws Exception {
    mode = CacheMode.REPLICATED;

    startGrids(2);

    try {
        checkReferenceCleanup(syncOpAsyncCommitCallable());
    }
    finally {
        stopAllGrids();
    }
}
 

/**
 * @throws Exception If failed.
 */
public void testCachePreload8() throws Exception {
    sameGrp = false;
    cacheMode = CacheMode.REPLICATED;
    atomicityMode = CacheAtomicityMode.TRANSACTIONAL;

    cachePreloadTest();
}
 

/**
 * Constructor.
 */
public H2DynamicIndexingComplexServerAtomicReplicatedTest() {
    super(CacheMode.REPLICATED, CacheAtomicityMode.ATOMIC, 1, SRV_IDX);
}
 

/**
 * Constructor.
 */
public DynamicColumnsConcurrentTransactionalReplicatedSelfTest() {
    super(CacheMode.REPLICATED, CacheAtomicityMode.TRANSACTIONAL);
}
 

/**
 * Constructor.
 */
public DynamicIndexReplicatedTransactionalConcurrentSelfTest() {
    super(CacheMode.REPLICATED, CacheAtomicityMode.TRANSACTIONAL);
}
 

/** {@inheritDoc} */
@Override protected CacheMode getCacheMode() {
    return CacheMode.REPLICATED;
}
 

/**
 * Constructor.
 */
public H2DynamicIndexingComplexClientTransactionalReplicatedTest() {
    super(CacheMode.REPLICATED, CacheAtomicityMode.TRANSACTIONAL, 1, CLIENT_IDX);
}
 

/** {@inheritDoc} */
@Override protected CacheMode cacheMode() {
    return CacheMode.REPLICATED;
}
 

/**
 * @return {@code True} if cache is replicated cache.
 */
public boolean isReplicated() {
    return cacheCfg.getCacheMode() == CacheMode.REPLICATED;
}
 

/** {@inheritDoc} */
@Override protected VisorCachePartitions run(VisorCachePartitionsTaskArg arg) throws IgniteException {
    String cacheName = arg.getCacheName();

    if (debug)
        log(ignite.log(), "Collecting partitions for cache: " + escapeName(cacheName));

    VisorCachePartitions parts = new VisorCachePartitions();

    GridCacheAdapter ca = ignite.context().cache().internalCache(cacheName);

    // Cache was not started.
    if (ca == null || !ca.context().started())
        return parts;

    CacheConfiguration cfg = ca.configuration();

    CacheMode mode = cfg.getCacheMode();

    boolean partitioned = (mode == CacheMode.PARTITIONED || mode == CacheMode.REPLICATED)
        && ca.context().affinityNode();

    if (partitioned) {
        GridDhtCacheAdapter dca = null;

        if (ca instanceof GridNearCacheAdapter)
            dca = ((GridNearCacheAdapter)ca).dht();
        else if (ca instanceof GridDhtCacheAdapter)
            dca = (GridDhtCacheAdapter)ca;

        if (dca != null) {
            GridDhtPartitionTopology top = dca.topology();

            List<GridDhtLocalPartition> locParts = top.localPartitions();

            for (GridDhtLocalPartition part : locParts) {
                int p = part.id();

                long sz = part.dataStore().cacheSize(ca.context().cacheId());

                // Pass NONE as topology version in order not to wait for topology version.
                if (part.primary(AffinityTopologyVersion.NONE))
                    parts.addPrimary(p, sz);
                else if (part.state() == GridDhtPartitionState.OWNING && part.backup(AffinityTopologyVersion.NONE))
                    parts.addBackup(p, sz);
            }
        }
    }

    return parts;
}
 

/**
 * @throws Exception If failed.
 */
public void testCachePreload3() throws Exception {
    cacheMode = CacheMode.REPLICATED;

    cachePreloadTest();
}