Repository: ignite Updated Branches: refs/heads/master 9a1a830a8 -> 272858dbc
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>
