public StrongServerStoreProxy(final String cacheId, final ClusterTierClientEntity entity, final ServerCallback invalidation) { this.delegate = new CommonServerStoreProxy(cacheId, entity, invalidation); this.entity = entity; delegate.addResponseListener(EhcacheEntityResponse.HashInvalidationDone.class, this::hashInvalidationDoneResponseListener); delegate.addResponseListener(EhcacheEntityResponse.AllInvalidationDone.class, this::allInvalidationDoneResponseListener); entity.addReconnectListener(this::reconnectListener); entity.addDisconnectionListener(this::disconnectionListener); }
@Override public ClusterTierClientEntity create(EntityClientEndpoint<EhcacheEntityMessage, EhcacheEntityResponse> endpoint, ClusterTierUserData userData) { return new SimpleClusterTierClientEntity(endpoint, userData.getTimeouts(), userData.getStoreIdentifier()); }
@Override public void clear() throws TimeoutException { delegate.clear(); } }
@Override public void clear() throws TimeoutException { performWaitingForAllInvalidation(() -> { delegate.clear(); return null; }, entity.getTimeouts().getWriteOperationTimeout()); } }
@Override public void append(final long key, final ByteBuffer payLoad) throws TimeoutException { performWaitingForHashInvalidation(key, () -> { delegate.append(key, payLoad); return null; }, entity.getTimeouts().getWriteOperationTimeout()); }
@Override public Chain getAndAppend(final long key, final ByteBuffer payLoad) throws TimeoutException { return performWaitingForHashInvalidation(key, () -> delegate.getAndAppend(key, payLoad), entity.getTimeouts().getWriteOperationTimeout()); }
private EhcacheEntityResponse invokeInternalAndWait(InvocationBuilder<EhcacheEntityMessage, EhcacheEntityResponse> invocationBuilder, EhcacheOperationMessage message, boolean track) throws ClusterException, TimeoutException { return invokeInternalAndWait(invocationBuilder, getTimeoutDuration(message), message, track); }
@Override public void replaceAtHead(long key, Chain expect, Chain update) { // TODO: Optimize this method to just send sequences for expect Chain try { entity.invokeAndWaitForSend(new ReplaceAtHeadMessage(key, expect, update), false); } catch (Exception e) { throw new ServerStoreProxyException(e); } }
@Override public void clear() throws TimeoutException { try { entity.invokeAndWaitForRetired(new ServerStoreOpMessage.ClearMessage(), true); } catch (TimeoutException e) { throw e; } catch (Exception e) { throw new ServerStoreProxyException(e); } } }
@Override public void append(long key, ByteBuffer payLoad) { try { entity.invokeAndWaitForReceive(new AppendMessage(key, payLoad), true); } catch (Exception e) { throw new ServerStoreProxyException(e); } }
protected <K, V> ClusteredStore<K, V> createStore(Configuration<K, V> storeConfig, OperationsCodec<K, V> codec, ChainResolver<K, V> resolver, TimeSource timeSource, boolean useLoaderInAtomics, Object[] serviceConfigs) { return new ClusteredStore<>(storeConfig, codec, resolver, timeSource); }
@Override public String getCacheId() { return storeProxy.getCacheId(); }
@Override public ValueHolder<V> putIfAbsent(final K key, final V value, Consumer<Boolean> put) throws StoreAccessException { putIfAbsentObserver.begin(); V result = silentPutIfAbsent(key, value); if(result == null) { putIfAbsentObserver.end(StoreOperationOutcomes.PutIfAbsentOutcome.PUT); return null; } else { putIfAbsentObserver.end(StoreOperationOutcomes.PutIfAbsentOutcome.HIT); return new ClusteredValueHolder<>(result); } }
@Override public ValueHolder<V> replace(final K key, final V value) throws StoreAccessException { replaceObserver.begin(); V result = silentReplace(key, value); if(result == null) { replaceObserver.end(StoreOperationOutcomes.ReplaceOutcome.MISS); return null; } else { replaceObserver.end(StoreOperationOutcomes.ReplaceOutcome.REPLACED); return new ClusteredValueHolder<>(result); } }
@Override public void unlock(long hash) throws TimeoutException { throw new ReconnectInProgressException(); } }
@Override public boolean containsKey(final K key) throws StoreAccessException { try { return getInternal(key) != null; } catch (TimeoutException e) { return false; } }
@SuppressWarnings("unchecked") @Override public void close() { entity.close(); }
@Override public void close() { storeProxy.close(); }
@Override public void clear() throws TimeoutException { storeProxy.clear(); } }
@Override public void clear() { throw new ReconnectInProgressException(); }