io.github.bucket4j.grid.ProxyManager Java Examples

public ProxyManager<String> resolve(String cacheName) {
	Cache<Object, Object> cache = cacheContainer.getCache(cacheName);
	if (cache == null) {
		throw new JCacheNotFoundException(cacheName);
	}

	FunctionalMapImpl functionalMap = FunctionalMapImpl.create(cache.getAdvancedCache());
	return Bucket4j.extension(Infinispan.class).proxyManagerForMap(ReadWriteMapImpl.create(functionalMap));
}
 

public ProxyManager<String>  resolve(String cacheName) {
	Cache springCache = cacheManager.getCache(cacheName);
	if (springCache == null) {
		throw new JCacheNotFoundException(cacheName);
	}

	return Bucket4j.extension(JCache.class).proxyManagerForCache(springCache);
}
 

@Test
public void testBucketRegistryWithKeyIndependentConfiguration() {
    BucketConfiguration configuration = Bucket4j.configurationBuilder()
            .addLimit(Bandwidth.simple(10, Duration.ofDays(1)))
            .build();

    ProxyManager<String> registry = newProxyManager();
    Bucket bucket1 = registry.getProxy(key, () -> configuration);
    assertTrue(bucket1.tryConsume(10));
    assertFalse(bucket1.tryConsume(1));

    Bucket bucket2 = registry.getProxy(anotherKey, () -> configuration);
    assertTrue(bucket2.tryConsume(10));
    assertFalse(bucket2.tryConsume(1));
}
 

@Test
public void testBucketWithNotLazyConfiguration() {
    BucketConfiguration configuration = Bucket4j.configurationBuilder()
            .addLimit(Bandwidth.simple(10, Duration.ofDays(1)))
            .build();

    ProxyManager<String> registry = newProxyManager();
    Bucket bucket = registry.getProxy(key, configuration);
    assertTrue(bucket.tryConsume(10));
    assertFalse(bucket.tryConsume(1));
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForCache(cache);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForCache(cache);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(JCache.class).proxyManagerForCache(getCache());
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(Infinispan.class).proxyManagerForMap(readWriteMap);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(Infinispan.class).proxyManagerForMap(readWriteMap);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForMap(map);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForMap(map);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForMap(map);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForMap(map);
}
 

@Override
protected ProxyManager<String> newProxyManager() {
    return Bucket4j.extension(getExtensionClass()).proxyManagerForCache(cache);
}
 

@Override
public ProxyManager<String> resolve(String cacheName) {
	org.apache.ignite.IgniteCache<String, GridBucketState> cache = ignite.cache(cacheName);
	return Bucket4j.extension(io.github.bucket4j.grid.ignite.Ignite.class).proxyManagerForCache(cache);
}
 

@Override
protected ProxyManager<String> getProxyManager(io.github.bucket4j.grid.ignite.Ignite extension) {
    return extension.proxyManagerForCache(cache);
}
 

@Override
protected ProxyManager<String> getProxyManager(io.github.bucket4j.grid.jcache.JCache extension) {
    return extension.proxyManagerForCache(cache);
}
 

@Override
protected ProxyManager<String> getProxyManager(io.github.bucket4j.grid.infinispan.Infinispan extension) {
    return extension.proxyManagerForMap(readWriteMap);
}
 

@Override
protected ProxyManager<String> getProxyManager(io.github.bucket4j.grid.hazelcast.Hazelcast extension) {
    return extension.proxyManagerForMap(rateLimit);
}
 

public FilterConfiguration<R> buildFilterConfig(Bucket4JConfiguration config, 
		ProxyManager<String> buckets, 
		ExpressionParser expressionParser, 
		ConfigurableBeanFactory  beanFactory) {
	
	config.getRateLimits().forEach(r -> {
		if(r.getFilterKeyType() != null) {
			throw new FilterKeyTypeDeprectatedException();
		}
	});
	
	FilterConfiguration<R> filterConfig = new FilterConfiguration<>();
	filterConfig.setUrl(config.getUrl());
	filterConfig.setOrder(config.getFilterOrder());
	filterConfig.setStrategy(config.getStrategy());
	filterConfig.setHttpResponseBody(config.getHttpResponseBody());
	filterConfig.setMetrics(config.getMetrics());
	
	throwExceptionOnInvalidFilterUrl(filterConfig);
	
	config.getRateLimits().forEach(rl -> {
		
		MetricHandler metricHandler = beanFactory.getBean(MetricHandler.class);
		final ConfigurationBuilder configurationBuilder = prepareBucket4jConfigurationBuilder(rl);
		
		RateLimitCheck<R> rlc = (servletRequest, async) -> {
			
	        boolean skipRateLimit = false;
	        if (rl.getSkipCondition() != null) {
	        	skipRateLimit = skipCondition(rl, expressionParser, beanFactory).evalute(servletRequest);
	        } 
	        
	        if(rl.getExecuteCondition() != null && !skipRateLimit) {
	        	skipRateLimit = !executeCondition(rl, expressionParser, beanFactory).evalute(servletRequest);
	        }
	        
	        if(!skipRateLimit) {
	        	String key = getKeyFilter(filterConfig.getUrl(), rl, expressionParser, beanFactory).key(servletRequest);
	        	BucketConfiguration bucketConfiguration = configurationBuilder.build();
	        	
	        	List<MetricTagResult> metricTagResults = getMetricTags(expressionParser, beanFactory, filterConfig,
						servletRequest);

	        	MetricBucketListener metricBucketListener = new MetricBucketListener(
						config.getCacheName(),
						metricHandler, 
						filterConfig.getMetrics().getTypes(),
						metricTagResults);
				
				Bucket bucket = buckets.getProxy(key, bucketConfiguration).toListenable( metricBucketListener);
	        	if(async) {
	        		return new ConsumptionProbeHolder(bucket.asAsync().tryConsumeAndReturnRemaining(1));
	        	} else {
	        		return new ConsumptionProbeHolder(bucket.tryConsumeAndReturnRemaining(1));
	        	}
	        	
	        }
			return null;
			
		};
		filterConfig.getRateLimitChecks().add(rlc);
		
	});
	
	return filterConfig;
}
 

@Override
public ProxyManager<String> resolve(String cacheName) {
	com.hazelcast.core.IMap<String, GridBucketState> map = hazelcastInstance.getMap(cacheName);
	return Bucket4j.extension(Hazelcast.class).proxyManagerForMap(map);
}
 

@Override
public ProxyManager<String> resolve(String cacheName) {
	Cache<Object, Object> cache = cacheContainer.getCache(cacheName);
	// TODO how to create an instance of ReadWriteMap
	return Bucket4j.extension(io.github.bucket4j.grid.infinispan.Infinispan.class).proxyManagerForMap(null);
}
 

/**
 * Creates {@link CoherenceProxyManager} for specified cache.
 *
 * @param cache cache for storing state of buckets
 * @param <T> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForCache(NamedCache<T, GridBucketState> cache) {
    return new CoherenceProxyManager<>(cache);
}
 

/**
 * Creates {@link HazelcastProxyManager} for specified map.
 *
 * @param map map for storing state of buckets
 * @param <T> type of keys in the map
 * @return {@link ProxyManager} for specified map.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForMap(IMap<T, GridBucketState> map) {
    return new HazelcastProxyManager<>(map);
}
 

/**
 * Creates {@link IgniteProxyManager} for specified cache.
 *
 * @param cache cache for storing state of buckets
 * @param <T> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForCache(IgniteCache<T, GridBucketState> cache) {
    return new IgniteProxyManager<>(cache);
}
 

/**
 * Creates {@link HazelcastProxyManager} for specified map.
 *
 * @param map map for storing state of buckets
 * @param <T> type of keys in the map
 * @return {@link ProxyManager} for specified map.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForMap(IMap<T, GridBucketState> map) {
    return new HazelcastProxyManager<>(map);
}
 

/**
 * Creates {@link InfinispanProxyManager} for specified cache.
 *
 * @param readWriteMap cache for storing state of buckets
 * @param <K> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <K extends Serializable> ProxyManager<K> proxyManagerForMap(FunctionalMap.ReadWriteMap<K, GridBucketState> readWriteMap) {
    return new InfinispanProxyManager<>(readWriteMap);
}
 

/**
 * Creates {@link InfinispanProxyManager} for specified cache.
 *
 * @param readWriteMap cache for storing state of buckets
 * @param <K> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <K extends Serializable> ProxyManager<K> proxyManagerForMap(ReadWriteMap<K, GridBucketState> readWriteMap) {
    return new InfinispanProxyManager<>(readWriteMap);
}
 

/**
 * Creates {@link JCacheProxyManager} for specified cache.
 *
 * @param cache cache for storing state of buckets
 * @param <T> type of keys in the cache
 * @return {@link ProxyManager} for specified cache.
 */
public <T extends Serializable> ProxyManager<T> proxyManagerForCache(Cache<T, GridBucketState> cache) {
    return new JCacheProxyManager<>(cache);
}
 

ProxyManager<String> resolve(String cacheName);