private static ClusteredLockManagerConfiguration extractConfiguration(GlobalComponentRegistry globalComponentRegistry) { ClusteredLockManagerConfiguration config = globalComponentRegistry.getGlobalConfiguration() .module(ClusteredLockManagerConfiguration.class); return config == null ? ClusteredLockManagerConfigurationBuilder.defaultConfiguration() : config; }
private CounterManagerConfiguration extractCounterManagerConfiguration(EmbeddedCacheManager cacheManager) { GlobalComponentRegistry globalComponentRegistry = SecurityActions.getGlobalComponentRegistry(cacheManager); CounterManagerConfiguration config = globalComponentRegistry.getGlobalConfiguration() .module(CounterManagerConfiguration.class); return config == null ? CounterManagerConfigurationBuilder.defaultConfiguration() : config; }
@Override protected void compareExtraGlobalConfiguration(GlobalConfiguration configurationBefore, GlobalConfiguration configurationAfter) { CounterManagerConfiguration configBefore = configurationBefore.module(CounterManagerConfiguration.class); CounterManagerConfiguration configAfter = configurationAfter.module(CounterManagerConfiguration.class); assertEquals(configBefore.numOwners(), configAfter.numOwners()); assertEquals(configBefore.reliability(), configAfter.reliability()); Map<String, AbstractCounterConfiguration> counterConfigBefore = new HashMap<>(); for (AbstractCounterConfiguration configuration : configBefore.counters()) { counterConfigBefore.put(configuration.name(), configuration); } Map<String, AbstractCounterConfiguration> counterConfigAfter = new HashMap<>(); for (AbstractCounterConfiguration configuration : configAfter.counters()) { counterConfigAfter.put(configuration.name(), configuration); } assertSameStrongCounterConfiguration(counterConfigBefore.get("c1"), counterConfigAfter.get("c1")); assertSameStrongCounterConfiguration(counterConfigBefore.get("c2"), counterConfigAfter.get("c2")); assertSameStrongCounterConfiguration(counterConfigBefore.get("c3"), counterConfigAfter.get("c3")); assertSameStrongCounterConfiguration(counterConfigBefore.get("c4"), counterConfigAfter.get("c4")); assertSameWeakCounterConfiguration(counterConfigBefore.get("c5"), counterConfigAfter.get("c5")); }
public void testParser() throws IOException { ConfigurationBuilderHolder holder = new ParserRegistry().parseFile("config/counters.xml"); withCacheManager(() -> createClusteredCacheManager(holder), cacheManager -> { cacheManager.getCache(CounterModuleLifecycle.COUNTER_CACHE_NAME); GlobalConfiguration globalConfiguration = cacheManager.getGlobalComponentRegistry().getGlobalConfiguration(); CounterManagerConfiguration counterManagerConfiguration = globalConfiguration .module(CounterManagerConfiguration.class); assertNotNull(counterManagerConfiguration); assertEquals(3, counterManagerConfiguration.numOwners()); assertEquals(Reliability.CONSISTENT, counterManagerConfiguration.reliability()); Map<String, AbstractCounterConfiguration> counterConfig = new HashMap<>(); for (AbstractCounterConfiguration configuration : counterManagerConfiguration.counters()) { counterConfig.put(configuration.name(), configuration); } assertStrongCounter("c1", counterConfig.get("c1"), 1, Storage.PERSISTENT, false, Long.MIN_VALUE, Long.MAX_VALUE); assertStrongCounter("c2", counterConfig.get("c2"), 2, Storage.VOLATILE, true, 0, Long.MAX_VALUE); assertStrongCounter("c3", counterConfig.get("c3"), 3, Storage.PERSISTENT, true, Long.MIN_VALUE, 5); assertStrongCounter("c4", counterConfig.get("c4"), 4, Storage.VOLATILE, true, 0, 10); assertWeakCounter(counterConfig.get("c5")); }); }
public void testCounters() { final GlobalConfigurationBuilder builder = defaultGlobalConfigurationBuilder(true); CounterManagerConfigurationBuilder counterBuilder = builder.addModule(CounterManagerConfigurationBuilder.class); counterBuilder.addStrongCounter().name("unbounded-strong-1").initialValue(1).storage(Storage.VOLATILE) .addStrongCounter().name("lower-bounded-strong-2").initialValue(2).lowerBound(-10) .storage(Storage.PERSISTENT) .addStrongCounter().name("upper-bounded-strong-3").initialValue(3).upperBound(10) .storage(Storage.VOLATILE) .addStrongCounter().name("bounded-strong-4").initialValue(4).lowerBound(-20).upperBound(20) .storage(Storage.PERSISTENT) .addWeakCounter().name("weak-5").initialValue(5).concurrencyLevel(10).storage(Storage.VOLATILE); GlobalConfiguration config = builder.build(); CounterManagerConfiguration counterConfig = config.module(CounterManagerConfiguration.class); assertUnboundedStrongCounter(counterConfig); assertBoundedStrongCounter(counterConfig, "lower-bounded-strong-2", 2, -10, Long.MAX_VALUE, Storage.PERSISTENT); assertBoundedStrongCounter(counterConfig, "upper-bounded-strong-3", 3, Long.MIN_VALUE, 10, Storage.VOLATILE); assertBoundedStrongCounter(counterConfig, "bounded-strong-4", 4, -20, 20, Storage.PERSISTENT); assertWeakCounter(counterConfig); TestingUtil.withCacheManager(() -> new DefaultCacheManager(builder.build()), cacheManager -> { CounterManager manager = asCounterManager(cacheManager); AssertJUnit.assertTrue(manager.isDefined("unbounded-strong-1")); AssertJUnit.assertTrue(manager.isDefined("lower-bounded-strong-2")); AssertJUnit.assertTrue(manager.isDefined("upper-bounded-strong-3")); AssertJUnit.assertTrue(manager.isDefined("bounded-strong-4")); AssertJUnit.assertTrue(manager.isDefined("weak-5")); AssertJUnit.assertFalse(manager.isDefined("not-defined-counter")); }); }