ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [68/79] [abbrv] incubator-ignite git commit: IGNITE-49 merged from sprint-1 into ignite-49
Date Fri, 23 Jan 2015 16:07:07 GMT
http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
index 0000000,44bdc3f..78ea95a
mode 000000,100644..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheProxyImpl.java
@@@ -1,0 -1,1903 +1,1903 @@@
+ /*
+  * Licensed to the Apache Software Foundation (ASF) under one or more
+  * contributor license agreements.  See the NOTICE file distributed with
+  * this work for additional information regarding copyright ownership.
+  * The ASF licenses this file to You 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 org.apache.ignite.internal.processors.cache;
+ 
+ import org.apache.ignite.*;
+ import org.apache.ignite.cache.*;
+ import org.apache.ignite.cache.affinity.*;
+ import org.apache.ignite.cache.datastructures.*;
+ import org.apache.ignite.cache.query.*;
+ import org.apache.ignite.cluster.*;
+ import org.apache.ignite.lang.*;
+ import org.apache.ignite.transactions.*;
+ import org.apache.ignite.internal.processors.cache.affinity.*;
+ import org.apache.ignite.internal.processors.cache.datastructures.*;
+ import org.apache.ignite.internal.processors.cache.dr.*;
+ import org.apache.ignite.internal.processors.cache.query.*;
+ import org.apache.ignite.internal.util.tostring.*;
+ import org.apache.ignite.internal.util.typedef.internal.*;
+ import org.jetbrains.annotations.*;
+ 
+ import javax.cache.expiry.*;
+ import javax.cache.processor.*;
+ import java.io.*;
+ import java.util.*;
+ import java.util.concurrent.*;
+ 
+ /**
+  * Cache proxy.
+  */
+ public class GridCacheProxyImpl<K, V> implements GridCacheProxy<K, V>, Externalizable {
+     /** */
+     private static final long serialVersionUID = 0L;
+ 
+     /** Context. */
+     private GridCacheContext<K, V> ctx;
+ 
+     /** Gateway. */
+     private GridCacheGateway<K, V> gate;
+ 
+     /** Cache. */
+     @GridToStringInclude
+     private GridCacheAdapter<K, V> cache;
+ 
+     /** Delegate object. */
+     @GridToStringExclude
+     private GridCacheProjectionEx<K, V> delegate;
+ 
+     /** Projection. */
+     @GridToStringExclude
+     private GridCacheProjectionImpl<K, V> prj;
+ 
+     /** Cache queries. */
+     private CacheQueries<K, V> qry;
+ 
+     /** Data structures. */
+     private CacheDataStructures dataStructures;
+ 
+     /** Affinity. */
+     private CacheAffinity<K> aff;
+ 
+     /**
+      * Empty constructor required for {@link Externalizable}.
+      */
+     public GridCacheProxyImpl() {
+         // No-op.
+     }
+ 
+     /**
+      * @param ctx Context.
+      * @param delegate Delegate object.
+      * @param prj Optional projection which will be passed to gateway.
+      */
+     public GridCacheProxyImpl(GridCacheContext<K, V> ctx, GridCacheProjectionEx<K, V> delegate,
+         @Nullable GridCacheProjectionImpl<K, V> prj) {
+         assert ctx != null;
+         assert delegate != null;
+ 
+         this.ctx = ctx;
+         this.delegate = delegate;
+         this.prj = prj;
+ 
+         gate = ctx.gate();
+         cache = ctx.cache();
+ 
+         qry = new GridCacheQueriesProxy<>(ctx, prj, (GridCacheQueriesEx<K, V>)delegate.queries());
+         dataStructures = new GridCacheDataStructuresProxy<>(ctx, ctx.cache().dataStructures());
+         aff = new GridCacheAffinityProxy<>(ctx, ctx.cache().affinity());
+     }
+ 
+     /**
+      * @return Cache context.
+      */
+     public GridCacheContext context() {
+         return ctx;
+     }
+ 
+     /**
+      * @return Proxy delegate.
+      */
+     public GridCacheProjectionEx<K, V> delegate() {
+         return delegate;
+     }
+ 
+     /**
+      * @return Gateway projection.
+      */
+     public GridCacheProjectionImpl<K, V> gateProjection() {
+         return prj;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String name() {
+         return cache.name();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public ClusterGroup gridProjection() {
+         return cache.gridProjection();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <K1, V1> GridCache<K1, V1> cache() {
+         return cache.cache();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheQueries<K, V> queries() {
+         return qry;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheAffinity<K> affinity() {
+         return aff;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheDataStructures dataStructures() {
+         return dataStructures;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheConfiguration configuration() {
+         return cache.configuration();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void txSynchronize(@Nullable IgniteTxSynchronization syncs) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             cache.txSynchronize(syncs);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void txUnsynchronize(@Nullable IgniteTxSynchronization syncs) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             cache.txUnsynchronize(syncs);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Collection<IgniteTxSynchronization> txSynchronizations() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.txSynchronizations();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheMetrics metrics() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.metrics();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
++    @Override public IgniteCacheMxBean mxBean() {
++        GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
++
++        try {
++            return cache.mxBean();
++        }
++        finally {
++            gate.leave(prev);
++        }
++    }
++
++    /** {@inheritDoc} */
+     @Override public long overflowSize() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.overflowSize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void loadCache(IgniteBiPredicate<K, V> p, long ttl, @Nullable Object[] args) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             cache.loadCache(p, ttl, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> loadCacheAsync(IgniteBiPredicate<K, V> p, long ttl, @Nullable Object[] args) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.loadCacheAsync(p, ttl, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public CacheEntry<K, V> randomEntry() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.randomEntry();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public ConcurrentMap<K, V> toMap() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.toMap();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<CacheFlag> flags() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.flags();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgnitePredicate<CacheEntry<K, V>> predicate() {
+         return delegate.predicate();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public GridCacheProjectionEx<K, V> forSubjectId(UUID subjId) {
+         return delegate.forSubjectId(subjId);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <K1, V1> CacheProjection<K1, V1> projection(
+         Class<? super K1> keyType,
+         Class<? super V1> valType
+     ) {
+         return delegate.projection(keyType, valType);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheProjection<K, V> projection(@Nullable IgniteBiPredicate<K, V> p) {
+         return delegate.projection(p);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheProjection<K, V> projection(
+         @Nullable IgnitePredicate<CacheEntry<K, V>> filter) {
+         return delegate.projection(filter);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheProjection<K, V> flagsOn(@Nullable CacheFlag[] flags) {
+         return delegate.flagsOn(flags);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public CacheProjection<K, V> flagsOff(@Nullable CacheFlag[] flags) {
+         return delegate.flagsOff(flags);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <K1, V1> CacheProjection<K1, V1> keepPortable() {
+         return delegate.keepPortable();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isEmpty() {
+         return delegate.isEmpty();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean containsKey(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.containsKey(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean containsValue(V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.containsValue(val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void forEach(IgniteInClosure<CacheEntry<K, V>> vis) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.forEach(vis);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean forAll(IgnitePredicate<CacheEntry<K, V>> vis) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.forAll(vis);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V reload(K key)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.reload(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> reloadAsync(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.reloadAsync(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void reloadAll() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.reloadAll();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> reloadAllAsync() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.reloadAllAsync();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void reloadAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.reloadAll(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> reloadAllAsync(@Nullable Collection<? extends K> keys) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.reloadAllAsync(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V get(K key) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.get(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public V get(K key, @Nullable GridCacheEntryEx<K, V> entry, boolean deserializePortable,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.get(key, entry, deserializePortable, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> getAsync(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getAsync(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public V getForcePrimary(K key) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getForcePrimary(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> getForcePrimaryAsync(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getForcePrimaryAsync(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public Map<K, V> getAllOutTx(List<K> keys) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getAllOutTx(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Map<K, V>> getAllOutTxAsync(List<K> keys) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getAllOutTxAsync(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isGgfsDataCache() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.isGgfsDataCache();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long ggfsDataSpaceUsed() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.ggfsDataSpaceUsed();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long ggfsDataSpaceMax() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.ggfsDataSpaceMax();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isMongoDataCache() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.isMongoDataCache();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isMongoMetaCache() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.isMongoMetaCache();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Map<K, V> getAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getAll(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Map<K, V>> getAllAsync(@Nullable Collection<? extends K> keys) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.getAllAsync(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V put(K key, V val, @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.put(key, val, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public V put(K key, V val, @Nullable GridCacheEntryEx<K, V> entry, long ttl,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.put(key, val, entry, ttl, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> putAsync(K key, V val,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putAsync(key, val, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> putAsync(K key, V val, @Nullable GridCacheEntryEx<K, V> entry, long ttl,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putAsync(key, val, entry, ttl, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean putx(K key, V val, @Nullable GridCacheEntryEx<K, V> entry, long ttl,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putx(key, val, entry, ttl, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean putx(K key, V val, @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putx(key, val, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void putAllDr(Map<? extends K, GridCacheDrInfo<V>> drMap) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.putAllDr(drMap);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> putAllDrAsync(Map<? extends K, GridCacheDrInfo<V>> drMap)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putAllDrAsync(drMap);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <T> EntryProcessorResult<T> invoke(K key,
+         EntryProcessor<K, V, T> entryProcessor,
+         Object... args) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.invoke(key, entryProcessor, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <T> IgniteFuture<EntryProcessorResult<T>> invokeAsync(K key,
+         EntryProcessor<K, V, T> entryProcessor,
+         Object... args) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.invokeAsync(key, entryProcessor, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <T> Map<K, EntryProcessorResult<T>> invokeAll(Set<? extends K> keys,
+         EntryProcessor<K, V, T> entryProcessor,
+         Object... args) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.invokeAll(keys, entryProcessor, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <T> IgniteFuture<Map<K, EntryProcessorResult<T>>> invokeAllAsync(
+         Set<? extends K> keys,
+         EntryProcessor<K, V, T> entryProcessor,
+         Object... args) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.invokeAllAsync(keys, entryProcessor, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <T> Map<K, EntryProcessorResult<T>> invokeAll(
+         Map<? extends K, ? extends EntryProcessor<K, V, T>> map,
+         Object... args) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.invokeAll(map, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public <T> IgniteFuture<Map<K, EntryProcessorResult<T>>> invokeAllAsync(
+         Map<? extends K, ? extends EntryProcessor<K, V, T>> map,
+         Object... args) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.invokeAllAsync(map, args);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> putxAsync(K key, V val,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putxAsync(key, val, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> putxAsync(K key,
+         V val,
+         @Nullable GridCacheEntryEx<K, V> entry,
+         long ttl,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putxAsync(key, val, entry, ttl, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V putIfAbsent(K key, V val) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putIfAbsent(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> putIfAbsentAsync(K key, V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putIfAbsentAsync(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean putxIfAbsent(K key, V val) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putxIfAbsent(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> putxIfAbsentAsync(K key, V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putxIfAbsentAsync(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V replace(K key, V val) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replace(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> replaceAsync(K key, V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replaceAsync(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean replacex(K key, V val) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replacex(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> replacexAsync(K key, V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replacexAsync(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean replace(K key, V oldVal, V newVal) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replace(key, oldVal, newVal);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> replaceAsync(K key, V oldVal, V newVal) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replaceAsync(key, oldVal, newVal);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void putAll(@Nullable Map<? extends K, ? extends V> m,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.putAll(m, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> putAllAsync(@Nullable Map<? extends K, ? extends V> m,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.putAllAsync(m, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<K> keySet() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.keySet();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<K> primaryKeySet() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.primaryKeySet();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Collection<V> values() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.values();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Collection<V> primaryValues() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.primaryValues();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<CacheEntry<K, V>> entrySet() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.entrySet();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<CacheEntry<K, V>> entrySet(int part) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.entrySet(part);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<CacheEntry<K, V>> entrySetx(IgnitePredicate<CacheEntry<K, V>>... filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.entrySetx(filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<CacheEntry<K, V>> primaryEntrySetx(IgnitePredicate<CacheEntry<K, V>>... filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.primaryEntrySetx(filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Set<CacheEntry<K, V>> primaryEntrySet() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.primaryEntrySet();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteTx txStart() throws IllegalStateException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.txStart();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteTx txStart(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.txStart(concurrency, isolation);
+         }
+         finally {
+             gate.leave(prev);
+         }
+ 
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteTx txStart(IgniteTxConcurrency concurrency, IgniteTxIsolation isolation,
+         long timeout, int txSize) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.txStart(concurrency, isolation, timeout, txSize);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteTx txStartAffinity(Object affinityKey, IgniteTxConcurrency concurrency,
+         IgniteTxIsolation isolation, long timeout, int txSize) throws IllegalStateException, IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.txStartAffinity(affinityKey, concurrency, isolation, timeout, txSize);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteTx txStartPartition(int partId, IgniteTxConcurrency concurrency,
+         IgniteTxIsolation isolation, long timeout, int txSize) throws IllegalStateException, IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.txStartPartition(partId, concurrency, isolation, timeout, txSize);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteTx tx() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.tx();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V peek(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.peek(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V peek(K key, @Nullable Collection<GridCachePeekMode> modes) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.peek(key, modes);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public CacheEntry<K, V> entry(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.entry(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean evict(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.evict(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void evictAll(@Nullable Collection<? extends K> keys) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.evictAll(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void evictAll() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.evictAll();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void clearAll() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.clearAll();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void globalClearAll() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.globalClearAll(0);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void globalClearAll(long timeout) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.globalClearAll(timeout);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean clear(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.clear(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean compact(K key)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.compact(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void compactAll() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.compactAll();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V remove(K key, @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.remove(key, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public V remove(K key, @Nullable GridCacheEntryEx<K, V> entry,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.remove(key, entry, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> removeAsync(K key, IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removeAsync(key, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<V> removeAsync(K key, @Nullable GridCacheEntryEx<K, V> entry,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removeAsync(key, entry, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean removex(K key, @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removex(key, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void removeAllDr(Map<? extends K, GridCacheVersion> drMap) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.removeAllDr(drMap);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> removeAllDrAsync(Map<? extends K, GridCacheVersion> drMap) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removeAllDrAsync(drMap);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean removex(K key, @Nullable GridCacheEntryEx<K, V> entry,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removex(key, entry, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> removexAsync(K key,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removexAsync(key, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> removexAsync(K key, @Nullable GridCacheEntryEx<K, V> entry,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>... filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removexAsync(key, entry, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<GridCacheReturn<V>> replacexAsync(K key, V oldVal, V newVal) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replacexAsync(key, oldVal, newVal);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public GridCacheReturn<V> replacex(K key, V oldVal, V newVal) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.replacex(key, oldVal, newVal);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public GridCacheReturn<V> removex(K key, V val) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removex(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<GridCacheReturn<V>> removexAsync(K key, V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removexAsync(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean remove(K key, V val) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.remove(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> removeAsync(K key, V val) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removeAsync(key, val);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void removeAll(@Nullable Collection<? extends K> keys,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.removeAll(keys, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> removeAllAsync(@Nullable Collection<? extends K> keys,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removeAllAsync(keys, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void removeAll(@Nullable IgnitePredicate<CacheEntry<K, V>>[] filter)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.removeAll(filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> removeAllAsync(@Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.removeAllAsync(filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean lock(K key, long timeout, @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter)
+         throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.lock(key, timeout, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> lockAsync(K key, long timeout,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.lockAsync(key, timeout, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean lockAll(@Nullable Collection<? extends K> keys, long timeout,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.lockAll(keys, timeout, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<Boolean> lockAllAsync(@Nullable Collection<? extends K> keys, long timeout,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.lockAllAsync(keys, timeout, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void unlock(K key, IgnitePredicate<CacheEntry<K, V>>[] filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.unlock(key, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void unlockAll(@Nullable Collection<? extends K> keys,
+         @Nullable IgnitePredicate<CacheEntry<K, V>>[] filter) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.unlockAll(keys, filter);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isLocked(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.isLocked(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isLockedByThread(K key) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.isLockedByThread(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public int size() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.size();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public int globalSize() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.globalSize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public int nearSize() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.nearSize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public int primarySize() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.primarySize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public int globalPrimarySize() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.globalPrimarySize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Nullable @Override public V promote(K key) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.promote(key);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void promoteAll(@Nullable Collection<? extends K> keys) throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             delegate.promoteAll(keys);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Iterator<Map.Entry<K, V>> swapIterator() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.swapIterator();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Iterator<Map.Entry<K, V>> offHeapIterator() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.offHeapIterator();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long offHeapEntriesCount() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.offHeapEntriesCount();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long offHeapAllocatedSize() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.offHeapAllocatedSize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long swapSize() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.swapSize();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public long swapKeys() throws IgniteCheckedException {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.swapKeys();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public Iterator<CacheEntry<K, V>> iterator() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return delegate.iterator();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public IgniteFuture<?> forceRepartition() {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             return cache.forceRepartition();
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void writeExternal(ObjectOutput out) throws IOException {
+         out.writeObject(ctx);
+         out.writeObject(delegate);
+         out.writeObject(prj);
+     }
+ 
+     /** {@inheritDoc} */
+     @SuppressWarnings({"unchecked"})
+     @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+         ctx = (GridCacheContext<K, V>)in.readObject();
+         delegate = (GridCacheProjectionEx<K, V>)in.readObject();
+         prj = (GridCacheProjectionImpl<K, V>)in.readObject();
+ 
+         gate = ctx.gate();
+         cache = ctx.cache();
+ 
+         gate = ctx.gate();
+         cache = ctx.cache();
+ 
+         qry = new GridCacheQueriesProxy<>(ctx, prj, (GridCacheQueriesEx<K, V>)delegate.queries());
+         dataStructures = new GridCacheDataStructuresProxy<>(ctx, ctx.cache().dataStructures());
+         aff = new GridCacheAffinityProxy<>(ctx, ctx.cache().affinity());
+     }
+ 
+     /** {@inheritDoc} */
 -    @Override public void resetMetrics() {
 -        GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
 -
 -        try {
 -            cache.resetMetrics();
 -        }
 -        finally {
 -            gate.leave(prev);
 -        }
 -    }
 -
 -    /** {@inheritDoc} */
+     @Nullable @Override public ExpiryPolicy expiry() {
+         return delegate.expiry();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public GridCacheProjectionEx<K, V> withExpiryPolicy(ExpiryPolicy plc) {
+         GridCacheProjectionImpl<K, V> prev = gate.enter(prj);
+ 
+         try {
+             GridCacheProjectionEx<K, V> prj0 = prj != null ? prj.withExpiryPolicy(plc) : delegate.withExpiryPolicy(plc);
+ 
+             return new GridCacheProxyImpl<>(ctx, prj0, (GridCacheProjectionImpl<K, V>)prj0);
+         }
+         finally {
+             gate.leave(prev);
+         }
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String toString() {
+         return S.toString(GridCacheProxyImpl.class, this);
+     }
+ }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheTtlManager.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheTtlManager.java
index 0000000,2f2c24f..d061f4c
mode 000000,100644..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheTtlManager.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/GridCacheTtlManager.java
@@@ -1,0 -1,215 +1,218 @@@
+ /*
+  * Licensed to the Apache Software Foundation (ASF) under one or more
+  * contributor license agreements.  See the NOTICE file distributed with
+  * this work for additional information regarding copyright ownership.
+  * The ASF licenses this file to You 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 org.apache.ignite.internal.processors.cache;
+ 
+ import org.apache.ignite.*;
+ import org.apache.ignite.cache.*;
+ import org.apache.ignite.internal.util.*;
+ import org.apache.ignite.thread.*;
+ import org.apache.ignite.internal.util.typedef.*;
+ import org.apache.ignite.internal.util.typedef.internal.*;
+ import org.apache.ignite.internal.util.worker.*;
+ 
+ import java.util.*;
+ 
+ /**
+  * Eagerly removes expired entries from cache when {@link CacheConfiguration#isEagerTtl()} flag is set.
+  */
+ @SuppressWarnings("NakedNotify")
+ public class GridCacheTtlManager<K, V> extends GridCacheManagerAdapter<K, V> {
+     /** Entries pending removal. */
+     private final GridConcurrentSkipListSet<EntryWrapper<K, V>> pendingEntries = new GridConcurrentSkipListSet<>();
+ 
+     /** Cleanup worker thread. */
+     private CleanupWorker cleanupWorker;
+ 
+     /** Sync mutex. */
+     private final Object mux = new Object();
+ 
+     /** {@inheritDoc} */
+     @Override protected void start0() throws IgniteCheckedException {
+         if (cctx.kernalContext().isDaemon() || !cctx.config().isEagerTtl())
+             return;
+ 
+         cleanupWorker = new CleanupWorker();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override protected void onKernalStart0() throws IgniteCheckedException {
+         if (cleanupWorker != null)
+             new IgniteThread(cleanupWorker).start();
+     }
+ 
+     /** {@inheritDoc} */
+     @Override protected void onKernalStop0(boolean cancel) {
+         U.cancel(cleanupWorker);
+         U.join(cleanupWorker, log);
+     }
+ 
+     /**
+      * Adds tracked entry to ttl processor.
+      *
+      * @param entry Entry to add.
+      */
+     public void addTrackedEntry(GridCacheMapEntry<K, V> entry) {
+         EntryWrapper<K, V> wrapper = new EntryWrapper<>(entry);
+ 
+         pendingEntries.add(wrapper);
+ 
+         // If entry is on the first position, notify waiting thread.
+         if (wrapper == pendingEntries.firstx()) {
+             synchronized (mux) {
+                 mux.notifyAll();
+             }
+         }
+     }
+ 
+     /**
+      * @param entry Entry to remove.
+      */
+     public void removeTrackedEntry(GridCacheMapEntry<K, V> entry) {
+         // Remove must be called while holding lock on entry before updating expire time.
+         // No need to wake up waiting thread in this case.
+         pendingEntries.remove(new EntryWrapper<>(entry));
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void printMemoryStats() {
+         X.println(">>>");
+         X.println(">>> TTL processor memory stats [grid=" + cctx.gridName() + ", cache=" + cctx.name() + ']');
+         X.println(">>>   pendingEntriesSize: " + pendingEntries.size());
+     }
+ 
+     /**
+      * Entry cleanup worker.
+      */
+     private class CleanupWorker extends GridWorker {
+         /**
+          * Creates cleanup worker.
+          */
+         protected CleanupWorker() {
+             super(cctx.gridName(), "ttl-cleanup-worker-" + cctx.name(), cctx.logger(GridCacheTtlManager.class));
+         }
+ 
+         /** {@inheritDoc} */
+         @Override protected void body() throws InterruptedException, IgniteInterruptedException {
+             while (!isCancelled()) {
+                 long now = U.currentTimeMillis();
+ 
+                 GridCacheVersion obsoleteVer = null;
+ 
+                 for (Iterator<EntryWrapper<K, V>> it = pendingEntries.iterator(); it.hasNext(); ) {
+                     EntryWrapper<K, V> wrapper = it.next();
+ 
+                     if (wrapper.expireTime <= now) {
+                         if (log.isDebugEnabled())
+                             log.debug("Trying to remove expired entry from cache: " + wrapper);
+ 
+                         if (obsoleteVer == null)
+                             obsoleteVer = cctx.versions().next();
+ 
+                         if (wrapper.entry.onTtlExpired(obsoleteVer))
+                             wrapper.entry.context().cache().removeEntry(wrapper.entry);
+ 
++                        if (wrapper.entry.context().cache().configuration().isStatisticsEnabled())
++                            wrapper.entry.context().cache().metrics0().onEvict();
++
+                         it.remove();
+                     }
+                     else
+                         break;
+                 }
+ 
+                 synchronized (mux) {
+                     while (true) {
+                         // Access of the first element must be inside of
+                         // synchronization block, so we don't miss out
+                         // on thread notification events sent from
+                         // 'addTrackedEntry(..)' method.
+                         EntryWrapper<K, V> first = pendingEntries.firstx();
+ 
+                         if (first != null) {
+                             long waitTime = first.expireTime - U.currentTimeMillis();
+ 
+                             if (waitTime > 0)
+                                 mux.wait(waitTime);
+                             else
+                                 break;
+                         }
+                         else
+                             mux.wait(5000);
+                     }
+                 }
+             }
+         }
+     }
+ 
+     /**
+      * Entry wrapper.
+      */
+     private static class EntryWrapper<K, V> implements Comparable<EntryWrapper<K, V>> {
+         /** Entry expire time. */
+         private final long expireTime;
+ 
+         /** Entry. */
+         private final GridCacheMapEntry<K, V> entry;
+ 
+         /**
+          * @param entry Cache entry to create wrapper for.
+          */
+         private EntryWrapper(GridCacheMapEntry<K, V> entry) {
+             expireTime = entry.expireTimeUnlocked();
+ 
+             assert expireTime != 0;
+ 
+             this.entry = entry;
+         }
+ 
+         /** {@inheritDoc} */
+         @Override public int compareTo(EntryWrapper<K, V> o) {
+             if (expireTime == o.expireTime) {
+                 if (entry.startVersion() == o.entry.startVersion())
+                     return 0;
+ 
+                 return entry.startVersion() < o.entry.startVersion() ? -1 : 1;
+             }
+             else
+                 return expireTime < o.expireTime ? -1 : 1;
+         }
+ 
+         /** {@inheritDoc} */
+         @Override public boolean equals(Object o) {
+             if (this == o)
+                 return true;
+ 
+             if (!(o instanceof EntryWrapper))
+                 return false;
+ 
+             EntryWrapper that = (EntryWrapper)o;
+ 
+             return expireTime == that.expireTime && entry.startVersion() == that.entry.startVersion();
+ 
+         }
+ 
+         /** {@inheritDoc} */
+         @Override public int hashCode() {
+             int res = (int)(expireTime ^ (expireTime >>> 32));
+ 
+             res = 31 * res + (int)(entry.startVersion() ^ (entry.startVersion() >>> 32));
+ 
+             return res;
+         }
+     }
+ }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/IgniteCacheProxy.java
----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/c7a9a1db/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCache.java
----------------------------------------------------------------------
diff --cc modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCache.java
index 0000000,43a0364..becbf0c
mode 000000,100644..100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCache.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/distributed/dht/GridDhtCache.java
@@@ -1,0 -1,103 +1,99 @@@
+ /*
+  * Licensed to the Apache Software Foundation (ASF) under one or more
+  * contributor license agreements.  See the NOTICE file distributed with
+  * this work for additional information regarding copyright ownership.
+  * The ASF licenses this file to You 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 org.apache.ignite.internal.processors.cache.distributed.dht;
+ 
+ import org.apache.ignite.*;
+ import org.apache.ignite.internal.processors.cache.*;
+ import org.apache.ignite.internal.processors.cache.distributed.near.*;
+ import org.apache.ignite.internal.util.tostring.*;
+ 
+ import java.io.*;
+ 
+ /**
+  * DHT cache.
+  */
+ public class GridDhtCache<K, V> extends GridDhtTransactionalCacheAdapter<K, V> {
+     /** */
+     private static final long serialVersionUID = 0L;
+ 
+     /** Near cache. */
+     @GridToStringExclude
+     private GridNearTransactionalCache<K, V> near;
+ 
+     /**
+      * Empty constructor required for {@link Externalizable}.
+      */
+     public GridDhtCache() {
+         // No-op.
+     }
+ 
+     /**
+      * @param ctx Context.
+      */
+     public GridDhtCache(GridCacheContext<K, V> ctx) {
+         super(ctx);
+     }
+ 
+     /**
+      * @param ctx Cache context.
+      * @param map Cache map.
+      */
+     public GridDhtCache(GridCacheContext<K, V> ctx, GridCacheConcurrentMap<K, V> map) {
+         super(ctx, map);
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public boolean isDht() {
+         return true;
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public String name() {
+         String name = super.name();
+ 
+         return name == null ? "defaultDhtCache" : name + "Dht";
+     }
+ 
+     /** {@inheritDoc} */
+     @Override public void start() throws IgniteCheckedException {
 -        resetMetrics();
 -
 -        super.start();
 -    }
 -
 -    /** {@inheritDoc} */
 -    @Override public void resetMetrics() {
 -        GridCacheMetricsAdapter m = new GridCacheMetricsAdapter();
++        CacheMetricsAdapter m = new CacheMetricsAdapter(ctx);
+ 
+         m.delegate(ctx.dht().near().metrics0());
+ 
+         metrics = m;
+ 
+         ctx.dr().resetMetrics();
++
++
++        super.start();
+     }
+ 
+     /**
+      * @return Near cache.
+      */
+     @Override public GridNearTransactionalCache<K, V> near() {
+         return near;
+     }
+ 
+     /**
+      * @param near Near cache.
+      */
+     public void near(GridNearTransactionalCache<K, V> near) {
+         this.near = near;
+     }
+ }


Mime
View raw message