You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by sb...@apache.org on 2018/12/19 19:57:36 UTC
[09/15] ignite git commit: IGNITE-9893 IGNITE-1757 IGNITE-10723
Adding hibernate-5.3 module
http://git-wip-us.apache.org/repos/asf/ignite/blob/272858db/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateCacheProxy.java
----------------------------------------------------------------------
diff --git a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateCacheProxy.java b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateCacheProxy.java
index 1752313..f53a14c 100644
--- a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateCacheProxy.java
+++ b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateCacheProxy.java
@@ -24,6 +24,7 @@ import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
+import java.util.function.Supplier;
import javax.cache.Cache;
import javax.cache.expiry.ExpiryPolicy;
import javax.cache.processor.EntryProcessor;
@@ -51,23 +52,30 @@ import org.jetbrains.annotations.Nullable;
* Hibernate cache proxy used to substitute hibernate keys with ignite keys.
*/
public class HibernateCacheProxy implements IgniteInternalCache<Object, Object> {
- /** Delegate. */
- private final IgniteInternalCache<Object, Object> delegate;
+ /** Delegate is lazily loaded which allows for creation of caches after the SPI is bootstrapped */
+ private final Supplier<IgniteInternalCache<Object, Object>> delegate;
/** Transformer. */
private final HibernateKeyTransformer keyTransformer;
+ /** */
+ private String cacheName;
+
/**
+ * @param cacheName Cache name. Should match delegate.get().name(). Needed for lazy loading.
* @param delegate Delegate.
* @param keyTransformer Key keyTransformer.
*/
HibernateCacheProxy(
- IgniteInternalCache<Object, Object> delegate,
+ String cacheName,
+ Supplier<IgniteInternalCache<Object, Object>> delegate,
HibernateKeyTransformer keyTransformer
) {
+ assert cacheName != null;
assert delegate != null;
assert keyTransformer != null;
+ this.cacheName = cacheName;
this.delegate = delegate;
this.keyTransformer = keyTransformer;
}
@@ -81,42 +89,42 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
/** {@inheritDoc} */
@Override public String name() {
- return delegate.name();
+ return cacheName;
}
/** {@inheritDoc} */
@Override public boolean skipStore() {
- return delegate.skipStore();
+ return delegate.get().skipStore();
}
/** {@inheritDoc} */
@Override public IgniteInternalCache setSkipStore(boolean skipStore) {
- return delegate.setSkipStore(skipStore);
+ return delegate.get().setSkipStore(skipStore);
}
/** {@inheritDoc} */
@Override public boolean isEmpty() {
- return delegate.isEmpty();
+ return delegate.get().isEmpty();
}
/** {@inheritDoc} */
@Override public boolean containsKey(Object key) {
- return delegate.containsKey(keyTransformer.transform(key));
+ return delegate.get().containsKey(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> containsKeyAsync(Object key) {
- return delegate.containsKeyAsync(keyTransformer.transform(key));
+ return delegate.get().containsKeyAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public boolean containsKeys(Collection keys) {
- return delegate.containsKey(transform(keys));
+ return delegate.get().containsKey(transform(keys));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> containsKeysAsync(Collection keys) {
- return delegate.containsKeysAsync(transform(keys));
+ return delegate.get().containsKeysAsync(transform(keys));
}
/** {@inheritDoc} */
@@ -124,147 +132,147 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
Object key,
CachePeekMode[] peekModes
) throws IgniteCheckedException {
- return delegate.localPeek(keyTransformer.transform(key), peekModes);
+ return delegate.get().localPeek(keyTransformer.transform(key), peekModes);
}
/** {@inheritDoc} */
@Override public Iterable<Cache.Entry<Object, Object>> localEntries(
CachePeekMode[] peekModes
) throws IgniteCheckedException {
- return delegate.localEntries(peekModes);
+ return delegate.get().localEntries(peekModes);
}
/** {@inheritDoc} */
@Nullable @Override public Object get(Object key) throws IgniteCheckedException {
- return delegate.get(keyTransformer.transform(key));
+ return delegate.get().get(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Nullable @Override public CacheEntry getEntry(Object key) throws IgniteCheckedException {
- return delegate.getEntry(keyTransformer.transform(key));
+ return delegate.get().getEntry(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture getAsync(Object key) {
- return delegate.getAsync(keyTransformer.transform(key));
+ return delegate.get().getAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<CacheEntry<Object, Object>> getEntryAsync(Object key) {
- return delegate.getEntryAsync(keyTransformer.transform(key));
+ return delegate.get().getEntryAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public Map getAll(@Nullable Collection keys) throws IgniteCheckedException {
- return delegate.getAll(transform(keys));
+ return delegate.get().getAll(transform(keys));
}
/** {@inheritDoc} */
@Override public Collection<CacheEntry<Object, Object>> getEntries(
@Nullable Collection keys) throws IgniteCheckedException {
- return delegate.getEntries(transform(keys));
+ return delegate.get().getEntries(transform(keys));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Map<Object, Object>> getAllAsync(@Nullable Collection keys) {
- return delegate.getAllAsync(transform(keys));
+ return delegate.get().getAllAsync(transform(keys));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Collection<CacheEntry<Object,Object>>> getEntriesAsync(
@Nullable Collection keys
) {
- return delegate.getEntriesAsync(transform(keys));
+ return delegate.get().getEntriesAsync(transform(keys));
}
/** {@inheritDoc} */
@Nullable @Override public Object getAndPut(Object key, Object val) throws IgniteCheckedException {
- return delegate.getAndPut(keyTransformer.transform(key), val);
+ return delegate.get().getAndPut(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture getAndPutAsync(Object key, Object val) {
- return delegate.getAndPutAsync(keyTransformer.transform(key), val);
+ return delegate.get().getAndPutAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public boolean put(Object key, Object val) throws IgniteCheckedException {
- return delegate.put(keyTransformer.transform(key), val);
+ return delegate.get().put(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> putAsync(Object key, Object val) {
- return delegate.putAsync(keyTransformer.transform(key), val);
+ return delegate.get().putAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Nullable @Override public Object getAndPutIfAbsent(Object key, Object val) throws IgniteCheckedException {
- return delegate.getAndPutIfAbsent(keyTransformer.transform(key), val);
+ return delegate.get().getAndPutIfAbsent(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture getAndPutIfAbsentAsync(Object key, Object val) {
- return delegate.getAndPutIfAbsentAsync(keyTransformer.transform(key), val);
+ return delegate.get().getAndPutIfAbsentAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public boolean putIfAbsent(Object key, Object val) throws IgniteCheckedException {
- return delegate.putIfAbsent(keyTransformer.transform(key), val);
+ return delegate.get().putIfAbsent(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> putIfAbsentAsync(Object key, Object val) {
- return delegate.putIfAbsentAsync(keyTransformer.transform(key), val);
+ return delegate.get().putIfAbsentAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Nullable @Override public Object getAndReplace(Object key, Object val) throws IgniteCheckedException {
- return delegate.getAndReplace(keyTransformer.transform(key), val);
+ return delegate.get().getAndReplace(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture getAndReplaceAsync(Object key, Object val) {
- return delegate.getAndReplaceAsync(keyTransformer.transform(key), val);
+ return delegate.get().getAndReplaceAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public boolean replace(Object key, Object val) throws IgniteCheckedException {
- return delegate.replace(keyTransformer.transform(key), val);
+ return delegate.get().replace(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> replaceAsync(Object key, Object val) {
- return delegate.replaceAsync(keyTransformer.transform(key), val);
+ return delegate.get().replaceAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public boolean replace(Object key, Object oldVal, Object newVal) throws IgniteCheckedException {
- return delegate.replace(keyTransformer.transform(key), oldVal, newVal);
+ return delegate.get().replace(keyTransformer.transform(key), oldVal, newVal);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> replaceAsync(Object key, Object oldVal, Object newVal) {
- return delegate.replaceAsync(keyTransformer.transform(key), oldVal, newVal);
+ return delegate.get().replaceAsync(keyTransformer.transform(key), oldVal, newVal);
}
/** {@inheritDoc} */
@Override public void putAll(@Nullable Map m) throws IgniteCheckedException {
- delegate.putAll(transform(m));
+ delegate.get().putAll(transform(m));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> putAllAsync(@Nullable Map m) {
- return delegate.putAllAsync(transform(m));
+ return delegate.get().putAllAsync(transform(m));
}
/** {@inheritDoc} */
@Override public Set keySet() {
- return delegate.keySet();
+ return delegate.get().keySet();
}
/** {@inheritDoc} */
@Override public Set<Cache.Entry<Object, Object>> entrySet() {
- return delegate.entrySet();
+ return delegate.get().entrySet();
}
/** {@inheritDoc} */
@@ -272,7 +280,7 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
TransactionConcurrency concurrency,
TransactionIsolation isolation
) {
- return delegate.txStart(concurrency, isolation);
+ return delegate.get().txStart(concurrency, isolation);
}
/** {@inheritDoc} */
@@ -280,7 +288,7 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
TransactionConcurrency concurrency,
TransactionIsolation isolation
) {
- return delegate.txStartEx(concurrency, isolation);
+ return delegate.get().txStartEx(concurrency, isolation);
}
/** {@inheritDoc} */
@@ -290,337 +298,337 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
long timeout,
int txSize
) {
- return delegate.txStart(concurrency, isolation, timeout, txSize);
+ return delegate.get().txStart(concurrency, isolation, timeout, txSize);
}
/** {@inheritDoc} */
@Nullable @Override public GridNearTxLocal tx() {
- return delegate.tx();
+ return delegate.get().tx();
}
/** {@inheritDoc} */
@Override public boolean evict(Object key) {
- return delegate.evict(keyTransformer.transform(key));
+ return delegate.get().evict(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public void evictAll(@Nullable Collection keys) {
- delegate.evictAll(transform(keys));
+ delegate.get().evictAll(transform(keys));
}
/** {@inheritDoc} */
@Override public void clearLocally(boolean srv, boolean near, boolean readers) {
- delegate.clearLocally(srv, near, readers);
+ delegate.get().clearLocally(srv, near, readers);
}
/** {@inheritDoc} */
@Override public boolean clearLocally(Object key) {
- return delegate.clearLocally(keyTransformer.transform(key));
+ return delegate.get().clearLocally(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public void clearLocallyAll(Set keys, boolean srv, boolean near, boolean readers) {
- delegate.clearLocallyAll((Set<?>)transform(keys), srv, near, readers);
+ delegate.get().clearLocallyAll((Set<?>)transform(keys), srv, near, readers);
}
/** {@inheritDoc} */
@Override public void clear(Object key) throws IgniteCheckedException {
- delegate.clear(keyTransformer.transform(key));
+ delegate.get().clear(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public void clearAll(Set keys) throws IgniteCheckedException {
- delegate.clearAll((Set<?>)transform(keys));
+ delegate.get().clearAll((Set<?>)transform(keys));
}
/** {@inheritDoc} */
@Override public void clear() throws IgniteCheckedException {
- delegate.clear();
+ delegate.get().clear();
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> clearAsync() {
- return delegate.clearAsync();
+ return delegate.get().clearAsync();
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> clearAsync(Object key) {
- return delegate.clearAsync(keyTransformer.transform(key));
+ return delegate.get().clearAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> clearAllAsync(Set keys) {
- return delegate.clearAllAsync((Set<?>)transform(keys));
+ return delegate.get().clearAllAsync((Set<?>)transform(keys));
}
/** {@inheritDoc} */
@Nullable @Override public Object getAndRemove(Object key) throws IgniteCheckedException {
- return delegate.getAndRemove(keyTransformer.transform(key));
+ return delegate.get().getAndRemove(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture getAndRemoveAsync(Object key) {
- return delegate.getAndRemoveAsync(keyTransformer.transform(key));
+ return delegate.get().getAndRemoveAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public boolean remove(Object key) throws IgniteCheckedException {
- return delegate.remove(keyTransformer.transform(key));
+ return delegate.get().remove(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> removeAsync(Object key) {
- return delegate.removeAsync(keyTransformer.transform(key));
+ return delegate.get().removeAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public boolean remove(Object key, Object val) throws IgniteCheckedException {
- return delegate.remove(keyTransformer.transform(key), val);
+ return delegate.get().remove(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> removeAsync(Object key, Object val) {
- return delegate.removeAsync(keyTransformer.transform(key), val);
+ return delegate.get().removeAsync(keyTransformer.transform(key), val);
}
/** {@inheritDoc} */
@Override public void removeAll(@Nullable Collection keys) throws IgniteCheckedException {
- delegate.removeAll(transform(keys));
+ delegate.get().removeAll(transform(keys));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> removeAllAsync(@Nullable Collection keys) {
- return delegate.removeAllAsync(transform(keys));
+ return delegate.get().removeAllAsync(transform(keys));
}
/** {@inheritDoc} */
@Override public void removeAll() throws IgniteCheckedException {
- delegate.removeAll();
+ delegate.get().removeAll();
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> removeAllAsync() {
- return delegate.removeAllAsync();
+ return delegate.get().removeAllAsync();
}
/** {@inheritDoc} */
@Override public boolean lock(Object key, long timeout) throws IgniteCheckedException {
- return delegate.lock(keyTransformer.transform(key), timeout);
+ return delegate.get().lock(keyTransformer.transform(key), timeout);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> lockAsync(Object key, long timeout) {
- return delegate.lockAsync(keyTransformer.transform(key), timeout);
+ return delegate.get().lockAsync(keyTransformer.transform(key), timeout);
}
/** {@inheritDoc} */
@Override public boolean lockAll(@Nullable Collection keys, long timeout) throws IgniteCheckedException {
- return delegate.lockAll(transform(keys), timeout);
+ return delegate.get().lockAll(transform(keys), timeout);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Boolean> lockAllAsync(@Nullable Collection keys, long timeout) {
- return delegate.lockAllAsync(transform(keys), timeout);
+ return delegate.get().lockAllAsync(transform(keys), timeout);
}
/** {@inheritDoc} */
@Override public void unlock(Object key) throws IgniteCheckedException {
- delegate.unlock(keyTransformer.transform(key));
+ delegate.get().unlock(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public void unlockAll(@Nullable Collection keys) throws IgniteCheckedException {
- delegate.unlockAll(transform(keys));
+ delegate.get().unlockAll(transform(keys));
}
/** {@inheritDoc} */
@Override public boolean isLocked(Object key) {
- return delegate.isLocked(keyTransformer.transform(key));
+ return delegate.get().isLocked(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public boolean isLockedByThread(Object key) {
- return delegate.isLockedByThread(keyTransformer.transform(key));
+ return delegate.get().isLockedByThread(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public int size() {
- return delegate.size();
+ return delegate.get().size();
}
/** {@inheritDoc} */
@Override public long sizeLong() {
- return delegate.sizeLong();
+ return delegate.get().sizeLong();
}
/** {@inheritDoc} */
@Override public int localSize(CachePeekMode[] peekModes) throws IgniteCheckedException {
- return delegate.localSize(peekModes);
+ return delegate.get().localSize(peekModes);
}
/** {@inheritDoc} */
@Override public long localSizeLong(CachePeekMode[] peekModes) throws IgniteCheckedException {
- return delegate.localSizeLong(peekModes);
+ return delegate.get().localSizeLong(peekModes);
}
/** {@inheritDoc} */
@Override public long localSizeLong(int partition, CachePeekMode[] peekModes) throws IgniteCheckedException {
- return delegate.localSizeLong(partition, peekModes);
+ return delegate.get().localSizeLong(partition, peekModes);
}
/** {@inheritDoc} */
@Override public int size(CachePeekMode[] peekModes) throws IgniteCheckedException {
- return delegate.size(peekModes);
+ return delegate.get().size(peekModes);
}
/** {@inheritDoc} */
@Override public long sizeLong(CachePeekMode[] peekModes) throws IgniteCheckedException {
- return delegate.sizeLong(peekModes);
+ return delegate.get().sizeLong(peekModes);
}
/** {@inheritDoc} */
@Override public long sizeLong(int partition, CachePeekMode[] peekModes) throws IgniteCheckedException {
- return delegate.sizeLong(partition, peekModes);
+ return delegate.get().sizeLong(partition, peekModes);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Integer> sizeAsync(CachePeekMode[] peekModes) {
- return delegate.sizeAsync(peekModes);
+ return delegate.get().sizeAsync(peekModes);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Long> sizeLongAsync(CachePeekMode[] peekModes) {
- return delegate.sizeLongAsync(peekModes);
+ return delegate.get().sizeLongAsync(peekModes);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Long> sizeLongAsync(int partition, CachePeekMode[] peekModes) {
- return delegate.sizeLongAsync(partition, peekModes);
+ return delegate.get().sizeLongAsync(partition, peekModes);
}
/** {@inheritDoc} */
@Override public int nearSize() {
- return delegate.nearSize();
+ return delegate.get().nearSize();
}
/** {@inheritDoc} */
@Override public int primarySize() {
- return delegate.primarySize();
+ return delegate.get().primarySize();
}
/** {@inheritDoc} */
@Override public long primarySizeLong() {
- return delegate.primarySizeLong();
+ return delegate.get().primarySizeLong();
}
/** {@inheritDoc} */
@Override public CacheConfiguration configuration() {
- return delegate.configuration();
+ return delegate.get().configuration();
}
/** {@inheritDoc} */
@Override public Affinity affinity() {
- return delegate.affinity();
+ return delegate.get().affinity();
}
/** {@inheritDoc} */
@Override public CacheMetrics clusterMetrics() {
- return delegate.clusterMetrics();
+ return delegate.get().clusterMetrics();
}
/** {@inheritDoc} */
@Override public CacheMetrics clusterMetrics(ClusterGroup grp) {
- return delegate.clusterMetrics(grp);
+ return delegate.get().clusterMetrics(grp);
}
/** {@inheritDoc} */
@Override public CacheMetrics localMetrics() {
- return delegate.localMetrics();
+ return delegate.get().localMetrics();
}
/** {@inheritDoc} */
@Override public CacheMetricsMXBean clusterMxBean() {
- return delegate.clusterMxBean();
+ return delegate.get().clusterMxBean();
}
/** {@inheritDoc} */
@Override public CacheMetricsMXBean localMxBean() {
- return delegate.localMxBean();
+ return delegate.get().localMxBean();
}
/** {@inheritDoc} */
@Override public long offHeapEntriesCount() {
- return delegate.offHeapEntriesCount();
+ return delegate.get().offHeapEntriesCount();
}
/** {@inheritDoc} */
@Override public long offHeapAllocatedSize() {
- return delegate.offHeapAllocatedSize();
+ return delegate.get().offHeapAllocatedSize();
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> rebalance() {
- return delegate.rebalance();
+ return delegate.get().rebalance();
}
/** {@inheritDoc} */
@Override public IgniteInternalCache forSubjectId(UUID subjId) {
- return delegate.forSubjectId(subjId);
+ return delegate.get().forSubjectId(subjId);
}
/** {@inheritDoc} */
@Nullable @Override public Object getForcePrimary(Object key) throws IgniteCheckedException {
- return delegate.getForcePrimary(keyTransformer.transform(key));
+ return delegate.get().getForcePrimary(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture getForcePrimaryAsync(Object key) {
- return delegate.getForcePrimaryAsync(keyTransformer.transform(key));
+ return delegate.get().getForcePrimaryAsync(keyTransformer.transform(key));
}
/** {@inheritDoc} */
@Override public Map getAllOutTx(Set keys) throws IgniteCheckedException {
- return delegate.getAllOutTx((Set<?>)transform(keys));
+ return delegate.get().getAllOutTx((Set<?>)transform(keys));
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Map<Object, Object>> getAllOutTxAsync(Set keys) {
- return delegate.getAllOutTxAsync((Set<?>)transform(keys));
+ return delegate.get().getAllOutTxAsync((Set<?>)transform(keys));
}
/** {@inheritDoc} */
@Override public boolean isIgfsDataCache() {
- return delegate.isIgfsDataCache();
+ return delegate.get().isIgfsDataCache();
}
/** {@inheritDoc} */
@Override public long igfsDataSpaceUsed() {
- return delegate.igfsDataSpaceUsed();
+ return delegate.get().igfsDataSpaceUsed();
}
/** {@inheritDoc} */
@Nullable @Override public ExpiryPolicy expiry() {
- return delegate.expiry();
+ return delegate.get().expiry();
}
/** {@inheritDoc} */
@Override public IgniteInternalCache withExpiryPolicy(ExpiryPolicy plc) {
- return delegate.withExpiryPolicy(plc);
+ return delegate.get().withExpiryPolicy(plc);
}
/** {@inheritDoc} */
@Override public IgniteInternalCache withNoRetries() {
- return delegate.withNoRetries();
+ return delegate.get().withNoRetries();
}
/** {@inheritDoc} */
@Override public <K1, V1> IgniteInternalCache<K1, V1> withAllowAtomicOpsInTx() {
- return delegate.withAllowAtomicOpsInTx();
+ return delegate.get().withAllowAtomicOpsInTx();
}
/** {@inheritDoc} */
@Override public GridCacheContext context() {
- return delegate.context();
+ return delegate.get().context();
}
/** {@inheritDoc} */
@@ -628,7 +636,7 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
@Nullable IgniteBiPredicate p,
@Nullable Object... args
) throws IgniteCheckedException {
- delegate.localLoadCache(p, args);
+ delegate.get().localLoadCache(p, args);
}
/** {@inheritDoc} */
@@ -636,27 +644,27 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
@Nullable IgniteBiPredicate p,
@Nullable Object... args
) {
- return delegate.localLoadCacheAsync(p, args);
+ return delegate.get().localLoadCacheAsync(p, args);
}
/** {@inheritDoc} */
@Override public Collection<Integer> lostPartitions() {
- return delegate.lostPartitions();
+ return delegate.get().lostPartitions();
}
/** {@inheritDoc} */
@Override public void preloadPartition(int part) throws IgniteCheckedException {
- delegate.preloadPartition(part);
+ delegate.get().preloadPartition(part);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> preloadPartitionAsync(int part) throws IgniteCheckedException {
- return delegate.preloadPartitionAsync(part);
+ return delegate.get().preloadPartitionAsync(part);
}
/** {@inheritDoc} */
@Override public boolean localPreloadPartition(int part) throws IgniteCheckedException {
- return delegate.localPreloadPartition(part);
+ return delegate.get().localPreloadPartition(part);
}
/** {@inheritDoc} */
@@ -666,27 +674,27 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
EntryProcessor entryProcessor,
Object... args
) throws IgniteCheckedException {
- return delegate.invoke(topVer, key, entryProcessor, args);
+ return delegate.get().invoke(topVer, key, entryProcessor, args);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Map> invokeAllAsync(Map map, Object... args) {
- return delegate.invokeAllAsync(map, args);
+ return delegate.get().invokeAllAsync(map, args);
}
/** {@inheritDoc} */
@Override public Map invokeAll(Map map, Object... args) throws IgniteCheckedException {
- return delegate.invokeAll(map, args);
+ return delegate.get().invokeAll(map, args);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<Map> invokeAllAsync(Set keys, EntryProcessor entryProcessor, Object... args) {
- return delegate.invokeAllAsync((Set<?>)transform(keys), entryProcessor, args);
+ return delegate.get().invokeAllAsync((Set<?>)transform(keys), entryProcessor, args);
}
/** {@inheritDoc} */
@Override public Map invokeAll(Set keys, EntryProcessor entryProcessor, Object... args) throws IgniteCheckedException {
- return delegate.invokeAll((Set<?>)transform(keys), entryProcessor, args);
+ return delegate.get().invokeAll((Set<?>)transform(keys), entryProcessor, args);
}
/** {@inheritDoc} */
@@ -695,7 +703,7 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
EntryProcessor entryProcessor,
Object... args
) {
- return delegate.invokeAsync(keyTransformer.transform(key), entryProcessor, args);
+ return delegate.get().invokeAsync(keyTransformer.transform(key), entryProcessor, args);
}
/** {@inheritDoc} */
@@ -704,7 +712,7 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
EntryProcessor entryProcessor,
Object... args
) throws IgniteCheckedException {
- return delegate.invoke(keyTransformer.transform(key), entryProcessor, args);
+ return delegate.get().invoke(keyTransformer.transform(key), entryProcessor, args);
}
/** {@inheritDoc} */
@@ -712,42 +720,42 @@ public class HibernateCacheProxy implements IgniteInternalCache<Object, Object>
boolean keepBinary,
@Nullable IgniteBiPredicate p
) throws IgniteCheckedException {
- return delegate.scanIterator(keepBinary, p);
+ return delegate.get().scanIterator(keepBinary, p);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> removeAllConflictAsync(Map drMap) throws IgniteCheckedException {
- return delegate.removeAllConflictAsync(drMap);
+ return delegate.get().removeAllConflictAsync(drMap);
}
/** {@inheritDoc} */
@Override public void removeAllConflict(Map drMap) throws IgniteCheckedException {
- delegate.removeAllConflictAsync(drMap);
+ delegate.get().removeAllConflictAsync(drMap);
}
/** {@inheritDoc} */
@Override public IgniteInternalFuture<?> putAllConflictAsync(Map drMap) throws IgniteCheckedException {
- return delegate.putAllConflictAsync(drMap);
+ return delegate.get().putAllConflictAsync(drMap);
}
/** {@inheritDoc} */
@Override public void putAllConflict(Map drMap) throws IgniteCheckedException {
- delegate.putAllConflict(drMap);
+ delegate.get().putAllConflict(drMap);
}
/** {@inheritDoc} */
@Override public IgniteInternalCache keepBinary() {
- return delegate.keepBinary();
+ return delegate.get().keepBinary();
}
/** {@inheritDoc} */
@Override public IgniteInternalCache cache() {
- return delegate.cache();
+ return delegate.get().cache();
}
/** {@inheritDoc} */
@Override public Iterator iterator() {
- return delegate.iterator();
+ return delegate.get().iterator();
}
/**
http://git-wip-us.apache.org/repos/asf/ignite/blob/272858db/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateNonStrictAccessStrategy.java
----------------------------------------------------------------------
diff --git a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateNonStrictAccessStrategy.java b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateNonStrictAccessStrategy.java
index 06c6f3d..b7d27fe 100644
--- a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateNonStrictAccessStrategy.java
+++ b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateNonStrictAccessStrategy.java
@@ -109,6 +109,9 @@ public class HibernateNonStrictAccessStrategy extends HibernateAccessStrategyAda
@Override public boolean afterUpdate(Object key, Object val) {
WriteContext ctx = writeCtx.get();
+ if (log.isDebugEnabled())
+ log.debug("Put after update [cache=" + cache.name() + ", key=" + key + ", val=" + val + ']');
+
if (ctx != null) {
ctx.updated(key, val);
@@ -127,6 +130,9 @@ public class HibernateNonStrictAccessStrategy extends HibernateAccessStrategyAda
/** {@inheritDoc} */
@Override public boolean afterInsert(Object key, Object val) {
+ if (log.isDebugEnabled())
+ log.debug("Put after insert [cache=" + cache.name() + ", key=" + key + ", val=" + val + ']');
+
try {
cache.put(key, val);
@@ -227,4 +233,4 @@ public class HibernateNonStrictAccessStrategy extends HibernateAccessStrategyAda
return S.toString(WriteContext.class, this);
}
}
-}
\ No newline at end of file
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/272858db/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadOnlyAccessStrategy.java
----------------------------------------------------------------------
diff --git a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadOnlyAccessStrategy.java b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadOnlyAccessStrategy.java
index a0957fd..07570ba 100644
--- a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadOnlyAccessStrategy.java
+++ b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadOnlyAccessStrategy.java
@@ -55,7 +55,8 @@ public class HibernateReadOnlyAccessStrategy extends HibernateAccessStrategyAdap
* @param cache Cache.
* @param eConverter Exception converter.
*/
- public HibernateReadOnlyAccessStrategy(Ignite ignite,
+ public HibernateReadOnlyAccessStrategy(
+ Ignite ignite,
HibernateCacheProxy cache,
HibernateExceptionConverter eConverter) {
super(ignite, cache, eConverter);
@@ -68,6 +69,9 @@ public class HibernateReadOnlyAccessStrategy extends HibernateAccessStrategyAdap
/** {@inheritDoc} */
@Override public boolean afterInsert(Object key, Object val) {
+ if (log.isDebugEnabled())
+ log.debug("Put [cache=" + cache.name() + ", key=" + key + ']');
+
try {
cache.put(key, val);
@@ -102,4 +106,4 @@ public class HibernateReadOnlyAccessStrategy extends HibernateAccessStrategyAdap
@Override public boolean afterUpdate(Object key, Object val) {
throw new UnsupportedOperationException("Updates are not supported for read-only access strategy.");
}
-}
\ No newline at end of file
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/272858db/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadWriteAccessStrategy.java
----------------------------------------------------------------------
diff --git a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadWriteAccessStrategy.java b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadWriteAccessStrategy.java
index 491553d..c3fba41 100644
--- a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadWriteAccessStrategy.java
+++ b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateReadWriteAccessStrategy.java
@@ -65,7 +65,8 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
* @param txCtx Thread local instance used to track updates done during one Hibernate transaction.
* @param eConverter Exception converter.
*/
- protected HibernateReadWriteAccessStrategy(Ignite ignite,
+ protected HibernateReadWriteAccessStrategy(
+ Ignite ignite,
HibernateCacheProxy cache,
ThreadLocal txCtx,
HibernateExceptionConverter eConverter) {
@@ -78,12 +79,14 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
@Override public Object get(Object key) {
boolean success = false;
+ Object val = null;
+
try {
- Object o = cache.get(key);
+ val = cache.get(key);
success = true;
- return o;
+ return val;
}
catch (IgniteCheckedException e) {
throw convertException(e);
@@ -91,6 +94,11 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled()) {
+ log.debug("Get [cache=" + cache.name() + ", key=" + key + ", val=" + val +
+ ", success=" + success + ']');
+ }
}
}
@@ -109,6 +117,11 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled()) {
+ log.debug("Put from load [cache=" + cache.name() + ", key=" + key + ", val=" + val +
+ ", success=" + success + ']');
+ }
}
}
@@ -134,6 +147,9 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled())
+ log.debug("Lock [cache=" + cache.name() + ", key=" + key + ", success=" + success + ']');
}
}
@@ -155,6 +171,9 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled())
+ log.debug("Unlock [cache=" + cache.name() + ", key=" + key + ", success=" + success + ']');
}
}
@@ -189,6 +208,11 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled()) {
+ log.debug("Put after update [cache=" + cache.name() + ", key=" + key + ", val=" + val +
+ ", success=" + success + ']');
+ }
}
}
@@ -214,6 +238,11 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled()) {
+ log.debug("Put after insert [cache=" + cache.name() + ", key=" + key + ", val=" + val +
+ ", success=" + success + ']');
+ }
}
}
@@ -235,6 +264,9 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
finally {
if (!success)
rollbackCurrentTx();
+
+ if (log.isDebugEnabled())
+ log.debug("Remove [cache=" + cache.name() + ", key=" + key + ", success=" + success + ']');
}
}
@@ -323,4 +355,4 @@ public class HibernateReadWriteAccessStrategy extends HibernateAccessStrategyAda
return locked.isEmpty();
}
}
-}
\ No newline at end of file
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/272858db/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateTransactionalAccessStrategy.java
----------------------------------------------------------------------
diff --git a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateTransactionalAccessStrategy.java b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateTransactionalAccessStrategy.java
index 6f4935b..259c6a8 100644
--- a/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateTransactionalAccessStrategy.java
+++ b/modules/hibernate-core/src/main/java/org/apache/ignite/cache/hibernate/HibernateTransactionalAccessStrategy.java
@@ -68,7 +68,12 @@ public class HibernateTransactionalAccessStrategy extends HibernateAccessStrateg
/** {@inheritDoc} */
@Nullable @Override public Object get(Object key) {
try {
- return cache.get(key);
+ Object val = cache.get(key);
+
+ if (log.isDebugEnabled())
+ log.debug("Get [cache=" + cache.name() + ", key=" + key + ", val=" + val + ']');
+
+ return val;
}
catch (IgniteCheckedException e) {
throw convertException(e);
@@ -79,6 +84,9 @@ public class HibernateTransactionalAccessStrategy extends HibernateAccessStrateg
@Override public void putFromLoad(Object key, Object val) {
try {
cache.put(key, val);
+
+ if (log.isDebugEnabled())
+ log.debug("Put [cache=" + cache.name() + ", key=" + key + ", val=" + val + ']');
}
catch (IgniteCheckedException e) {
throw convertException(e);
@@ -98,9 +106,12 @@ public class HibernateTransactionalAccessStrategy extends HibernateAccessStrateg
/** {@inheritDoc} */
@Override public boolean update(Object key, Object val) {
try {
- cache.put(key, val);
+ boolean res = cache.put(key, val);
- return true;
+ if (log.isDebugEnabled())
+ log.debug("Update [cache=" + cache.name() + ", key=" + key + ", val=" + val + ", res=" + res + ']');
+
+ return res;
}
catch (IgniteCheckedException e) {
throw convertException(e);
@@ -115,9 +126,12 @@ public class HibernateTransactionalAccessStrategy extends HibernateAccessStrateg
/** {@inheritDoc} */
@Override public boolean insert(Object key, Object val) {
try {
- cache.put(key, val);
+ boolean res = cache.put(key, val);
+
+ if (log.isDebugEnabled())
+ log.debug("Insert [cache=" + cache.name() + ", key=" + key + ", val=" + val + ", res=" + res + ']');
- return true;
+ return res;
}
catch (IgniteCheckedException e) {
throw convertException(e);
@@ -138,4 +152,4 @@ public class HibernateTransactionalAccessStrategy extends HibernateAccessStrateg
throw convertException(e);
}
}
-}
\ No newline at end of file
+}
http://git-wip-us.apache.org/repos/asf/ignite/blob/272858db/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 2bcdf16..fc71761 100644
--- a/pom.xml
+++ b/pom.xml
@@ -108,6 +108,7 @@
<module>modules/geospatial</module>
<module>modules/hibernate-4.2</module>
<module>modules/hibernate-5.1</module>
+ <module>modules/hibernate-5.3</module>
<module>modules/schedule</module>
<module>modules/web-console/web-agent</module>
<module>modules/yardstick</module>
@@ -245,6 +246,7 @@
<modules>
<module>modules/hibernate-4.2</module>
<module>modules/hibernate-5.1</module>
+ <module>modules/hibernate-5.3</module>
<module>modules/geospatial</module>
<module>modules/schedule</module>
</modules>