Example #1
0
  protected Cache<String, String> startCache() throws IOException {
    CacheBuilder cb = new CacheBuilder(cfgFile);
    EmbeddedCacheManager cacheManager = cb.getCacheManager();
    Configuration dcc = cacheManager.getDefaultCacheConfiguration();

    cacheManager.defineConfiguration(
        "wordcount",
        new ConfigurationBuilder()
            .read(dcc)
            .clustering()
            .l1()
            .disable()
            .clustering()
            .cacheMode(CacheMode.DIST_SYNC)
            .hash()
            .numOwners(1)
            .build());
    Cache<String, String> cache = cacheManager.getCache();

    Transport transport = cache.getAdvancedCache().getRpcManager().getTransport();
    if (isMaster)
      System.out.printf(
          "Node %s joined as master. View is %s.%n",
          transport.getAddress(), transport.getMembers());
    else
      System.out.printf(
          "Node %s joined as slave. View is %s.%n", transport.getAddress(), transport.getMembers());

    return cache;
  }
 private Map<CacheCategory, CacheService> createCaches(CacheInfo cacheInfo) {
   Map<CacheCategory, CacheService> ciCaches = new HashMap<CacheCategory, CacheService>();
   for (Map.Entry<CacheCategory, CacheConfiguration> entry :
       cacheInfo.getConfiguration().entrySet()) {
     if (entry.getValue() instanceof InfinispanConfiguration) {
       CacheService cacheService;
       CacheCategory category = entry.getKey();
       InfinispanConfiguration config = (InfinispanConfiguration) entry.getValue();
       if (config.isCacheEnabled()) {
         String configurationName = config.getConfigurationName();
         if (null == configurationName) {
           Configuration dcc = manager.getDefaultCacheConfiguration();
           Configuration infinispan =
               config.getInfinispanConfiguration(new ConfigurationBuilder().read(dcc));
           configurationName = "$" + category.getName() + "$" + cacheInfo.getId();
           manager.defineConfiguration(configurationName, infinispan);
         }
         recorder.record("infinispan", "configuration name " + configurationName);
         cacheService =
             new InfinispanCacheService(manager.<String, Object>getCache(configurationName));
       } else {
         cacheService = noCacheFactory.create(null, category);
       }
       ciCaches.put(category, cacheService);
     }
   }
   return ciCaches;
 }
 private CacheLoaderConfiguration buildCacheManagerWithCacheStore(final String config)
     throws IOException {
   InputStream is = new ByteArrayInputStream(config.getBytes());
   cacheManager = TestCacheManagerFactory.fromStream(is);
   assert cacheManager.getDefaultCacheConfiguration().loaders().cacheLoaders().size() == 1;
   return cacheManager.getDefaultCacheConfiguration().loaders().cacheLoaders().get(0);
 }
  public void testNoSchemaWithStuff() throws IOException {
    String config =
        INFINISPAN_START_TAG_NO_SCHEMA
            + "    <default>\n"
            + "        <locking concurrencyLevel=\"10000\" isolationLevel=\"REPEATABLE_READ\" />\n"
            + "    </default>\n"
            + INFINISPAN_END_TAG;

    InputStream is = new ByteArrayInputStream(config.getBytes());
    EmbeddedCacheManager cm = TestCacheManagerFactory.fromStream(is);

    Configuration cfg = cm.getDefaultCacheConfiguration();
    assert cfg.locking().concurrencyLevel() == 10000;
    assert cfg.locking().isolationLevel() == IsolationLevel.REPEATABLE_READ;
  }
  public void testNoNamedCaches() throws Exception {
    String config =
        INFINISPAN_START_TAG
            + "   <global>\n"
            + "      <transport clusterName=\"demoCluster\"/>\n"
            + "   </global>\n"
            + "\n"
            + "   <default>\n"
            + "      <clustering mode=\"replication\">\n"
            + "      </clustering>\n"
            + "   </default>\n"
            + TestingUtil.INFINISPAN_END_TAG;

    InputStream is = new ByteArrayInputStream(config.getBytes());
    EmbeddedCacheManager cm = TestCacheManagerFactory.fromStream(is);
    GlobalConfiguration globalCfg = cm.getCacheManagerConfiguration();

    assert globalCfg.transport().transport() instanceof JGroupsTransport;
    assert globalCfg.transport().clusterName().equals("demoCluster");

    Configuration cfg = cm.getDefaultCacheConfiguration();
    assert cfg.clustering().cacheMode() == CacheMode.REPL_SYNC;
  }
 private void assertCacheMode(String config) throws IOException {
   InputStream is = new ByteArrayInputStream(config.getBytes());
   EmbeddedCacheManager cm = TestCacheManagerFactory.fromStream(is);
   Assert.assertEquals(
       cm.getDefaultCacheConfiguration().clustering().cacheMode(), CacheMode.REPL_SYNC);
 }
  private void assertNamedCacheFile(EmbeddedCacheManager cm) {
    final GlobalConfiguration gc = cm.getCacheManagerConfiguration();

    assert gc.asyncListenerExecutor().factory() instanceof DefaultExecutorFactory;
    assert gc.asyncListenerExecutor().properties().getProperty("maxThreads").equals("5");
    assert gc.asyncListenerExecutor()
        .properties()
        .getProperty("threadNamePrefix")
        .equals("AsyncListenerThread");

    assert gc.asyncTransportExecutor().factory() instanceof DefaultExecutorFactory;
    assert gc.asyncTransportExecutor().properties().getProperty("maxThreads").equals("25");
    assert gc.asyncTransportExecutor()
        .properties()
        .getProperty("threadNamePrefix")
        .equals("AsyncSerializationThread");

    assert gc.evictionScheduledExecutor().factory() instanceof DefaultScheduledExecutorFactory;
    assert gc.evictionScheduledExecutor()
        .properties()
        .getProperty("threadNamePrefix")
        .equals("EvictionThread");

    assert gc.replicationQueueScheduledExecutor().factory()
        instanceof DefaultScheduledExecutorFactory;
    assert gc.replicationQueueScheduledExecutor()
        .properties()
        .getProperty("threadNamePrefix")
        .equals("ReplicationQueueThread");

    assert gc.transport().transport() instanceof JGroupsTransport;
    assert gc.transport().clusterName().equals("infinispan-cluster");
    assert gc.transport().nodeName().equals("Jalapeno");
    assert gc.transport().distributedSyncTimeout() == 50000;

    assert gc.shutdown().hookBehavior().equals(ShutdownHookBehavior.REGISTER);

    assert gc.serialization().marshaller() instanceof VersionAwareMarshaller;
    assert gc.serialization().version() == Version.getVersionShort("1.0");
    final Map<Integer, AdvancedExternalizer<?>> externalizers =
        gc.serialization().advancedExternalizers();
    assert externalizers.size() == 3;
    assert externalizers.get(1234) instanceof AdvancedExternalizerTest.IdViaConfigObj.Externalizer;
    assert externalizers.get(5678)
        instanceof AdvancedExternalizerTest.IdViaAnnotationObj.Externalizer;
    assert externalizers.get(3456) instanceof AdvancedExternalizerTest.IdViaBothObj.Externalizer;

    Configuration defaultCfg = cm.getDefaultCacheConfiguration();

    assert defaultCfg.locking().lockAcquisitionTimeout() == 1000;
    assert defaultCfg.locking().concurrencyLevel() == 100;
    assert defaultCfg.locking().isolationLevel() == IsolationLevel.READ_COMMITTED;

    Configuration c = cm.getCacheConfiguration("transactional");
    assert !c.clustering().cacheMode().isClustered();
    assert c.transaction().transactionManagerLookup() instanceof GenericTransactionManagerLookup;
    assert c.transaction().useEagerLocking();
    assert c.transaction().eagerLockingSingleNode();
    assert !c.transaction().syncRollbackPhase();

    c = cm.getCacheConfiguration("transactional2");
    assert c.transaction().transactionManagerLookup() instanceof Lookup;
    assert c.transaction().cacheStopTimeout() == 10000;
    assert c.transaction().lockingMode().equals(LockingMode.PESSIMISTIC);
    assert !c.transaction().autoCommit();

    c = cm.getCacheConfiguration("syncRepl");

    assert c.clustering().cacheMode() == CacheMode.REPL_SYNC;
    assert !c.clustering().stateRetrieval().fetchInMemoryState();
    assert c.clustering().sync().replTimeout() == 15000;

    c = cm.getCacheConfiguration("asyncRepl");

    assert c.clustering().cacheMode() == CacheMode.REPL_ASYNC;
    assert !c.clustering().async().useReplQueue();
    assert !c.clustering().async().asyncMarshalling();
    assert !c.clustering().stateRetrieval().fetchInMemoryState();

    c = cm.getCacheConfiguration("asyncReplQueue");

    assert c.clustering().cacheMode() == CacheMode.REPL_ASYNC;
    assert c.clustering().async().useReplQueue();
    assert !c.clustering().async().asyncMarshalling();
    assert !c.clustering().stateRetrieval().fetchInMemoryState();

    c = cm.getCacheConfiguration("txSyncRepl");

    assert c.transaction().transactionManagerLookup() instanceof GenericTransactionManagerLookup;
    assert c.clustering().cacheMode() == CacheMode.REPL_SYNC;
    assert !c.clustering().stateRetrieval().fetchInMemoryState();
    assert c.clustering().sync().replTimeout() == 15000;

    c = cm.getCacheConfiguration("overriding");

    assert c.clustering().cacheMode() == CacheMode.LOCAL;
    assert c.locking().lockAcquisitionTimeout() == 20000;
    assert c.locking().concurrencyLevel() == 1000;
    assert c.locking().isolationLevel() == IsolationLevel.REPEATABLE_READ;
    assert !c.storeAsBinary().enabled();

    c = cm.getCacheConfiguration("storeAsBinary");
    assert c.storeAsBinary().enabled();

    c = cm.getCacheConfiguration("withLoader");
    assert c.loaders().preload();
    assert !c.loaders().passivation();
    assert !c.loaders().shared();
    assert c.loaders().cacheLoaders().size() == 1;

    FileCacheStoreConfiguration loaderCfg =
        (FileCacheStoreConfiguration) c.loaders().cacheLoaders().get(0);

    assert loaderCfg.fetchPersistentState();
    assert loaderCfg.ignoreModifications();
    assert loaderCfg.purgeOnStartup();
    assert loaderCfg.location().equals("/tmp/FileCacheStore-Location");
    assert loaderCfg.fsyncMode() == FileCacheStoreConfigurationBuilder.FsyncMode.PERIODIC;
    assert loaderCfg.fsyncInterval() == 2000;
    assert loaderCfg.singletonStore().pushStateTimeout() == 20000;
    assert loaderCfg.singletonStore().pushStateWhenCoordinator();
    assert loaderCfg.async().threadPoolSize() == 5;
    assert loaderCfg.async().flushLockTimeout() == 15000;
    assert loaderCfg.async().enabled();
    assert loaderCfg.async().modificationQueueSize() == 700;

    c = cm.getCacheConfiguration("withLoaderDefaults");
    loaderCfg = (FileCacheStoreConfiguration) c.loaders().cacheLoaders().get(0);
    assert loaderCfg.location().equals("/tmp/Another-FileCacheStore-Location");
    assert loaderCfg.fsyncMode() == FileCacheStoreConfigurationBuilder.FsyncMode.DEFAULT;

    c = cm.getCacheConfiguration("withouthJmxEnabled");
    assert !c.jmxStatistics().enabled();
    assert gc.globalJmxStatistics().enabled();
    assert gc.globalJmxStatistics().allowDuplicateDomains();
    assert gc.globalJmxStatistics().domain().equals("funky_domain");
    assert gc.globalJmxStatistics().mbeanServerLookup() instanceof PerThreadMBeanServerLookup;

    c = cm.getCacheConfiguration("dist");
    assert c.clustering().cacheMode() == CacheMode.DIST_SYNC;
    assert c.clustering().l1().lifespan() == 600000;
    assert c.clustering().hash().rehashRpcTimeout() == 120000;
    assert c.clustering().stateTransfer().timeout() == 120000;
    assert c.clustering().hash().consistentHash() instanceof TopologyAwareConsistentHash;
    assert c.clustering().hash().numOwners() == 3;
    assert c.clustering().l1().enabled();

    c = cm.getCacheConfiguration("groups");
    assert c.clustering().hash().groups().enabled();
    assert c.clustering().hash().groups().groupers().size() == 1;
    assert c.clustering().hash().groups().groupers().get(0).getKeyType().equals(String.class);

    c = cm.getCacheConfiguration("chunkSize");
    assert c.clustering().stateTransfer().fetchInMemoryState();
    assert c.clustering().stateTransfer().timeout() == 120000;
    assert c.clustering().stateTransfer().chunkSize() == 1000;

    c = cm.getCacheConfiguration("cacheWithCustomInterceptors");
    assert !c.customInterceptors().interceptors().isEmpty();
    assert c.customInterceptors().interceptors().size() == 5;

    c = cm.getCacheConfiguration("evictionCache");
    assert c.eviction().maxEntries() == 5000;
    assert c.eviction().strategy().equals(EvictionStrategy.FIFO);
    assert c.expiration().lifespan() == 60000;
    assert c.expiration().maxIdle() == 1000;
    assert c.eviction().threadPolicy() == EvictionThreadPolicy.PIGGYBACK;
    assert c.expiration().wakeUpInterval() == 500;

    c = cm.getCacheConfiguration("withDeadlockDetection");
    assert c.deadlockDetection().enabled();
    assert c.deadlockDetection().spinDuration() == 1221;
    assert c.clustering().cacheMode() == CacheMode.DIST_SYNC;

    c = cm.getCacheConfiguration("storeKeyValueBinary");
    assert c.storeAsBinary().enabled();
    assert c.storeAsBinary().storeKeysAsBinary();
    assert !c.storeAsBinary().storeValuesAsBinary();
  }