/** * {@inheritDoc} */ @Override public Iterator<Entry<K, V>> iterator() { statusTransitioner.checkAvailable(); return new CacheEntryIterator(false); }
@Override public <K, V> Cache<K, V> getCache(String alias, Class<K> keyType, Class<V> valueType) { statusTransitioner.checkAvailable(); final CacheHolder cacheHolder = caches.get(alias); if(cacheHolder == null) { return null; } else { try { return cacheHolder.retrieve(keyType, valueType); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("Cache '" + alias + "' type is <" + cacheHolder.keyType.getName() + ", " + cacheHolder.valueType.getName() + ">, but you retrieved it with <" + keyType.getName() + ", " + valueType.getName() +">"); } } }
/** * {@inheritDoc} */ @Override public boolean containsKey(final K key) { statusTransitioner.checkAvailable(); checkNonNull(key); try { return store.containsKey(key); } catch (StoreAccessException e) { return resilienceStrategy.containsKeyFailure(key, e); } }
@Override public void run() { try { transitioner.checkAvailable(); fail(); } catch (IllegalStateException e) { assertThat(e.getMessage().contains(Status.MAINTENANCE.name()), is(true)); assertThat(e.getMessage().contains("own"), is(true)); } } };
/** * Closes and removes a cache, by alias, from this cache manager. * * @param alias the alias of the cache to remove * @param removeFromConfig if {@code true}, the cache configuration is altered to remove the cache */ private void removeCache(final String alias, final boolean removeFromConfig) { statusTransitioner.checkAvailable(); final CacheHolder cacheHolder = caches.remove(alias); if(cacheHolder != null) { final InternalCache<?, ?> ehcache = cacheHolder.retrieve(cacheHolder.keyType, cacheHolder.valueType); if (ehcache != null) { if (removeFromConfig) { configuration.removeCacheConfiguration(alias); } if (!statusTransitioner.isTransitioning()) { for (CacheManagerListener listener : listeners) { listener.cacheRemoved(alias, ehcache); } } ehcache.close(); closeEhcache(alias, ehcache); } LOGGER.info("Cache '{}' removed from {}.", alias, simpleName); } }
protected Map<K,V> getAllInternal(Set<? extends K> keys, boolean includeNulls) { getAllObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNullContent(keys); if (keys.isEmpty()) { getAllObserver.end(GetAllOutcome.SUCCESS); return Collections.emptyMap(); } try { Map<K, V> result = doGetAllInternal(keys, includeNulls); getAllObserver.end(GetAllOutcome.SUCCESS); return result; } catch (StoreAccessException e) { Map<K, V> result = resilienceStrategy.getAllFailure(keys, e); getAllObserver.end(GetAllOutcome.FAILURE); return result; } } catch (Throwable e) { getAllObserver.end(GetAllOutcome.FAILURE); throw e; } }
/** * {@inheritDoc} */ @Override public void removeAll(Set<? extends K> keys) throws BulkCacheWritingException { removeAllObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(keys); if (keys.isEmpty()) { removeAllObserver.end(RemoveAllOutcome.SUCCESS); return; } for (K key : keys) { if (key == null) { throw new NullPointerException(); } } try { doRemoveAll(keys); removeAllObserver.end(RemoveAllOutcome.SUCCESS); } catch (StoreAccessException e) { resilienceStrategy.removeAllFailure(keys, e); removeAllObserver.end(RemoveAllOutcome.FAILURE); } } catch (Throwable e) { removeAllObserver.end(RemoveAllOutcome.FAILURE); throw e; } }
private <K, V> Cache<K, V> createCache(String alias, CacheConfiguration<K, V> originalConfig, boolean addToConfig) throws IllegalArgumentException { statusTransitioner.checkAvailable();
/** * {@inheritDoc} */ @Override public void clear() { clearObserver.begin(); try { statusTransitioner.checkAvailable(); try { store.clear(); clearObserver.end(ClearOutcome.SUCCESS); } catch (StoreAccessException e) { resilienceStrategy.clearFailure(e); clearObserver.end(ClearOutcome.FAILURE); } } catch (Throwable e) { clearObserver.end(ClearOutcome.FAILURE); throw e; } }
statusTransitioner.checkAvailable();
/** * {@inheritDoc} */ @Override public void putAll(Map<? extends K, ? extends V> entries) throws BulkCacheWritingException { putAllObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(entries); if(entries.isEmpty()) { putAllObserver.end(PutAllOutcome.SUCCESS); return; } try { doPutAll(entries); putAllObserver.end(PutAllOutcome.SUCCESS); } catch (StoreAccessException e) { resilienceStrategy.putAllFailure(entries, e); putAllObserver.end(PutAllOutcome.FAILURE); } } catch (Exception e) { putAllObserver.end(PutAllOutcome.FAILURE); throw e; } }
@Test public void testCheckAvailableAccountsForThreadLease() throws InterruptedException { final StatusTransitioner transitioner = new StatusTransitioner(LoggerFactory.getLogger(StatusTransitionerTest.class)); transitioner.maintenance().succeeded(); transitioner.checkAvailable(); Thread thread = new Thread() { @Override public void run() { try { transitioner.checkAvailable(); fail(); } catch (IllegalStateException e) { assertThat(e.getMessage().contains(Status.MAINTENANCE.name()), is(true)); assertThat(e.getMessage().contains("own"), is(true)); } } }; thread.start(); thread.join(); transitioner.close(); }
/** * {@inheritDoc} */ @Override public void put(K key, V value) { putObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key, value); try { Store.PutStatus status = doPut(key, value); switch (status) { case PUT: putObserver.end(PutOutcome.PUT); break; case NOOP: putObserver.end(PutOutcome.NOOP); break; default: throw new AssertionError("Invalid Status."); } } catch (StoreAccessException e) { resilienceStrategy.putFailure(key, value, e); putObserver.end(PutOutcome.FAILURE); } } catch (Throwable e) { putObserver.end(PutOutcome.FAILURE); throw e; } }
conditionalRemoveObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key, value);
replaceObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key, oldValue, newValue);
protected boolean removeInternal(final K key) { removeObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key); boolean removed = false; try { removed = doRemoveInternal(key); if (removed) { removeObserver.end(RemoveOutcome.SUCCESS); } else { removeObserver.end(RemoveOutcome.NOOP); } } catch (StoreAccessException e) { resilienceStrategy.removeFailure(key, e); removeObserver.end(RemoveOutcome.FAILURE); } return removed; } catch (Throwable e) { removeObserver.end(RemoveOutcome.FAILURE); throw e; } }
/** * {@inheritDoc} */ @Override public V replace(K key, V value) { replaceObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key, value); try { V result = doReplace(key, value); if(result == null) { replaceObserver.end(ReplaceOutcome.MISS_NOT_PRESENT); } else { replaceObserver.end(ReplaceOutcome.HIT); } return result; } catch (StoreAccessException e) { V result = resilienceStrategy.replaceFailure(key, value, e); replaceObserver.end(ReplaceOutcome.FAILURE); return result; } } catch (Throwable e) { replaceObserver.end(ReplaceOutcome.FAILURE); throw e; } }
protected V getNoLoader(K key) { getObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key); try { Store.ValueHolder<V> valueHolder = store.get(key); // Check for expiry first if (valueHolder == null) { getObserver.end(GetOutcome.MISS); return null; } else { getObserver.end(GetOutcome.HIT); return valueHolder.get(); } } catch (StoreAccessException e) { V value = resilienceStrategy.getFailure(key, e); getObserver.end(GetOutcome.FAILURE); return value; } } catch (Throwable e) { getObserver.end(GetOutcome.FAILURE); throw e; } }
/** * {@inheritDoc} */ @Override public V get(K key) { getObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key); try { Store.ValueHolder<V> valueHolder = doGet(key); // Check for expiry first if (valueHolder == null) { getObserver.end(GetOutcome.MISS); return null; } else { getObserver.end(GetOutcome.HIT); return valueHolder.get(); } } catch (StoreAccessException e) { V value = resilienceStrategy.getFailure(key, e); getObserver.end(GetOutcome.FAILURE); return value; } } catch (Throwable e) { getObserver.end(GetOutcome.FAILURE); throw e; } }
/** * {@inheritDoc} */ @Override public V putIfAbsent(final K key, final V value) { putIfAbsentObserver.begin(); try { statusTransitioner.checkAvailable(); checkNonNull(key, value); boolean[] put = { false }; try { ValueHolder<V> inCache = doPutIfAbsent(key, value, b -> put[0] = b); if (put[0]) { putIfAbsentObserver.end(PutIfAbsentOutcome.PUT); return null; } else { putIfAbsentObserver.end(PutIfAbsentOutcome.HIT); return inCache.get(); } } catch (StoreAccessException e) { V newValue = resilienceStrategy.putIfAbsentFailure(key, value, e); putIfAbsentObserver.end(PutIfAbsentOutcome.FAILURE); return newValue; } } catch (Throwable e) { putIfAbsentObserver.end(PutIfAbsentOutcome.FAILURE); throw e; } }