/*
* Copyright (c) 2008-2013, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.client.cache.impl;
import com.hazelcast.cache.impl.CacheClearResponse;
import com.hazelcast.cache.impl.CacheEventData;
import com.hazelcast.cache.impl.CacheEventListenerAdaptor;
import com.hazelcast.cache.impl.CacheEventSet;
import com.hazelcast.cache.impl.CacheEventType;
import com.hazelcast.cache.impl.CacheProxyUtil;
import com.hazelcast.cache.impl.client.AbstractCacheRequest;
import com.hazelcast.cache.impl.client.CacheAddEntryListenerRequest;
import com.hazelcast.cache.impl.client.CacheClearRequest;
import com.hazelcast.cache.impl.client.CacheGetAndRemoveRequest;
import com.hazelcast.cache.impl.client.CacheGetAndReplaceRequest;
import com.hazelcast.cache.impl.client.CachePutIfAbsentRequest;
import com.hazelcast.cache.impl.client.CachePutRequest;
import com.hazelcast.cache.impl.client.CacheRemoveEntryListenerRequest;
import com.hazelcast.cache.impl.client.CacheRemoveRequest;
import com.hazelcast.cache.impl.client.CacheReplaceRequest;
import com.hazelcast.cache.impl.operation.MutableOperation;
import com.hazelcast.client.impl.client.ClientRequest;
import com.hazelcast.client.nearcache.ClientHeapNearCache;
import com.hazelcast.client.nearcache.ClientNearCache;
import com.hazelcast.client.spi.ClientContext;
import com.hazelcast.client.spi.EventHandler;
import com.hazelcast.config.CacheConfig;
import com.hazelcast.config.InMemoryFormat;
import com.hazelcast.config.NearCacheConfig;
import com.hazelcast.core.ICompletableFuture;
import com.hazelcast.nio.serialization.Data;
import com.hazelcast.util.ExceptionUtil;
import com.hazelcast.util.executor.CompletedFuture;
import com.hazelcast.util.executor.DelegatingFuture;
import javax.cache.CacheException;
import javax.cache.configuration.CacheEntryListenerConfiguration;
import javax.cache.expiry.ExpiryPolicy;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
import static com.hazelcast.cache.impl.CacheProxyUtil.validateNotNull;
/**
* Abstract {@link com.hazelcast.cache.ICache} implementation which provides shared internal implementations
* of cache operations like put, replace, remove and invoke. These internal implementations are delegated
* by actual cache methods.
* <p/>
* <p>Note: this partial implementation is used by client.</p>
*
* @param <K> the type of key
* @param <V> the type of value
*/
abstract class AbstractClientInternalCacheProxy<K, V>
extends AbstractClientCacheProxyBase<K, V> {
protected final ClientNearCache<Data, Object> nearCache;
private final boolean cacheOnUpdate;
private final ConcurrentMap<CacheEntryListenerConfiguration, String> asyncListenerRegistrations;
private final ConcurrentMap<CacheEntryListenerConfiguration, String> syncListenerRegistrations;
private final ConcurrentMap<Integer, CountDownLatch> syncLocks;
private final AtomicInteger completionIdCounter = new AtomicInteger();
private final Object completionRegistrationMutex = new Object();
private volatile String completionRegistrationId;
protected AbstractClientInternalCacheProxy(CacheConfig cacheConfig, ClientContext clientContext) {
super(cacheConfig, clientContext);
asyncListenerRegistrations = new ConcurrentHashMap<CacheEntryListenerConfiguration, String>();
syncListenerRegistrations = new ConcurrentHashMap<CacheEntryListenerConfiguration, String>();
syncLocks = new ConcurrentHashMap<Integer, CountDownLatch>();
NearCacheConfig nearCacheConfig = cacheConfig.getNearCacheConfig();
if (nearCacheConfig != null) {
nearCache = new ClientHeapNearCache<Data>(nameWithPrefix, clientContext, nearCacheConfig);
cacheOnUpdate = nearCacheConfig.getLocalUpdatePolicy() == NearCacheConfig.LocalUpdatePolicy.CACHE;
} else {
nearCache = null;
cacheOnUpdate = false;
}
}
protected <T> ICompletableFuture<T> invoke(ClientRequest req, Data keyData, boolean completionOperation) {
Integer completionId = null;
if (completionOperation) {
completionId = registerCompletionLatch(1);
if (req instanceof AbstractCacheRequest) {
((AbstractCacheRequest) req).setCompletionId(completionId);
}
}
try {
final ICompletableFuture<T> f = clientContext.getInvocationService().invokeOnKeyOwner(req, keyData);
if (completionOperation) {
waitCompletionLatch(completionId);
}
return f;
} catch (Throwable e) {
if (e instanceof IllegalStateException) {
close();
}
if (completionOperation) {
deregisterCompletionLatch(completionId);
}
throw ExceptionUtil.rethrowAllowedTypeFirst(e, CacheException.class);
}
}
protected <T> T getSafely(Future<T> future) {
try {
return future.get();
} catch (Throwable throwable) {
throw ExceptionUtil.rethrow(throwable);
}
}
//region internal base operations
protected <T> ICompletableFuture<T> removeAsyncInternal(K key, V oldValue, boolean hasOldValue, boolean isGet,
boolean withCompletionEvent) {
ensureOpen();
if (hasOldValue) {
validateNotNull(key, oldValue);
CacheProxyUtil.validateConfiguredTypes(cacheConfig, key, oldValue);
} else {
validateNotNull(key);
CacheProxyUtil.validateConfiguredTypes(cacheConfig, key);
}
final Data keyData = toData(key);
final Data oldValueData = oldValue != null ? toData(oldValue) : null;
ClientRequest request;
InMemoryFormat inMemoryFormat = cacheConfig.getInMemoryFormat();
if (isGet) {
request = new CacheGetAndRemoveRequest(nameWithPrefix, keyData, inMemoryFormat);
} else {
request = new CacheRemoveRequest(nameWithPrefix, keyData, oldValueData, inMemoryFormat);
}
ICompletableFuture future;
try {
future = invoke(request, keyData, withCompletionEvent);
invalidateNearCache(keyData);
} catch (Exception e) {
throw ExceptionUtil.rethrow(e);
}
return new DelegatingFuture<T>(future, clientContext.getSerializationService());
}
protected <T> ICompletableFuture<T> replaceAsyncInternal(K key, V oldValue, V newValue, ExpiryPolicy expiryPolicy,
boolean hasOldValue, boolean isGet, boolean withCompletionEvent) {
ensureOpen();
if (hasOldValue) {
validateNotNull(key, oldValue, newValue);
CacheProxyUtil.validateConfiguredTypes(cacheConfig, key, oldValue, newValue);
} else {
validateNotNull(key, newValue);
CacheProxyUtil.validateConfiguredTypes(cacheConfig, key, newValue);
}
final Data keyData = toData(key);
final Data oldValueData = oldValue != null ? toData(oldValue) : null;
final Data newValueData = newValue != null ? toData(newValue) : null;
InMemoryFormat inMemoryFormat = cacheConfig.getInMemoryFormat();
ClientRequest request;
if (isGet) {
request = new CacheGetAndReplaceRequest(nameWithPrefix, keyData, newValueData, expiryPolicy, inMemoryFormat);
} else {
request = new CacheReplaceRequest(nameWithPrefix, keyData, oldValueData, newValueData, expiryPolicy, inMemoryFormat);
}
ICompletableFuture future;
try {
future = invoke(request, keyData, withCompletionEvent);
invalidateNearCache(keyData);
} catch (Exception e) {
throw ExceptionUtil.rethrow(e);
}
return new DelegatingFuture<T>(future, clientContext.getSerializationService());
}
protected <T> ICompletableFuture<T> putAsyncInternal(K key, V value, ExpiryPolicy expiryPolicy, boolean isGet,
boolean withCompletionEvent) {
ensureOpen();
validateNotNull(key, value);
CacheProxyUtil.validateConfiguredTypes(cacheConfig, key, value);
final Data keyData = toData(key);
final Data valueData = toData(value);
InMemoryFormat inMemoryFormat = cacheConfig.getInMemoryFormat();
CachePutRequest request = new CachePutRequest(nameWithPrefix, keyData, valueData, expiryPolicy, isGet, inMemoryFormat);
ICompletableFuture future;
try {
future = invoke(request, keyData, withCompletionEvent);
if (cacheOnUpdate) {
storeInNearCache(keyData, valueData, value);
} else {
invalidateNearCache(keyData);
}
} catch (Exception e) {
throw ExceptionUtil.rethrow(e);
}
return future;
}
protected ICompletableFuture<Boolean> putIfAbsentAsyncInternal(K key, V value, ExpiryPolicy expiryPolicy,
boolean withCompletionEvent) {
ensureOpen();
validateNotNull(key, value);
CacheProxyUtil.validateConfiguredTypes(cacheConfig, key, value);
final Data keyData = toData(key);
final Data valueData = toData(value);
CachePutIfAbsentRequest request = new CachePutIfAbsentRequest(nameWithPrefix, keyData, valueData, expiryPolicy,
cacheConfig.getInMemoryFormat());
ICompletableFuture<Boolean> future;
try {
future = invoke(request, keyData, withCompletionEvent);
if (cacheOnUpdate) {
storeInNearCache(keyData, valueData, value);
} else {
invalidateNearCache(keyData);
}
} catch (Exception e) {
throw ExceptionUtil.rethrow(e);
}
return new DelegatingFuture<Boolean>(future, clientContext.getSerializationService());
}
protected void removeAllInternal(Set<? extends K> keys, boolean isRemoveAll) {
final Set<Data> keysData;
if (keys != null) {
keysData = new HashSet<Data>();
for (K key : keys) {
keysData.add(toData(key));
}
} else {
keysData = null;
}
final int partitionCount = clientContext.getPartitionService().getPartitionCount();
final Integer completionId = registerCompletionLatch(partitionCount);
CacheClearRequest request = new CacheClearRequest(nameWithPrefix, keysData, isRemoveAll, completionId);
try {
final Map<Integer, Object> results = invoke(request);
int completionCount = 0;
for (Object result : results.values()) {
if (result != null && result instanceof CacheClearResponse) {
final Object response = ((CacheClearResponse) result).getResponse();
if (response instanceof Boolean) {
completionCount++;
}
if (response instanceof Throwable) {
throw (Throwable) response;
}
}
}
waitCompletionLatch(completionId, partitionCount - completionCount);
} catch (Throwable t) {
deregisterCompletionLatch(completionId);
throw ExceptionUtil.rethrowAllowedTypeFirst(t, CacheException.class);
}
}
protected void storeInNearCache(Data key, Data valueData, V value) {
if (nearCache != null) {
final Object valueToStore;
if (nearCache.getInMemoryFormat() == InMemoryFormat.OBJECT) {
valueToStore = value != null ? value : valueData;
} else {
valueToStore = valueData != null ? valueData : value;
}
nearCache.put(key, valueToStore);
}
}
protected void invalidateNearCache(Data key) {
if (nearCache != null) {
nearCache.remove(key);
}
}
//endregion internal base operations
protected void addListenerLocally(String regId, CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
if (cacheEntryListenerConfiguration.isSynchronous()) {
syncListenerRegistrations.putIfAbsent(cacheEntryListenerConfiguration, regId);
registerCompletionListener();
} else {
asyncListenerRegistrations.putIfAbsent(cacheEntryListenerConfiguration, regId);
}
}
protected String removeListenerLocally(CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
final ConcurrentMap<CacheEntryListenerConfiguration, String> regs;
if (cacheEntryListenerConfiguration.isSynchronous()) {
regs = syncListenerRegistrations;
} else {
regs = asyncListenerRegistrations;
}
return regs.remove(cacheEntryListenerConfiguration);
}
public void deregisterAllCacheEntryListener(Collection<String> listenerRegistrations) {
for (String regId : listenerRegistrations) {
CacheRemoveEntryListenerRequest removeReq = new CacheRemoveEntryListenerRequest(nameWithPrefix, regId);
clientContext.getListenerService().stopListening(removeReq, regId);
}
}
@Override
protected void closeListeners() {
deregisterAllCacheEntryListener(syncListenerRegistrations.values());
deregisterAllCacheEntryListener(asyncListenerRegistrations.values());
syncListenerRegistrations.clear();
asyncListenerRegistrations.clear();
deregisterCompletionListener();
}
protected void countDownCompletionLatch(int id) {
final CountDownLatch countDownLatch = syncLocks.get(id);
if (countDownLatch == null) {
return;
}
countDownLatch.countDown();
if (countDownLatch.getCount() == 0) {
deregisterCompletionLatch(id);
}
}
protected Integer registerCompletionLatch(int count) {
if (!syncListenerRegistrations.isEmpty()) {
final int id = completionIdCounter.incrementAndGet();
CountDownLatch countDownLatch = new CountDownLatch(count);
syncLocks.put(id, countDownLatch);
return id;
}
return MutableOperation.IGNORE_COMPLETION;
}
protected void deregisterCompletionLatch(Integer countDownLatchId) {
syncLocks.remove(countDownLatchId);
}
protected void waitCompletionLatch(Integer countDownLatchId) {
final CountDownLatch countDownLatch = syncLocks.get(countDownLatchId);
if (countDownLatch != null) {
try {
countDownLatch.await();
} catch (InterruptedException e) {
ExceptionUtil.sneakyThrow(e);
}
}
}
protected void waitCompletionLatch(Integer countDownLatchId, int offset) {
//fix completion count
final CountDownLatch countDownLatch = syncLocks.get(countDownLatchId);
if (countDownLatch != null) {
for (int i = 0; i < offset; i++) {
countDownLatch.countDown();
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
ExceptionUtil.sneakyThrow(e);
}
}
}
protected void registerCompletionListener() {
if (!syncListenerRegistrations.isEmpty() && completionRegistrationId == null) {
synchronized (completionRegistrationMutex) {
if (completionRegistrationId == null) {
final EventHandler<Object> handler = new CacheCompletionEventHandler();
final CacheAddEntryListenerRequest registrationRequest = new CacheAddEntryListenerRequest(nameWithPrefix);
completionRegistrationId = clientContext.getListenerService().listen(registrationRequest, null, handler);
}
}
}
}
protected void deregisterCompletionListener() {
if (syncListenerRegistrations.isEmpty() && completionRegistrationId != null) {
synchronized (completionRegistrationMutex) {
if (completionRegistrationId != null) {
CacheRemoveEntryListenerRequest removeRequest = new CacheRemoveEntryListenerRequest(nameWithPrefix,
completionRegistrationId);
boolean isDeregistered = clientContext.getListenerService()
.stopListening(removeRequest, completionRegistrationId);
if (isDeregistered) {
completionRegistrationId = null;
}
}
}
}
}
protected EventHandler<Object> createHandler(final CacheEventListenerAdaptor adaptor) {
return new EventHandler<Object>() {
@Override
public void handle(Object event) {
adaptor.handleEvent(event);
}
@Override
public void beforeListenerRegister() {
}
@Override
public void onListenerRegister() {
}
};
}
protected ICompletableFuture createCompletedFuture(Object value) {
return new CompletedFuture(clientContext.getSerializationService(), value,
clientContext.getExecutionService().getAsyncExecutor());
}
private final class CacheCompletionEventHandler
implements EventHandler<Object> {
@Override
public void handle(Object eventObject) {
if (eventObject instanceof CacheEventData) {
handleEventData((CacheEventData) eventObject);
} else if (eventObject instanceof CacheEventSet) {
Set<CacheEventData> events = ((CacheEventSet) eventObject).getEvents();
for (CacheEventData event : events) {
handleEventData(event);
}
}
}
private void handleEventData(CacheEventData cacheEventData) {
if (cacheEventData.getCacheEventType() == CacheEventType.COMPLETED) {
Integer completionId = toObject(cacheEventData.getDataValue());
countDownCompletionLatch(completionId);
}
}
@Override
public void beforeListenerRegister() {
}
@Override
public void onListenerRegister() {
}
}
}