public void addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) { delegate.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); }
public void addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) { delegate.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); }
/** See {@link MutableConfiguration#addCacheEntryListenerConfiguration}. */ public void addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) { delegate.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); }
/** {@inheritDoc} */ @Override public MutableConfiguration<K, V> addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryLsnrCfg) { synchronized (this) { return super.addCacheEntryListenerConfiguration(cacheEntryLsnrCfg); } }
@Test public void testTemplateAddsListeners() throws Exception { CacheManager cacheManager = cachingProvider.getCacheManager(getClass().getResource("/ehcache-107-listeners.xml") .toURI(), getClass().getClassLoader()); MutableConfiguration<String, String> configuration = new MutableConfiguration<>(); configuration.setTypes(String.class, String.class); MutableCacheEntryListenerConfiguration<String, String> listenerConfiguration = new MutableCacheEntryListenerConfiguration<>(Test107CacheEntryListener::new, null, false, true); configuration.addCacheEntryListenerConfiguration(listenerConfiguration); Cache<String, String> cache = cacheManager.createCache("foos", configuration); cache.put("Hello", "Bonjour"); assertThat(Test107CacheEntryListener.seen.size(), Matchers.is(1)); assertThat(TestCacheEventListener.seen.size(), Matchers.is(1)); }
/** * Constructs a {@link MutableConfiguration} based on another * {@link CompleteConfiguration}. * * @param configuration the {@link CompleteConfiguration} */ public MutableConfiguration(CompleteConfiguration<K, V> configuration) { this.keyType = configuration.getKeyType(); this.valueType = configuration.getValueType(); listenerConfigurations = new HashSet<CacheEntryListenerConfiguration<K, V>>(); for (CacheEntryListenerConfiguration<K, V> definition : configuration .getCacheEntryListenerConfigurations()) { addCacheEntryListenerConfiguration(definition); } this.cacheLoaderFactory = configuration.getCacheLoaderFactory(); this.cacheWriterFactory = configuration.getCacheWriterFactory(); if (configuration.getExpiryPolicyFactory() == null) { this.expiryPolicyFactory = EternalExpiryPolicy.factoryOf(); } else { this.expiryPolicyFactory = configuration.getExpiryPolicyFactory(); } this.isReadThrough = configuration.isReadThrough(); this.isWriteThrough = configuration.isWriteThrough(); this.isStatisticsEnabled = configuration.isStatisticsEnabled(); this.isStoreByValue = configuration.isStoreByValue(); this.isManagementEnabled = configuration.isManagementEnabled(); }
@Test public void jsr107ListenerFactoryInitFailureClosesExpiryLoader() throws Exception { ExpiryPolicy expiryPolicy = mock(ExpiryPolicy.class, new MockSettingsImpl<>().extraInterfaces(Closeable.class)); CacheLoader<Object, Object> loader = mock(CacheLoader.class, new MockSettingsImpl<>().extraInterfaces(Closeable.class)); MutableConfiguration<Object, Object> configuration = new MutableConfiguration<>(); configuration.setExpiryPolicyFactory(factoryOf(expiryPolicy)) .setReadThrough(true) .setCacheLoaderFactory(factoryOf(loader)) .addCacheEntryListenerConfiguration(new ThrowingCacheEntryListenerConfiguration()); try { merger.mergeConfigurations("cache", configuration); fail("Loader factory should have thrown"); } catch (CacheException mce) { verify((Closeable) expiryPolicy).close(); verify((Closeable) loader).close(); } }
/** {@inheritDoc} */ @Override public MutableConfiguration<K, V> addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryLsnrCfg) { synchronized (this) { return super.addCacheEntryListenerConfiguration(cacheEntryLsnrCfg); } }
/** See {@link MutableConfiguration#addCacheEntryListenerConfiguration}. */ public void addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) { delegate.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); }
public void addCacheEntryListenerConfiguration( CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) { delegate.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); }
/** * JCache configuration for the "{@code timestable}" cache. * The key is {@link Tuple} holding the input to the times * table argument (eg. the pair {@code 5} and {@code 6}) and * the value is the resulting number. * <p> * Add a cache listener so we can observe when items are * actually added to the cache, as this helps to prove when * caching is happening and when it is not. */ @SuppressWarnings({"rawtypes", "unchecked"}) public static MutableConfiguration timesTableConfiguration() { MutableConfiguration<Tuple, Integer> mutableConfiguration = new MutableConfiguration<>(); mutableConfiguration.setTypes(Tuple.class, Integer.class); CacheEntryListenerConfiguration cacheEntryListenerConfiguration = new MutableCacheEntryListenerConfiguration( // Factory, FilterFactory, is old value required?, is synchronous? new MyCacheListenerFactory(), null, false, false); mutableConfiguration.addCacheEntryListenerConfiguration(cacheEntryListenerConfiguration); return mutableConfiguration; }
@SuppressWarnings("unchecked") @Override public <C extends Configuration<K, V>> C getConfiguration(Class<C> _class) { if (CompleteConfiguration.class.isAssignableFrom(_class)) { MutableConfiguration<K, V> cfg = new MutableConfiguration<K, V>(); cfg.setTypes(keyType, valueType); cfg.setStatisticsEnabled(jmxStatisticsEnabled); cfg.setManagementEnabled(jmxEnabled); cfg.setStoreByValue(storeByValue); Collection<CacheEntryListenerConfiguration<K,V>> _listenerConfigurations = eventHandling.getAllListenerConfigurations(); for (CacheEntryListenerConfiguration<K,V> _listenerConfig : _listenerConfigurations) { cfg.addCacheEntryListenerConfiguration(_listenerConfig); } return (C) cfg; } return (C) new Configuration<K, V>() { @Override public Class<K> getKeyType() { return keyType; } @Override public Class<V> getValueType() { return valueType; } @Override public boolean isStoreByValue() { return storeByValue; } }; }
public void testMultipleCacheEntryListenerFactories_differentOrder_shouldbe_equal() { Factory<? extends CacheEntryListener<String, String>> listenerFactory1 = FactoryBuilder.factoryOf(ACacheEntryListener.class); Factory<? extends CacheEntryListener<String, String>> listenerFactory2 = FactoryBuilder.factoryOf(AnotherCacheEntryListener.class); MutableCacheEntryListenerConfiguration<String, String> listenerConfig1 = new MutableCacheEntryListenerConfiguration<String, String>(listenerFactory1, null, false, false); MutableCacheEntryListenerConfiguration<String, String> listenerConfig2 = new MutableCacheEntryListenerConfiguration<>(listenerFactory2, null, false, false); MutableConfiguration<String, String> config1 = new MutableConfiguration<>(); MutableConfiguration<String, String> config2 = new MutableConfiguration<>(); config1.addCacheEntryListenerConfiguration(listenerConfig1); config2.addCacheEntryListenerConfiguration(listenerConfig2); assertFalse(config1.equals(config2)); // same listeners just added in different order. // if listeners kept in set, they would compare correctly. // currently, listeners are kept in ArrayList and listeners must be in same order to be equal. config1.addCacheEntryListenerConfiguration(listenerConfig2); config2.addCacheEntryListenerConfiguration(listenerConfig1); System.out.println("config1.hashCode=" + config1.hashCode() + " config2.hashcode()=" + config2.hashCode() + "equals()=" + config1.equals(config2)); assertTrue(config1.equals(config2)); }
@Override protected MutableConfiguration<Integer, Integer> extraSetup(MutableConfiguration<Integer, Integer> configuration) { listener = new CacheTestSupport.MyCacheEntryListener<Integer, Integer>(true); //establish a CacheEntryListenerClient that a Cache can use for CacheEntryListening //(via the CacheEntryListenerServer) listenerConfiguration = new MutableCacheEntryListenerConfiguration<>(FactoryBuilder.factoryOf(cacheEntryListerClient), null, true, true); cacheEntryListenerServer.addCacheEventListener(listener); return configuration.addCacheEntryListenerConfiguration(listenerConfiguration); }
<K, T> Configuration<K, T> createConfiguration(final CacheSizeManager<K, T> listener) { return new MutableConfiguration<K, T>() .setStoreByValue(false) .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(SECONDS, cacheExpiry))) .setManagementEnabled(cacheManagement) .setStatisticsEnabled(cacheStatistics) .addCacheEntryListenerConfiguration(new MutableCacheEntryListenerConfiguration<>( new FactoryBuilder.SingletonFactory<>(listener), null, false, false)); }
public MutableConfiguration(CompleteConfiguration<K, V> configuration) { this.keyType = configuration.getKeyType(); this.valueType = configuration.getValueType(); listenerConfigurations = new HashSet<CacheEntryListenerConfiguration<K, V>>(); for (final CacheEntryListenerConfiguration<K, V> definition : configuration.getCacheEntryListenerConfigurations()) { addCacheEntryListenerConfiguration(definition); } this.cacheLoaderFactory = configuration.getCacheLoaderFactory(); this.cacheWriterFactory = configuration.getCacheWriterFactory(); if (configuration.getExpiryPolicyFactory() == null) { this.expiryPolicyFactory = EternalExpiryPolicy.factoryOf(); } else { this.expiryPolicyFactory = configuration.getExpiryPolicyFactory(); } this.isReadThrough = configuration.isReadThrough(); this.isWriteThrough = configuration.isWriteThrough(); this.isStatisticsEnabled = configuration.isStatisticsEnabled(); this.isStoreByValue = configuration.isStoreByValue(); this.isManagementEnabled = configuration.isManagementEnabled(); }
/** * Constructs a {@link MutableConfiguration} based on another * {@link CompleteConfiguration}. * * @param configuration the {@link CompleteConfiguration} */ public MutableConfiguration(CompleteConfiguration<K, V> configuration) { this.keyType = configuration.getKeyType(); this.valueType = configuration.getValueType(); listenerConfigurations = new HashSet<CacheEntryListenerConfiguration<K, V>>(); for (CacheEntryListenerConfiguration<K, V> definition : configuration .getCacheEntryListenerConfigurations()) { addCacheEntryListenerConfiguration(definition); } this.cacheLoaderFactory = configuration.getCacheLoaderFactory(); this.cacheWriterFactory = configuration.getCacheWriterFactory(); if (configuration.getExpiryPolicyFactory() == null) { this.expiryPolicyFactory = EternalExpiryPolicy.factoryOf(); } else { this.expiryPolicyFactory = configuration.getExpiryPolicyFactory(); } this.isReadThrough = configuration.isReadThrough(); this.isWriteThrough = configuration.isWriteThrough(); this.isStatisticsEnabled = configuration.isStatisticsEnabled(); this.isStoreByValue = configuration.isStoreByValue(); this.isManagementEnabled = configuration.isManagementEnabled(); }
@Override protected MutableConfiguration<Long, String> extraSetup(MutableConfiguration<Long, String> configuration) { cacheEntryListenerServer = new CacheEntryListenerServer<Long, String>(10011, Long.class, String.class); try { cacheEntryListenerServer.open(); } catch (IOException e) { e.printStackTrace(); } //establish and open a CacheEntryListenerServer to handle cache //cache entry events from a CacheEntryListenerClient listener = new MyCacheEntryListener<Long, String>(oldValueRequired); cacheEntryListenerServer.addCacheEventListener(listener); //establish a CacheEntryListenerClient that a Cache can use for CacheEntryListening //(via the CacheEntryListenerServer) CacheEntryListenerClient<Long, String> clientListener = new CacheEntryListenerClient<>(cacheEntryListenerServer.getInetAddress(), cacheEntryListenerServer.getPort()); listenerConfiguration = new MutableCacheEntryListenerConfiguration<Long, String>(FactoryBuilder.factoryOf(clientListener), null, oldValueRequired, true); return configuration.addCacheEntryListenerConfiguration(listenerConfiguration); }
@Test public void listener() throws InterruptedException { final CachingProvider cachingProvider = Caching.getCachingProvider(); final CacheManager cacheManager = cachingProvider.getCacheManager(); final CacheEntryExpiredListenerImpl listener = new CacheEntryExpiredListenerImpl(); cacheManager.createCache("default", new MutableConfiguration<String, String>() .setExpiryPolicyFactory(new FactoryBuilder.SingletonFactory<ExpiryPolicy>( new CreatedExpiryPolicy(new Duration(TimeUnit.MILLISECONDS, 1)))) .addCacheEntryListenerConfiguration(new MutableCacheEntryListenerConfiguration<String, String>( FactoryBuilder.factoryOf(listener), null, false, false ))); final Cache<String, String> cache = cacheManager.getCache("default"); assertFalse(cache.containsKey("foo")); cache.put("foo", "bar"); Thread.sleep(10); assertFalse(cache.containsKey("foo")); cachingProvider.close(); assertEquals(1, listener.events.size()); }
@Test public void testSetAttributeToNull() { MutableConfiguration<String, String> config = new MutableConfiguration<String, String>(); try { config.setTypes(null, String.class); fail("null poiner exception expected"); } catch (NullPointerException e) { // ignore this expected exception. } try { config.setTypes(String.class, null); fail("null poiner exception expected"); } catch (NullPointerException e) { // ignore this expected exception. } try { config.addCacheEntryListenerConfiguration(null); fail("null poiner exception expected"); } catch (NullPointerException e) { // ignore this expected exception. } try { config.setExpiryPolicyFactory(null); assertNotNull(config.getExpiryPolicyFactory()); } catch (NullPointerException e) { fail("should not throw NullPointerException when setting ExpiryPolicyFactory to null"); } }