io.github.bucket4j.grid.GridBucketState Java Examples

private <T extends Serializable> CompletableFuture<CommandResult<T>> invokeAsync(K key, JCacheEntryProcessor<K, T> entryProcessor) {
    CompletableFuture<CommandResult<T>> future = new CompletableFuture<>();
    SingleEntryAsynchronousProcessor<K, GridBucketState, CommandResult<T>> asyncProcessor =
            new SingleEntryAsynchronousProcessor<K, GridBucketState, CommandResult<T>>(adoptEntryProcessor(entryProcessor)) {
        @Override
        public void onResult(Map.Entry<K, CommandResult<T>> entry) {
            super.onResult(entry);
            future.complete(entry.getValue());
        }
        @Override
        public void onException(Throwable error) {
            super.onException(error);
            future.completeExceptionally(error);
        }
    };
    cache.invoke(key, asyncProcessor);
    return future;
}
 

private void checkProviders(Cache<K, GridBucketState> cache) {
    CacheManager cacheManager = cache.getCacheManager();
    if (cacheManager == null) {
        return;
    }

    CachingProvider cachingProvider = cacheManager.getCachingProvider();
    if (cachingProvider == null) {
        return;
    }

    String providerClassName = cachingProvider.getClass().getName();
    incompatibleProviders.forEach((providerPrefix, recommendation) -> {
        if (providerClassName.startsWith(providerPrefix)) {
            String message = "The Cache provider " + providerClassName + " is incompatible with Bucket4j, " + recommendation;
            throw new UnsupportedOperationException(message);
        }
    });
}
 

@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    try {
        SerializableFunction<EntryView.ReadWriteEntryView<K, GridBucketState>, GridBucketState> findFunction =
                (SerializableFunction<EntryView.ReadWriteEntryView<K, GridBucketState>, GridBucketState>)
                entry -> entry.find().orElse(null);
        GridBucketState state = readWriteMap.eval(key, findFunction).get();
        if (state == null) {
            return Optional.empty();
        } else {
            return Optional.of(state.getConfiguration());
        }
    } catch (InterruptedException | ExecutionException e) {
        throw new CacheException(e);
    }
}
 

@Override
public CommandResult execute(Serializable key, GridCommand command) {
    if (exception != null) {
        throw new RuntimeException();
    }
    if (state == null) {
        return CommandResult.bucketNotFound();
    }
    emulateSerialization(key);
    command = emulateSerialization(command);
    GridBucketState newState = emulateSerialization(state);
    Serializable resultData = command.execute(newState, timeMeter.currentTimeNanos());
    if (command.isBucketStateModified()) {
        state = newState;
    }
    resultData = emulateSerialization(resultData);
    return CommandResult.success(resultData);
}
 

@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    GridBucketState state = cache.get(key);
    if (state == null) {
        return Optional.empty();
    } else {
        return Optional.of(state.getConfiguration());
    }
}
 

@Bean
@Qualifier("RateLimit")
public ReadWriteMap<String, GridBucketState> map() {
    DefaultCacheManager cacheManager = new DefaultCacheManager();
    cacheManager.defineConfiguration("rateLimit", new ConfigurationBuilder().build());
    AdvancedCache<String, GridBucketState> cache = cacheManager.<String, GridBucketState>getCache("rateLimit").getAdvancedCache();
    FunctionalMapImpl<String, GridBucketState> functionalMap = FunctionalMapImpl.create(cache);
    return ReadWriteMapImpl.create(functionalMap);
}
 

public RateLimitingFilter(JHipsterProperties jHipsterProperties) {
    this.jHipsterProperties = jHipsterProperties;

    CachingProvider cachingProvider = Caching.getCachingProvider();
    CacheManager cacheManager = cachingProvider.getCacheManager();
    CompleteConfiguration<String, GridBucketState> config =
        new MutableConfiguration<String, GridBucketState>()
            .setTypes(String.class, GridBucketState.class);

    this.cache = cacheManager.createCache(GATEWAY_RATE_LIMITING_CACHE_NAME, config);
    this.buckets = Bucket4j.extension(JCache.class).proxyManagerForCache(cache);
}
 

public RateLimitingFilter(JHipsterProperties jHipsterProperties) {
    this.jHipsterProperties = jHipsterProperties;

    CachingProvider cachingProvider = Caching.getCachingProvider();
    CacheManager cacheManager = cachingProvider.getCacheManager();
    CompleteConfiguration<String, GridBucketState> config =
        new MutableConfiguration<String, GridBucketState>()
            .setTypes(String.class, GridBucketState.class);

    this.cache = cacheManager.createCache(GATEWAY_RATE_LIMITING_CACHE_NAME, config);
    this.buckets = Bucket4j.extension(JCache.class).proxyManagerForCache(cache);
}
 

@Override
public CommandResult<T> process(MutableEntry<K, GridBucketState> mutableEntry, Object... arguments) {
    if (!mutableEntry.exists()) {
        return CommandResult.bucketNotFound();
    }
    long currentTimeNanos = currentTimeNanos();
    GridBucketState gridBucketState = mutableEntry.getValue();

    T result = targetCommand.execute(gridBucketState, currentTimeNanos);
    if (targetCommand.isBucketStateModified()) {
        mutableEntry.setValue(gridBucketState);
    }
    return CommandResult.success(result);
}
 

@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    GridBucketState state = cache.get(key);
    if (state == null) {
        return Optional.empty();
    } else {
        return Optional.of(state.getConfiguration());
    }
}
 

@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    GridBucketState state = cache.get(key);
    if (state == null) {
        return Optional.empty();
    } else {
        return Optional.of(state.getConfiguration());
    }
}
 

public static BucketState getState(Bucket bucket) {
    if (bucket instanceof LockFreeBucket) {
        AtomicReference stateRef = getFieldValue(bucket, "stateRef");
        return getFieldValue(stateRef.get(), "state");
    } else if (bucket instanceof SynchronizedBucket) {
        return getFieldValue(bucket, "state");
    } else if (bucket instanceof GridBucket) {
        GridProxyMock proxy = getFieldValue(bucket, "gridProxy");
        GridBucketState gridState = getFieldValue(proxy, "state");
        return gridState.getState();
    } else {
        throw new IllegalStateException("Unknown bucket type " + bucket.getClass());
    }
}
 

public RateLimitingFilter(JHipsterProperties jHipsterProperties) {
    this.jHipsterProperties = jHipsterProperties;

    CachingProvider cachingProvider = Caching.getCachingProvider();
    CacheManager cacheManager = cachingProvider.getCacheManager();
    CompleteConfiguration<String, GridBucketState> config =
        new MutableConfiguration<String, GridBucketState>()
            .setTypes(String.class, GridBucketState.class);

    this.cache = cacheManager.createCache(GATEWAY_RATE_LIMITING_CACHE_NAME, config);
    this.buckets = Bucket4j.extension(JCache.class).proxyManagerForCache(cache);
}
 

@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    GridBucketState state = cache.get(key);
    if (state == null) {
        return Optional.empty();
    } else {
        return Optional.of(state.getConfiguration());
    }
}
 

@Override
public Optional<BucketConfiguration> getConfiguration(K key) {
    GridBucketState state = cache.get(key);
    if (state == null) {
        return Optional.empty();
    } else {
        return Optional.of(state.getConfiguration());
    }
}
 

@Test
public void testSerializationOfBucketState() throws IOException {
    Bandwidth[] bandwidths = new Bandwidth[] {
            simple(10, ofSeconds(42)),
            classic(20, greedy(300, ofHours(2))),
            classic(400, intervallyAligned(1000, ofDays(2), Instant.now(), false))
    };
    BucketConfiguration bucketConfiguration = new BucketConfiguration(Arrays.asList(bandwidths));
    BucketState bucketState = new BucketState(bucketConfiguration, System.nanoTime());

    bucketState.addTokens(bandwidths, 42);
    GridBucketState gridBucketState = new GridBucketState(bucketConfiguration, bucketState);

    testSerialization(gridBucketState);
}
 

@Override
public Object process(Map.Entry<K, GridBucketState> entry) {
    HazelcastMutableEntryAdapter<K> entryAdapter = new HazelcastMutableEntryAdapter<>(entry);
    CommandResult<T> result = entryProcessor.process(entryAdapter);
    if (entryAdapter.isModified()) {
        GridBucketState state = entry.getValue();
        backupProcessor = new SimpleBackupProcessor<>(state);
    }
    return result;
}
 

@BeforeEach
public void setUp() {
    MockitoAnnotations.initMocks(this);
    DefaultCacheManager cacheManager = new DefaultCacheManager();
    cacheManager.defineConfiguration("rateLimit", new ConfigurationBuilder().build());
    AdvancedCache<String, GridBucketState> cache = cacheManager.<String, GridBucketState>getCache("rateLimit").getAdvancedCache();
    FunctionalMapImpl<String, GridBucketState> functionalMap = FunctionalMapImpl.create(cache);
    FunctionalMap.ReadWriteMap<String, GridBucketState> readWriteMap = ReadWriteMapImpl.create(functionalMap);
    target = new Bucket4jInfinispanRateLimiter(readWriteMap);
}
 

@Override
public void createInitialState(Serializable key, BucketConfiguration configuration) {
    if (exception != null) {
        throw new RuntimeException();
    }
    BucketState bucketState = BucketState.createInitialState(configuration, timeMeter.currentTimeNanos());
    this.state = new GridBucketState(configuration, bucketState);
}
 

public MutableEntryAdapter(EntryView.ReadWriteEntryView<K, GridBucketState> entryView) {
    this.entryView = entryView;
}
 

private static ReadWriteMap<String, GridBucketState> toMap(Cache<String, GridBucketState> cache) {
    FunctionalMapImpl<String, GridBucketState> functionalMap = FunctionalMapImpl.create(cache.getAdvancedCache());
    return ReadWriteMapImpl.create(functionalMap);
}
 

@Override
public void setValue(GridBucketState value) {
    entryView.set(value);
}
 

public JCacheProxy(Cache<K, GridBucketState> cache) {
    this.cache = Objects.requireNonNull(cache);
    checkProviders(cache);
}
 

@Override
public void setValue(GridBucketState value) {
    entryView.set(value);
}
 

@Override
public Object process(Map.Entry<K, GridBucketState> entry) {
    entry.setValue(state);
    return null; // return value from backup processor is ignored, see https://github.com/hazelcast/hazelcast/pull/14995
}
 

@Override
public <I> SimpleBackupProcessor<?> deserialize(DeserializationAdapter<I> adapter, I input) throws IOException {
    GridBucketState state = adapter.readObject(input, GridBucketState.class);
    return new SimpleBackupProcessor<>(state);
}
 

HazelcastProxyManager(IMap<K, GridBucketState> map) {
    if (map == null) {
        throw new IllegalArgumentException("map must not be null");
    }
    this.gridProxy = new HazelcastProxy<>(map);
}
 

@Override
public EntryBackupProcessor<K, GridBucketState> getBackupProcessor() {
    return backupProcessor;
}
 

public HazelcastProxy(IMap<K, GridBucketState> cache) {
    this.cache = cache;
}
 

public SimpleBackupProcessor(GridBucketState state) {
    this.state = state;
}