Java Code Examples for org.infinispan.configuration.global.GlobalConfigurationBuilder#defaultClusteredBuilder()

@ApplicationScoped
@Produces
public EmbeddedCacheManager cacheManager(
        @RegistryProperties("registry.infinispan.transport") Properties properties
) {
    GlobalConfigurationBuilder gConf = GlobalConfigurationBuilder.defaultClusteredBuilder();

    gConf.serialization()
            .marshaller(new JavaSerializationMarshaller())
            .whiteList()
            .addRegexps(
                    "io.apicurio.registry.storage.",
                    TupleId.class.getName(),
                    MapValue.class.getName()
            );

    TransportConfigurationBuilder tConf = gConf.transport();
    tConf.clusterName(clusterName);
    if (properties.size() > 0) {
        tConf.withProperties(properties);
    }

    return new DefaultCacheManager(gConf.build(), true);
}
 

public static void main(String[] args) throws Exception {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build());
   // Create a replicated synchronous configuration
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.clustering().cacheMode(CacheMode.REPL_SYNC);
   Configuration cacheConfig = builder.build();
   // Create a cache
   Cache<String, String> cache = cacheManager.administration()
           .withFlags(CacheContainerAdmin.AdminFlag.VOLATILE)
           .getOrCreateCache("cache", cacheConfig);

   // Store the current node address in some random keys
   for(int i=0; i < 10; i++) {
      cache.put(UUID.randomUUID().toString(), cacheManager.getNodeAddress());
   }
   // Display the current cache contents for the whole cluster
   cache.entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Display the current cache contents for this node
   cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP)
      .entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Stop the cache manager and release all resources
   cacheManager.stop();
}
 

public static void main(String[] args) throws Exception {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build());
   //Create cache configuration
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.clustering().cacheMode(CacheMode.DIST_SYNC);
   // Obtain a cache
   Cache<String, String> cache = cacheManager.administration().withFlags(CacheContainerAdmin.AdminFlag.VOLATILE)
         .getOrCreateCache("cache", builder.build());

   // Store the current node address in some random keys
   for (int i = 0; i < 10; i++) {
      cache.put(UUID.randomUUID().toString(), cacheManager.getNodeAddress());
   }
   // Display the current cache contents for the whole cluster
   cache.entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Display the current cache contents for this node
   cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP).entrySet()
         .forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Stop the cache manager and release all resources
   cacheManager.stop();
}
 

public static void main(String[] args) {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build());
   ClusterExecutor clusterExecutor = cacheManager.executor();
   clusterExecutor.submitConsumer(cm -> new Random().nextInt(), (address, intValue, exception) ->
           System.out.printf("%s\n", intValue));
   // Shuts down the cache manager and all associated resources
   cacheManager.stop();
}
 

@Bean
public InfinispanGlobalConfigurer globalCustomizer() {
   return () -> {
      GlobalConfigurationBuilder builder = GlobalConfigurationBuilder.defaultClusteredBuilder();
      builder.serialization().marshaller(new JavaSerializationMarshaller());
      builder.serialization().whiteList().addClass("org.springframework.session.MapSession");
      builder.serialization().whiteList().addRegexp("java.util.*");
      return builder.build();
   };
}
 

public static void main(String[] args) throws InterruptedException {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();

   // Initialize 1 cache managers
   DefaultCacheManager cm = new DefaultCacheManager(global.build());

   // Initialize the clustered lock manager from the cache manager
   ClusteredLockManager clm1 = EmbeddedClusteredLockManagerFactory.from(cm);

   // Define a lock. By default this lock is non reentrant
   clm1.defineLock("lock");

   // Get a lock interface from each node
   ClusteredLock lock = clm1.get("lock");

   AtomicInteger counter = new AtomicInteger(0);

   // Acquire and release the lock 3 times
   CompletableFuture<Boolean> call1 = lock.tryLock(1, TimeUnit.SECONDS).whenComplete((r, ex) -> {
      if (r) {
         System.out.println("lock is acquired by the call 1");
         lock.unlock().whenComplete((nil, ex2) -> {
            System.out.println("lock is released by the call 1");
            counter.incrementAndGet();
         });
      }
   });

   CompletableFuture<Boolean> call2 = lock.tryLock(1, TimeUnit.SECONDS).whenComplete((r, ex) -> {
      if (r) {
         System.out.println("lock is acquired by the call 2");
         lock.unlock().whenComplete((nil, ex2) -> {
            System.out.println("lock is released by the call 2");
            counter.incrementAndGet();
         });
      }
   });

   CompletableFuture<Boolean> call3 = lock.tryLock(1, TimeUnit.SECONDS).whenComplete((r, ex) -> {
      if (r) {
         System.out.println("lock is acquired by the call 3");
         lock.unlock().whenComplete((nil, ex2) -> {
            System.out.println("lock is released by the call 3");
            counter.incrementAndGet();
         });
      }
   });

   CompletableFuture.allOf(call1, call2, call3).whenComplete((r, ex) -> {
      // Print the value of the counter
      System.out.println("Value of the counter is " + counter.get());

      // Stop the cache manager
      cm.stop();
   });
}
 

public static void main(String[] args) throws Exception {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Create the counter configuration builder
   CounterManagerConfigurationBuilder builder = global.addModule(CounterManagerConfigurationBuilder.class);

   // Create 3 counters.
   // The first counter is bounded to 10 (upper-bound).
   builder.addStrongCounter().name("counter-1").upperBound(10).initialValue(1);
   // The second counter is unbounded
   builder.addStrongCounter().name("counter-2").initialValue(2);
   // And finally, the third counter is a weak counter.
   builder.addWeakCounter().name("counter-3").initialValue(3);
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build());

   // Retrieve the CounterManager from the CacheManager. Each CacheManager has it own CounterManager
   CounterManager counterManager = EmbeddedCounterManagerFactory.asCounterManager(cacheManager);

   // StrongCounter provides the higher consistency. Its value is known during the increment/decrement and it may be bounded.
   // Bounded counters are aimed for uses cases where a limit is needed.
   StrongCounter counter1 = counterManager.getStrongCounter("counter-1");
   // All methods returns a CompletableFuture. So you can do other work while the counter value is being computed.
   counter1.getValue().thenAccept(value -> System.out.println("Counter-1 initial value is " + value)).get();

   // Try to add more than the upper-bound
   counter1.addAndGet(10).handle((value, throwable) -> {
      // Value is null since the counter is bounded and we can add 10 to it.
      System.out.println("Counter-1 Exception is " + throwable.getMessage());
      return 0;
   }).get();

   // Check the counter value. It should be the upper-bound (10)
   counter1.getValue().thenAccept(value -> System.out.println("Counter-1 value is " + value)).get();

   //Decrement the value. Should be 9.
   counter1.decrementAndGet().handle((value, throwable) -> {
      // No exception this time.
      System.out.println("Counter-1 new value is " + value);
      return value;
   }).get();

   // Similar to counter-1, counter-2 is a strong counter but it is unbounded. It will never throw the CounterOutOfBoundsException
   StrongCounter counter2 = counterManager.getStrongCounter("counter-2");

   // All counters allow a listener to be registered.
   // The handle can be used to remove the listener
   counter2.addListener(event -> System.out
         .println("Counter-2 event: oldValue=" + event.getOldValue() + " newValue=" + event.getNewValue()));

   // Adding MAX_VALUE won't throws an exception. But the all the increments won't have any effect since we can store
   //any value larger the MAX_VALUE
   counter2.addAndGet(Long.MAX_VALUE).thenAccept(aLong -> System.out.println("Counter-2 value is " + aLong)).get();

   // Conditional operations are allowed in strong counters
   counter2.compareAndSet(Long.MAX_VALUE, 0)
         .thenAccept(aBoolean -> System.out.println("Counter-2 CAS result is " + aBoolean)).get();
   counter2.getValue().thenAccept(value -> System.out.println("Counter-2 value is " + value)).get();

   // Reset the counter to its initial value (2)
   counter2.reset().get();
   counter2.getValue().thenAccept(value -> System.out.println("Counter-2 initial value is " + value)).get();

   // Retrieve counter-3
   WeakCounter counter3 = counterManager.getWeakCounter("counter-3");
   // Weak counter doesn't have its value available during updates. This makes the increment faster than the StrongCounter
   // Its value is computed lazily and stored locally.
   // Its main use case is for uses-case where faster increments are needed.
   counter3.add(5).thenAccept(aVoid -> System.out.println("Adding 5 to counter-3 completed!")).get();

   // Check the counter value.
   System.out.println("Counter-3 value is " + counter3.getValue());

   // Stop the cache manager and release all resources
   cacheManager.stop();
}
 

private static GlobalConfiguration getGlobalConfiguration() {
    GlobalConfigurationBuilder globalConfigurationBuilder = GlobalConfigurationBuilder.defaultClusteredBuilder();
    globalConfigurationBuilder.serialization().addContextInitializer(new Bucket4jProtobufContextInitializer());
    return globalConfigurationBuilder.build();
}