@Override public PersistenceConfiguration get() { PersistenceConfiguration persistence = super.get(); StoreConfiguration store = persistence.stores().get(0); try { @SuppressWarnings("unchecked") Class<StoreConfigurationBuilder<?, ?>> storeClass = (Class<StoreConfigurationBuilder<?, ?>>) this.module.get().getClassLoader().loadClass(this.className).asSubclass(StoreConfigurationBuilder.class); return new ConfigurationBuilder().persistence().passivation(persistence.passivation()).addStore(storeClass) .async().read(store.async()) .fetchPersistentState(store.fetchPersistentState()) .preload(store.preload()) .purgeOnStartup(store.purgeOnStartup()) .shared(store.shared()) .withProperties(store.properties()) .persistence().create(); } catch (ClassNotFoundException | ClassCastException e) { throw InfinispanLogger.ROOT_LOGGER.invalidCacheStore(e, this.className); } }
private static <T> T getStoreConfiguration(Configuration c, Class<T> configurationClass) { for (StoreConfiguration pc: c.persistence().stores()) { if (configurationClass.isInstance(pc)) { return (T) pc; } } throw new NoSuchElementException("There is no store of type " + configurationClass); }
private StoreConfiguration buildCacheManagerWithCacheStore(final String config) throws IOException { InputStream is = new ByteArrayInputStream(config.getBytes()); cacheManager = TestCacheManagerFactory.fromStream(is); assert cacheManager.getDefaultCacheConfiguration().persistence().stores().size() == 1; return cacheManager.getDefaultCacheConfiguration().persistence().stores().get(0); } }
public void testLoaders() { List<StoreConfiguration> stores = cacheManager.getCache("customLoaderCache").getCacheConfiguration().persistence().stores(); assertEquals(stores.size(), 1); StoreConfiguration storeConfiguration = stores.get(0); assertTrue(storeConfiguration instanceof ClusterLoaderConfiguration); ClusterLoaderConfiguration csc = (ClusterLoaderConfiguration) storeConfiguration; assertEquals(csc.remoteCallTimeout(), 1222); } }
public void testConfiguration() { Cache<Object,Object> customLoaderCache = cacheManager.getCache("customLoaderCache"); List<StoreConfiguration> loaders = customLoaderCache.getCacheConfiguration().persistence().stores(); assertEquals(loaders.size(), 1); } }
@Test public void testClearStores() { Configuration c = new ConfigurationBuilder() .persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .persistence() .clearStores() .build(); assertEquals(c.persistence().stores().size(), 0); }
@Override public void call() { PersistenceConfiguration cfg = cm.getDefaultCacheConfiguration().persistence(); StoreConfiguration config = cfg.stores().get(0); assertTrue(config instanceof DummyInMemoryStoreConfiguration); DummyInMemoryStoreConfiguration dummyInMemoryStoreConfiguration = (DummyInMemoryStoreConfiguration)config; assertEquals("myStore", dummyInMemoryStoreConfiguration.storeName()); } });
@Override public void check(ConfigurationBuilderHolder holder) { Configuration local = getConfiguration(holder, "local"); PersistenceConfiguration persistenceConfiguration = local.persistence(); assertEquals(5, persistenceConfiguration.connectionAttempts()); assertEquals(100, persistenceConfiguration.connectionInterval()); assertEquals(2000, persistenceConfiguration.availabilityInterval()); assertFalse(persistenceConfiguration.stores().isEmpty()); AsyncStoreConfiguration asyncConfig = persistenceConfiguration.stores().iterator().next().async(); assertTrue(asyncConfig.failSilently()); } },
@Override public void call() { PersistenceConfiguration cfg = cm.getDefaultCacheConfiguration().persistence(); StoreConfiguration config = cfg.stores().get(0); assertTrue(config instanceof AbstractStoreConfiguration); AbstractStoreConfiguration abstractStoreConfiguration = (AbstractStoreConfiguration)config; assertTrue(abstractStoreConfiguration.fetchPersistentState()); assertTrue(abstractStoreConfiguration.preload()); } });
@Override public void call() { Cache<String, String> first = cm.getCache("first"); Cache<String, String> second = cm.getCache("second"); StoreConfiguration firstCacheLoaderConfig = first.getCacheConfiguration().persistence().stores().get(0); assertNotNull(firstCacheLoaderConfig); assertTrue(firstCacheLoaderConfig instanceof JdbcStringBasedStoreConfiguration); StoreConfiguration secondCacheLoaderConfig = second.getCacheConfiguration().persistence().stores().get(0); assertNotNull(secondCacheLoaderConfig); assertTrue(secondCacheLoaderConfig instanceof JdbcStringBasedStoreConfiguration); JdbcStringBasedStore loader = (JdbcStringBasedStore) TestingUtil.getFirstLoader(first); assertTrue(loader.getConnectionFactory() instanceof ManagedConnectionFactory); } });
public void testImplicitPooledConnectionFactory() { ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .connectionPool().connectionUrl(JDBC_URL); Configuration configuration = b.build(); JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0); assert store.connectionFactory() instanceof PooledConnectionFactoryConfiguration; }
public void testImplicitManagedConnectionFactory() { ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .dataSource().jndiUrl("java:jboss/datasources/ExampleDS"); Configuration configuration = b.build(); JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0); assert store.connectionFactory() instanceof ManagedConnectionFactoryConfiguration; }
public void testTableProperties() { Properties props = new Properties(); props.put("createOnStart", "false"); props.put("dropOnExit", "true"); ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .connectionPool().connectionUrl(JDBC_URL) .withProperties(props); Configuration stringConfiguration = b.build(); JdbcStringBasedStoreConfiguration stringStoreConfiguration = (JdbcStringBasedStoreConfiguration) stringConfiguration.persistence().stores().get(0); assertFalse(stringStoreConfiguration.table().createOnStart()); assertTrue(stringStoreConfiguration.table().dropOnExit()); } }
public void testParsingElement() throws Exception { String config = TestingUtil.wrapXMLWithoutSchema( "<cache-container default-cache=\"default\">" + " <local-cache name=\"default\">\n" + " <persistence passivation=\"false\"> \n" + " <file-store path=\"other-location\" max-entries=\"100\" shared=\"false\" preload=\"true\" fragmentation-factor=\"0.75\"/> \n" + " </persistence>\n" + " </local-cache>\n" + "</cache-container>"); InputStream is = new ByteArrayInputStream(config.getBytes()); ConfigurationBuilderHolder holder = new ParserRegistry().parse(config); List<StoreConfiguration> storeConfigs = holder.getDefaultConfigurationBuilder().build().persistence().stores(); assertEquals(1, storeConfigs.size()); SingleFileStoreConfiguration fileStoreConfig = (SingleFileStoreConfiguration) storeConfigs.get(0); assertEquals("other-location", fileStoreConfig.location()); assertEquals(100, fileStoreConfig.maxEntries()); assertEquals(0.75f, fileStoreConfig.fragmentationFactor(), 0f); Util.recursiveFileRemove("other-location"); }
public static InitializationContext createContext(String nodeName, Configuration configuration, StreamingMarshaller marshaller, TimeService timeService) { Cache mockCache = mockCache(nodeName, configuration, timeService); return new InitializationContextImpl(configuration.persistence().stores().get(0), mockCache, SingleSegmentKeyPartitioner.getInstance(), marshaller, timeService, new ByteBufferFactoryImpl(), new MarshalledEntryFactoryImpl(marshaller), new WithinThreadExecutor()); }
public void testParsingEmptyElement() throws Exception { String config = TestingUtil.wrapXMLWithSchema( "<cache-container default-cache=\"default\">" + " <local-cache name=\"default\">\n" + " <persistence passivation=\"false\"> \n" + " <file-store shared=\"false\" preload=\"true\"/> \n" + " </persistence>\n" + " </local-cache>\n" + "</cache-container>"); ConfigurationBuilderHolder holder = new ParserRegistry().parse(config); List<StoreConfiguration> storeConfigs = holder.getDefaultConfigurationBuilder().build().persistence().stores(); assertEquals(1, storeConfigs.size()); SingleFileStoreConfiguration fileStoreConfig = (SingleFileStoreConfiguration) storeConfigs.get(0); assertEquals("Infinispan-SingleFileStore", fileStoreConfig.location()); assertEquals(-1, fileStoreConfig.maxEntries()); }
public void testXmlConfig() throws IOException { InputStream configSTream = ConfigurationTest.class.getResourceAsStream("/config/leveldb-config-auto.xml"); ConfigurationBuilderHolder configHolder = new ParserRegistry().parse(configSTream); // check persistence attributes Configuration cacheConfig = configHolder.getNamedConfigurationBuilders().get("testCache").build(); assertFalse(cacheConfig.persistence().passivation()); assertEquals(cacheConfig.persistence().stores().size(), 1); // check generic store attributes StoreConfiguration cacheLoaderConfig = cacheConfig.persistence().stores().get(0); assertFalse(cacheLoaderConfig.shared()); assertTrue(cacheLoaderConfig.preload()); assertTrue(cacheLoaderConfig instanceof LevelDBStoreConfiguration); // check LevelDB store attributes LevelDBStoreConfiguration leveldbConfig = (LevelDBStoreConfiguration) cacheLoaderConfig; assertEquals("/tmp/leveldb/52/data", leveldbConfig.location()); assertEquals("/tmp/leveldb/52/expired", leveldbConfig.expiredLocation()); assertEquals(LevelDBStoreConfiguration.ImplementationType.AUTO, leveldbConfig.implementationType()); } }
public void testOverrideWithStore() { final ConfigurationBuilder builder1 = new ConfigurationBuilder(); builder1.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class); cm = TestCacheManagerFactory.createCacheManager(builder1); ConfigurationBuilder builder2 = new ConfigurationBuilder(); builder2.read(cm.getDefaultCacheConfiguration()); builder2.memory().size(1000); Configuration configuration = cm.defineConfiguration("named", builder2.build()); assertEquals(1, configuration.persistence().stores().size()); }
public void testLazyLoadTopology() { HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder(); builder.topologyStateTransfer(false).topologyReplTimeout(43000); withClusteredServer(builder, (cfg, distSyncTimeout) -> { assertEquals(cfg.clustering().remoteTimeout(), 43000); assertTrue(cfg.clustering().stateTransfer().fetchInMemoryState()); ClusterLoaderConfiguration clcfg = ((ClusterLoaderConfiguration) cfg.persistence().stores().get(0)); assertNotNull(clcfg); assertEquals(clcfg.remoteCallTimeout(), 43000); }); }
public void testUserDefinedTimeouts() { HotRodServerConfigurationBuilder builder = new HotRodServerConfigurationBuilder(); builder.topologyLockTimeout(26000).topologyReplTimeout(31000); withClusteredServer(builder, (cfg, distSyncTimeout) -> { assertEquals(cfg.locking().lockAcquisitionTimeout(), 26000); assertEquals(cfg.clustering().remoteTimeout(), 31000); assertTrue(cfg.clustering().stateTransfer().fetchInMemoryState()); assertEquals(cfg.clustering().stateTransfer().timeout(), 31000 + distSyncTimeout); assertTrue(cfg.persistence().stores().isEmpty()); }); }