Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you
* may not use this file except in compliance with the License. You
* may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal.cache;
import static com.gemstone.gemfire.internal.offheap.annotations.OffHeapIdentifier.ENTRY_EVENT_NEW_VALUE;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.LongBinaryOperator;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import com.gemstone.gemfire.CancelCriterion;
import com.gemstone.gemfire.CancelException;
import com.gemstone.gemfire.CopyHelper;
import com.gemstone.gemfire.DataSerializable;
import com.gemstone.gemfire.DataSerializer;
import com.gemstone.gemfire.DeltaSerializationException;
import com.gemstone.gemfire.InternalGemFireError;
import com.gemstone.gemfire.InternalGemFireException;
import com.gemstone.gemfire.LogWriter;
import com.gemstone.gemfire.SystemFailure;
import com.gemstone.gemfire.admin.internal.SystemMemberCacheEventProcessor;
import com.gemstone.gemfire.cache.AttributesMutator;
import com.gemstone.gemfire.cache.Cache;
import com.gemstone.gemfire.cache.CacheClosedException;
import com.gemstone.gemfire.cache.CacheEvent;
import com.gemstone.gemfire.cache.CacheException;
import com.gemstone.gemfire.cache.CacheListener;
import com.gemstone.gemfire.cache.CacheLoader;
import com.gemstone.gemfire.cache.CacheLoaderException;
import com.gemstone.gemfire.cache.CacheRuntimeException;
import com.gemstone.gemfire.cache.CacheStatistics;
import com.gemstone.gemfire.cache.CacheWriter;
import com.gemstone.gemfire.cache.CacheWriterException;
import com.gemstone.gemfire.cache.ConflictException;
import com.gemstone.gemfire.cache.CustomExpiry;
import com.gemstone.gemfire.cache.DataPolicy;
import com.gemstone.gemfire.cache.DiskAccessException;
import com.gemstone.gemfire.cache.DiskStoreFactory;
import com.gemstone.gemfire.cache.DiskWriteAttributes;
import com.gemstone.gemfire.cache.DiskWriteAttributesFactory;
import com.gemstone.gemfire.cache.EntryDestroyedException;
import com.gemstone.gemfire.cache.EntryExistsException;
import com.gemstone.gemfire.cache.EntryNotFoundException;
import com.gemstone.gemfire.cache.EvictionAttributes;
import com.gemstone.gemfire.cache.ExpirationAttributes;
import com.gemstone.gemfire.cache.FailedSynchronizationException;
import com.gemstone.gemfire.cache.InterestRegistrationEvent;
import com.gemstone.gemfire.cache.InterestResultPolicy;
import com.gemstone.gemfire.cache.LoaderHelper;
import com.gemstone.gemfire.cache.LockTimeoutException;
import com.gemstone.gemfire.cache.LowMemoryException;
import com.gemstone.gemfire.cache.Operation;
import com.gemstone.gemfire.cache.PartitionedRegionStorageException;
import com.gemstone.gemfire.cache.Region;
import com.gemstone.gemfire.cache.RegionAttributes;
import com.gemstone.gemfire.cache.RegionDestroyedException;
import com.gemstone.gemfire.cache.RegionEvent;
import com.gemstone.gemfire.cache.RegionExistsException;
import com.gemstone.gemfire.cache.RegionMembershipListener;
import com.gemstone.gemfire.cache.RegionReinitializedException;
import com.gemstone.gemfire.cache.Scope;
import com.gemstone.gemfire.cache.StatisticsDisabledException;
import com.gemstone.gemfire.cache.TimeoutException;
import com.gemstone.gemfire.cache.TransactionException;
import com.gemstone.gemfire.cache.client.ServerOperationException;
import com.gemstone.gemfire.cache.client.SubscriptionNotEnabledException;
import com.gemstone.gemfire.cache.client.internal.BridgePoolImpl;
import com.gemstone.gemfire.cache.client.internal.Connection;
import com.gemstone.gemfire.cache.client.internal.Endpoint;
import com.gemstone.gemfire.cache.client.internal.PoolImpl;
import com.gemstone.gemfire.cache.client.internal.ServerRegionProxy;
import com.gemstone.gemfire.cache.control.ResourceManager;
import com.gemstone.gemfire.cache.execute.Function;
import com.gemstone.gemfire.cache.execute.ResultCollector;
import com.gemstone.gemfire.cache.hdfs.internal.HDFSBucketRegionQueue;
import com.gemstone.gemfire.cache.hdfs.internal.HDFSIntegrationUtil;
import com.gemstone.gemfire.cache.hdfs.internal.HoplogListenerForRegion;
import com.gemstone.gemfire.cache.hdfs.internal.hoplog.HDFSRegionDirector;
import com.gemstone.gemfire.cache.hdfs.internal.hoplog.HDFSRegionDirector.HdfsRegionManager;
import com.gemstone.gemfire.cache.partition.PartitionRegionHelper;
import com.gemstone.gemfire.cache.persistence.ConflictingPersistentDataException;
import com.gemstone.gemfire.cache.query.FunctionDomainException;
import com.gemstone.gemfire.cache.query.IndexMaintenanceException;
import com.gemstone.gemfire.cache.query.IndexType;
import com.gemstone.gemfire.cache.query.NameResolutionException;
import com.gemstone.gemfire.cache.query.QueryException;
import com.gemstone.gemfire.cache.query.QueryInvocationTargetException;
import com.gemstone.gemfire.cache.query.QueryService;
import com.gemstone.gemfire.cache.query.SelectResults;
import com.gemstone.gemfire.cache.query.TypeMismatchException;
import com.gemstone.gemfire.cache.query.internal.CqService;
import com.gemstone.gemfire.cache.query.internal.DefaultQuery;
import com.gemstone.gemfire.cache.query.internal.ExecutionContext;
import com.gemstone.gemfire.cache.query.internal.IndexUpdater;
import com.gemstone.gemfire.cache.query.internal.index.IndexCreationData;
import com.gemstone.gemfire.cache.query.internal.index.IndexManager;
import com.gemstone.gemfire.cache.query.internal.index.IndexProtocol;
import com.gemstone.gemfire.cache.query.internal.index.IndexUtils;
import com.gemstone.gemfire.cache.util.BridgeWriterException;
import com.gemstone.gemfire.cache.util.GatewayHub;
import com.gemstone.gemfire.cache.util.ObjectSizer;
import com.gemstone.gemfire.cache.wan.GatewaySender;
import com.gemstone.gemfire.distributed.DistributedMember;
import com.gemstone.gemfire.distributed.DistributedSystem;
import com.gemstone.gemfire.distributed.internal.DM;
import com.gemstone.gemfire.distributed.internal.DistributionAdvisor;
import com.gemstone.gemfire.distributed.internal.DistributionAdvisor.Profile;
import com.gemstone.gemfire.distributed.internal.DistributionManager;
import com.gemstone.gemfire.distributed.internal.DistributionStats;
import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
import com.gemstone.gemfire.distributed.internal.ResourceEvent;
import com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember;
import com.gemstone.gemfire.i18n.LogWriterI18n;
import com.gemstone.gemfire.internal.Assert;
import com.gemstone.gemfire.internal.ClassLoadUtil;
import com.gemstone.gemfire.internal.HeapDataOutputStream;
import com.gemstone.gemfire.internal.InternalStatisticsDisabledException;
import com.gemstone.gemfire.internal.NanoTimer;
import com.gemstone.gemfire.internal.cache.CacheDistributionAdvisor.CacheProfile;
import com.gemstone.gemfire.internal.cache.DiskInitFile.DiskRegionFlag;
import com.gemstone.gemfire.internal.cache.DistributedRegion.DiskSavyIterator;
import com.gemstone.gemfire.internal.cache.FilterRoutingInfo.FilterInfo;
import com.gemstone.gemfire.internal.cache.GemFireCacheImpl.StaticSystemCallbacks;
import com.gemstone.gemfire.internal.cache.InitialImageOperation.GIIStatus;
import com.gemstone.gemfire.internal.cache.PutAllPartialResultException.PutAllPartialResult;
import com.gemstone.gemfire.internal.cache.control.InternalResourceManager;
import com.gemstone.gemfire.internal.cache.control.InternalResourceManager.ResourceType;
import com.gemstone.gemfire.internal.cache.control.MemoryEvent;
import com.gemstone.gemfire.internal.cache.control.MemoryThresholds;
import com.gemstone.gemfire.internal.cache.control.ResourceListener;
import com.gemstone.gemfire.internal.cache.delta.Delta;
import com.gemstone.gemfire.internal.cache.execute.DistributedRegionFunctionExecutor;
import com.gemstone.gemfire.internal.cache.execute.DistributedRegionFunctionResultSender;
import com.gemstone.gemfire.internal.cache.execute.LocalResultCollector;
import com.gemstone.gemfire.internal.cache.execute.RegionFunctionContextImpl;
import com.gemstone.gemfire.internal.cache.execute.ServerToClientFunctionResultSender;
import com.gemstone.gemfire.internal.cache.ha.ThreadIdentifier;
import com.gemstone.gemfire.internal.cache.locks.ExclusiveSharedLockObject;
import com.gemstone.gemfire.internal.cache.locks.LockMode;
import com.gemstone.gemfire.internal.cache.locks.LockingPolicy;
import com.gemstone.gemfire.internal.cache.locks.LockingPolicy.ReadEntryUnderLock;
import com.gemstone.gemfire.internal.cache.locks.QueuedSynchronizer;
import com.gemstone.gemfire.internal.cache.lru.LRUEntry;
import com.gemstone.gemfire.internal.cache.partitioned.RedundancyAlreadyMetException;
import com.gemstone.gemfire.internal.cache.persistence.DiskExceptionHandler;
import com.gemstone.gemfire.internal.cache.persistence.DiskRecoveryStore;
import com.gemstone.gemfire.internal.cache.persistence.DiskRegionView;
import com.gemstone.gemfire.internal.cache.persistence.PersistentMemberID;
import com.gemstone.gemfire.internal.cache.persistence.query.IndexMap;
import com.gemstone.gemfire.internal.cache.persistence.query.mock.IndexMapImpl;
import com.gemstone.gemfire.internal.cache.tier.InterestType;
import com.gemstone.gemfire.internal.cache.tier.sockets.CacheClientNotifier;
import com.gemstone.gemfire.internal.cache.tier.sockets.ClientHealthMonitor;
import com.gemstone.gemfire.internal.cache.tier.sockets.ClientProxyMembershipID;
import com.gemstone.gemfire.internal.cache.tier.sockets.ClientTombstoneMessage;
import com.gemstone.gemfire.internal.cache.tier.sockets.ClientUpdateMessage;
import com.gemstone.gemfire.internal.cache.tier.sockets.HandShake;
import com.gemstone.gemfire.internal.cache.tier.sockets.VersionedObjectList;
import com.gemstone.gemfire.internal.cache.versions.ConcurrentCacheModificationException;
import com.gemstone.gemfire.internal.cache.versions.RegionVersionHolder;
import com.gemstone.gemfire.internal.cache.versions.RegionVersionVector;
import com.gemstone.gemfire.internal.cache.versions.VersionSource;
import com.gemstone.gemfire.internal.cache.versions.VersionStamp;
import com.gemstone.gemfire.internal.cache.versions.VersionTag;
import com.gemstone.gemfire.internal.cache.wan.AbstractGatewaySender;
import com.gemstone.gemfire.internal.cache.wan.GatewaySenderEventCallbackArgument;
import com.gemstone.gemfire.internal.cache.wan.GatewaySenderEventCallbackArgumentImpl;
import com.gemstone.gemfire.internal.cache.wan.serial.SerialGatewaySenderImpl;
import com.gemstone.gemfire.internal.concurrent.CustomEntryConcurrentHashMap;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.jta.TransactionManagerImpl;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.SimpleMemoryAllocatorImpl;
import com.gemstone.gemfire.internal.offheap.SimpleMemoryAllocatorImpl.Chunk;
import com.gemstone.gemfire.internal.offheap.StoredObject;
import com.gemstone.gemfire.internal.offheap.annotations.Released;
import com.gemstone.gemfire.internal.offheap.annotations.Retained;
import com.gemstone.gemfire.internal.offheap.annotations.Unretained;
import com.gemstone.gemfire.internal.sequencelog.EntryLogger;
import com.gemstone.gemfire.internal.shared.SystemProperties;
import com.gemstone.gemfire.management.internal.ManagementConstants;
import io.snappydata.collection.OpenHashSet;
import com.gemstone.gemfire.internal.shared.Version;
import com.gemstone.gemfire.internal.size.ReflectionObjectSizer;
import com.gemstone.gemfire.internal.size.ReflectionSingleObjectSizer;
import com.gemstone.gemfire.internal.size.SingleObjectSizer;
import com.gemstone.gemfire.internal.snappy.CallbackFactoryProvider;
import com.gemstone.gemfire.internal.snappy.StoreCallbacks;
import com.gemstone.gemfire.internal.snappy.UMMMemoryTracker;
import com.gemstone.gemfire.internal.util.concurrent.FutureResult;
import com.gemstone.gemfire.internal.util.concurrent.StoppableCountDownLatch;
import com.gemstone.gemfire.internal.util.concurrent.StoppableReentrantReadWriteLock;
import com.gemstone.gemfire.internal.util.concurrent.StoppableReentrantReadWriteLock.StoppableWriteLock;
/**
* Implementation of a local scoped-region. Note that this class has a different
* meaning starting with 3.0. In previous versions, a LocalRegion was the
* representation of a region in the VM. Starting with 3.0, a LocalRegion is a
* non-distributed region. The subclass DistributedRegion adds distribution
* behavior.
*
* @author Eric Zoerner
*/
@SuppressWarnings("deprecation")
public class LocalRegion extends AbstractRegion
implements LoaderHelperFactory, ResourceListener,
DiskExceptionHandler, DiskRecoveryStore
{
/**
* Internal interface used to simulate failures when performing entry operations
* @author Mitch Thomas
* @since 5.7
*/
public interface TestCallable {
public void call(LocalRegion r, Operation op, RegionEntry re);
}
// view types for iterators
public enum IteratorType {
KEYS, VALUES, ENTRIES,
/**
* Indicates iteration over RegionEntry or TXEntryState objects -- used by
* GemFireXD to avoid unnecessarily looking up those again since
* indexes/scans etc. deal with raw entries directly
*/
RAW_ENTRIES
}
// iniitialization level
public static final int AFTER_INITIAL_IMAGE = 0;
public static final int BEFORE_INITIAL_IMAGE = 1;
public static final int ANY_INIT = 2;
/**
* thread local to indicate that this thread should bypass the initialization
* Latch
*/
private static final ThreadLocal initializationThread = new ThreadLocal();
/* thread local to indicate its for persist data convert tool */
protected static final ThreadLocal isConversion = new ThreadLocal();
// user attributes //
private Object regionUserAttribute;
protected Map entryUserAttributes; // @todo darrel: shouldn't this be an
// identity map whose key is a RegionEntry?
private final String regionName;
protected final LocalRegion parentRegion;
// set to true only if isDestroyed is also true
// and region is about to be recreated due to reinitialization by loading
// of a snapshot, etc.
private volatile boolean reinitialized_old = false;
public volatile boolean isDestroyed = false;
// In case of parallel wan, when a destroy is called on userPR, it waits for
// parallelQueue to drain and then destroys paralleQueue. In this time if
// operation like put happens on userPR then it will keep on building parallel
// queue increasing time of userPR to get destroyed.this volatile boolean will
// block such put operation by throwing RegionDestroyedException
protected volatile boolean isDestroyedForParallelWAN = false;
// set to true after snapshot is loaded, to help get initial image
// make sure this is the right incarnation of this region
private volatile boolean reinitialized_new = false;
/** Lock used to prevent multiple concurrent destroy region operations */
private Semaphore destroyLock;
private volatile RegionTTLExpiryTask regionTTLExpiryTask = null;
private volatile RegionIdleExpiryTask regionIdleExpiryTask = null;
private final ConcurrentHashMap entryExpiryTasks = new ConcurrentHashMap();
/**
* Set to true after an invalidate region expiration so we don't get multiple
* expirations
*/
volatile boolean regionInvalid = false;
public final RegionMap entries;
private static final ThreadLocal isOffHeapThreadLocal =
new ThreadLocal() ;
/**
* Set to true if this region supports transaction else false.
*/
private final boolean supportsTX;
private final boolean isReserved;
public static final ReadEntryUnderLock READ_VALUE = new ReadEntryUnderLock() {
public final Object readEntry(final ExclusiveSharedLockObject lockObj,
Object context, int iContext, boolean allowTombstones) {
return ((RegionEntry)lockObj).getValue((LocalRegion)context);
}
};
public static final ReadEntryUnderLock READ_VALUE_RETAIN = new ReadEntryUnderLock() {
@Retained
public final Object readEntry(final ExclusiveSharedLockObject lockObj,
Object context, int iContext, boolean allowTombstones) {
return ((RegionEntry)lockObj)._getValueRetain((LocalRegion)context,
false);
}
};
public static final ReadEntryUnderLock READ_TOKEN = new ReadEntryUnderLock() {
public final Token readEntry(final ExclusiveSharedLockObject lockObj,
Object context, int iContext, boolean allowTombstones) {
return ((RegionEntry)lockObj).getValueAsToken();
}
};
public static final ReadEntryUnderLock TX_READ_VALUE = new ReadEntryUnderLock() {
public final Object readEntry(final ExclusiveSharedLockObject lockObj,
final Object context, int iContext, boolean allowTombstones) {
return ((LocalRegion)context)
.getREValueForTXRead((RegionEntry)lockObj);
}
};
public static final ReadEntryUnderLock GET_VALUE = new ReadEntryUnderLock() {
public final Object readEntry(final ExclusiveSharedLockObject lockObj,
final Object context, int iContext, boolean allowTombstones) {
return ((LocalRegion)context).getEntryValue((RegionEntry)lockObj);
}
};
public static final ReadEntryUnderLock DESER_VALUE = new ReadEntryUnderLock() {
public final Object readEntry(final ExclusiveSharedLockObject lockObj,
final Object context, final int iContext, boolean allowTombstones) {
return ((LocalRegion)context).getDeserialized(
(RegionEntry)lockObj, (iContext & DESER_UPDATE_STATS) != 0,
(iContext & DESER_DISABLE_COPY_ON_READ) != 0,
(iContext & DESER_PREFER_CD) != 0);
}
};
/**
* A count of entries that have been created by in-progress transactions for
* locking. This will be incremented when TX creates the entry for lock in the
* region and decremented when TX commits or rolls back.
*/
final AtomicInteger txLockCreateCount = new AtomicInteger(0);
/** tracks threadID->seqno information for this region */
protected EventTracker eventTracker;
/** tracks region-level version information for members. See
* https://wiki.gemstone.com/display/gfe70/Consistency+in+Replicated+Regions+and+WAN
*/
private RegionVersionVector versionVector;
private static final Pattern[] QUERY_PATTERNS = new Pattern[] {
Pattern.compile("^\\(*select .*", Pattern.CASE_INSENSITIVE
| Pattern.UNICODE_CASE | Pattern.DOTALL),
Pattern.compile("^import .*", Pattern.CASE_INSENSITIVE
| Pattern.UNICODE_CASE | Pattern.DOTALL) };
public static final String EXPIRY_MS_PROPERTY = "gemfire.EXPIRY_UNITS_MS";
/**
* Used by unit tests to set expiry to milliseconds instead of the default
* seconds. Used in ExpiryTask.
*
* @since 5.0
*/
final boolean EXPIRY_UNITS_MS = Boolean.getBoolean(EXPIRY_MS_PROPERTY);
// Indicates that the entries are in fact initialized. It turns out
// you can't trust the assignment of a volatile (as indicated above)
// to mean that the the thing being assigned is fully formed, only
// those things *before* the assignment are fully formed. mthomas 10/02/2005
private volatile boolean entriesInitialized;
/**
* contains Regions themselves // marked volatile to make sure it is fully
* initialized before being // accessed; (actually should be final)
*/
protected volatile ConcurrentHashMap subregions;
private final Object subregionsLock = new Object();
// Used for synchronizzing access to client Cqs
// private final Object clientCqsSync = new Object();
/**
* Prevents access to this region until it is done initializing, except for
* some special initializing operations such as replying to create region
* messages In JDK 1.5 we will use java.util.concurrent.CountDownLatch instead
* of com.gemstone.gemfire.internal.util.CountDownLatch.
*/
protected final StoppableCountDownLatch initializationLatchBeforeGetInitialImage;
protected final StoppableCountDownLatch initializationLatchAfterGetInitialImage;
/**
* Used to hold off cache listener events until the afterRegionCreate is
* called
*
* @since 5.0
*/
private final StoppableCountDownLatch afterRegionCreateEventLatch;
private final StoppableReentrantReadWriteLock deltaLock;
/**
* For test purpose to, especially for AbstractRegionMap.applyAllSuspects
*/
public static volatile CountDownLatch applyAllSuspectTestLatch;
public static volatile boolean applyAllSuspectTestLatchWaiting;
public static volatile String applyAllSuspectTEST_REGION_NAME;
/**
* Set to true the first time isInitialized returns true.
*/
private volatile boolean initialized = false; // added for bug 30223
/** Used for accessing region data on disk */
private final DiskRegion diskRegion;
/**
* Used by transactions to suspend entry expiration while a transaction is in
* progress on a region. This field is only initialized if expiration is
* configured and transactions are possible.
*/
private volatile StoppableReentrantReadWriteLock txExpirationLock;
final ArrayList pendingExpires = new ArrayList();
/**
* Used for serializing netSearch and netLoad on a per key basis.
* CM
*/
protected final ConcurrentHashMap getFutures =
new ConcurrentHashMap<>();
/*
* Asif: This boolean needs to be made true if the test needs to receive a
* synchronous callback just after clear on map is done. Its visibility is
* default so that only tests present in com.gemstone.gemfire.internal.cache
* will be able to see it
*/
public static boolean ISSUE_CALLBACKS_TO_CACHE_OBSERVER = false;
/**
* A flag used to indicate that this Region is being used as an administrative
* Region, holding meta-data for a PartitionedRegion
*/
final private boolean isUsedForPartitionedRegionAdmin;
final private boolean isUsedForPartitionedRegionBucket;
private PartitionedRegion partitionedRegionForBucket = null;
final private boolean isUsedForMetaRegion;
final private boolean isMetaRegionWithTransactions;
final private boolean isUsedForSerialGatewaySenderQueue;
final private boolean isUsedForIndex;
final private SerialGatewaySenderImpl serialGatewaySender;
protected volatile boolean hasLocalSerialAEQorWAN;
protected volatile boolean hasSerialAEQorWAN;
/** parallel WAN is always colocated, so present locally if at all */
protected volatile boolean hasLocalParallelAEQorWAN;
/**
* The factory used to create the LoaderHelper when a loader is invoked
*/
protected final LoaderHelperFactory loaderHelperFactory;
/**
* Allow for different cacheperfstats locations... primarily for PartitionedRegions
*/
private final CachePerfStats cachePerfStats;
private final boolean hasOwnStats;
private final ImageState imageState;
/**
* Register interest count to track if any register interest is in progress for
* this region. This count will be incremented when register interest starts
* and decremented when register interest finishes.
* @guarded.By {@link #imageState}
*/
private int riCnt = 0; /*
* since always written while holding an exclusive write lock
* and only read while holding a read lock
* it does not need to be atomic or
* protected by any other sync.
*/
/**
* Map of subregion full paths to serial numbers. These are subregions that
* were destroyed when this region was destroyed. This map remains null until
* this region is destroyed.
*/
private volatile HashMap destroyedSubregionSerialNumbers;
/**
* This boolean is true when a member who has this region is running low on memory.
* It is used to reject region operations.
*/
public final AtomicBoolean memoryThresholdReached = new AtomicBoolean(false);
// Lock for updating PR MetaData on client side
public final Lock clientMetaDataLock = new ReentrantLock();
// The int hubType would identify the order of the GfxdHub.
// If the int is 0 implies it is not associated with any hub.
private int hubType= GatewayHubImpl.NO_HUB;
public static final int GATEWAY_NONE = 0;
public static final int GATEWAY_SENDER = 1;
public static final int GATEWAY_ASYNCQUEUE = 2;
private final int gatewayType = GATEWAY_NONE;
/**
* Global map of waiters for locks when using the waiting mode in
* {@link ExclusiveSharedLockObject}.
*/
private final CustomEntryConcurrentHashMap
lockWaiters = new CustomEntryConcurrentHashMap(CustomEntryConcurrentHashMap.DEFAULT_INITIAL_CAPACITY,
CustomEntryConcurrentHashMap.DEFAULT_LOAD_FACTOR, 8, true);
protected HdfsRegionManager hdfsManager;
protected HoplogListenerForRegion hoplogListener;
/**
* There seem to be cases where a region can be created and yet the
* distributed system is not yet in place...
*
* @author jpenney
*
*/
protected class Stopper extends CancelCriterion {
@Override
public String cancelInProgress() {
// ---
// This grossness is necessary because there are instances where the
// region can exist without having a cache (XML creation)
Cache c = LocalRegion.this.getCache();
if (c == null) {
return LocalizedStrings.LocalRegion_THE_CACHE_IS_NOT_AVAILABLE.toLocalizedString();
}
// --- end of grossness
return c.getCancelCriterion().cancelInProgress();
}
/* (non-Javadoc)
* @see com.gemstone.gemfire.CancelCriterion#generateCancelledException(java.lang.Throwable)
*/
@Override
public RuntimeException generateCancelledException(Throwable e) {
// ---
// This grossness is necessary because there are instances where the
// region can exist without having a cache (XML creation)
Cache c = LocalRegion.this.getCache();
if (c == null) {
return new CacheClosedException("No cache", e);
}
// --- end of grossness
return c.getCancelCriterion().generateCancelledException(e);
}
}
protected final CancelCriterion stopper = createStopper();
protected CancelCriterion createStopper() {
return new Stopper();
}
private final TestCallable testCallable;
/**
* ThreadLocal used to set the current region being initialized.
*
* Currently used by the OpLog layer to initialize the
* {@link KeyWithRegionContext} if required.
*/
private final static ThreadLocal initializingRegion =
new ThreadLocal();
/**
* Set to true if the region contains keys implementing
* {@link KeyWithRegionContext} that require setting up of region specific
* context after deserialization or recovery from disk.
*/
private boolean keyRequiresRegionContext;
/**
* A UUID generator that is unique in the DS for this region. Currently used
* by GemFireXD for IDENTITY columns and for region keys in tables having no
* primary key.
*/
final UUIDAdvisor uuidAdvisor;
public static final Random rand = new Random(Long.getLong(
"gemfire.PartitionedRegionRandomSeed", System.nanoTime()));
// below atomic vars are used by newUUID() and newShortUUID() in case
// the region is local
private final AtomicLong localUUID;
private final AtomicInteger localShortUUID;
/**
* A cluster-wide unique ID for the region. Currently used by persistence
* layer to determine if a region recovered is same as this one.
*/
private final long regionUUID;
/** combines the path with {@link #regionUUID} */
private final String regionId;
/**
* Get the current initializing region as set in the ThreadLocal.
*
* Note that this value is cleared after the initialization of LocalRegion is
* done so is valid only for the duration of region creation and
* initialization.
*/
public static LocalRegion getInitializingRegion() {
return initializingRegion.get();
}
/**
* To clear the initializing region set in the ThreadLocal.
*
* NOTE: Only to be used by internal product code.
*/
public static void clearInitializingRegion() {
initializingRegion.set(null);
}
/**
* Return true if the keys of this region implement
* {@link KeyWithRegionContext} that require region specific context
* initialization after deserialization or recovery from disk.
*
* Currently used by GemFireXD for the optimized
* CompactCompositeRegionKey that points to the raw row bytes and
* so requires a handle to table schema for interpretation of those bytes.
*/
public final boolean keyRequiresRegionContext() {
return this.keyRequiresRegionContext;
}
/**
* Set the {@link #keyRequiresRegionContext} flag to given value.
*/
public final void setKeyRequiresRegionContext(boolean v) {
this.keyRequiresRegionContext = v;
}
public CancelCriterion getCancelCriterion() {
return this.stopper;
}
////////////////// Public Methods ///////////////////////////////////////////
static String calcFullPath(String regionName, LocalRegion parentRegion) {
StringBuilder buf = null;
if (parentRegion == null) {
buf = new StringBuilder(regionName.length() + 1);
}
else {
String parentFull = parentRegion.getFullPath();
buf = new StringBuilder(parentFull.length() + regionName.length() + 1);
buf.append(parentFull);
}
buf.append(SEPARATOR).append(regionName);
return buf.toString();
}
/**
* Creates new region
*/
protected LocalRegion(String regionName, RegionAttributes attrs,
LocalRegion parentRegion, GemFireCacheImpl cache,
InternalRegionArguments internalRegionArgs) throws DiskAccessException {
super(cache, attrs,regionName, internalRegionArgs);
Assert.assertTrue(regionName != null, "regionName must not be null");
this.sharedDataView = buildDataView();
this.regionName = regionName;
this.isInternalColumnTable = regionName.toUpperCase().endsWith(
StoreCallbacks.SHADOW_TABLE_SUFFIX);
this.parentRegion = parentRegion;
this.fullPath = calcFullPath(regionName, parentRegion);
// cannot support patterns like "..._/..." due to ambiguity in encoding
// of bucket regions
if (this.fullPath.contains("_/")) {
throw new IllegalArgumentException("Region path " + this.fullPath +
" cannot have trailing slash in a parent region");
}
final GemFireCacheImpl.StaticSystemCallbacks sysCb =
GemFireCacheImpl.FactoryStatics.systemCallbacks;
if (sysCb == null) {
this.regionUUID = internalRegionArgs.getUUID();
}
else {
this.regionUUID = sysCb.getRegionUUID(this, internalRegionArgs);
internalRegionArgs.setUUID(this.regionUUID);
}
this.regionId = getIDFromPath(this.fullPath, this.regionUUID);
this.regionLock = new ReentrantLock();
this.initializationLatchBeforeGetInitialImage = new StoppableCountDownLatch(
this.stopper, 1);
this.initializationLatchAfterGetInitialImage = new StoppableCountDownLatch(
this.stopper, 1);
this.afterRegionCreateEventLatch = new StoppableCountDownLatch(
this.stopper, 1);
this.deltaLock = new StoppableReentrantReadWriteLock(this.stopper);
String myName = getFullPath();
if (internalRegionArgs.getPartitionedRegion() != null) {
myName = internalRegionArgs.getPartitionedRegion().getFullPath();
}
this.enableOffHeapMemory = attrs.getEnableOffHeapMemory() || Boolean.getBoolean(myName+":OFF_HEAP");
if (getEnableOffHeapMemory()) {
if (cache.getOffHeapStore() == null) {
throw new IllegalStateException("The region " + myName + " was configured to use off heap memory but no off heap memory was configured.");
}
if (getCompressor() != null) {
cache.getOffHeapStore().setCompressor(getCompressor());
}
}
// set the user-attribute object upfront for GemFireXD GemFireContainer
// cache.getLogger().fine("For region " + this.fullPath + " userAttr="
// + internalRegionArgs.getUserAttribute() + " indexUpdater="
// + internalRegionArgs.getIndexUpdater());
if (internalRegionArgs.getUserAttribute() != null) {
setUserAttribute(internalRegionArgs.getUserAttribute());
}
setKeyRequiresRegionContext(internalRegionArgs.keyRequiresRegionContext());
initializingRegion.set(this);
if (internalRegionArgs.getCachePerfStatsHolder() != null) {
this.hasOwnStats = false;
this.cachePerfStats = internalRegionArgs.getCachePerfStatsHolder()
.getCachePerfStats();
}
else {
if (attrs.getPartitionAttributes() != null || isInternalRegion()
|| internalRegionArgs.isUsedForMetaRegion()) {
this.hasOwnStats = false;
this.cachePerfStats = cache.getCachePerfStats();
}
else {
this.hasOwnStats = true;
this.cachePerfStats = new RegionPerfStats(cache, cache.getCachePerfStats(), regionName);
}
}
this.hdfsManager = initHDFSManager();
this.dsi = findDiskStore(attrs, internalRegionArgs);
this.diskRegion = createDiskRegion(internalRegionArgs);
this.entries = createRegionMap(internalRegionArgs);
this.entriesInitialized = true;
this.subregions = new ConcurrentHashMap<>();
// we only need a destroy lock if this is a root
if (parentRegion == null) {
initRoot();
}
if (internalRegionArgs.getLoaderHelperFactory() != null) {
this.loaderHelperFactory = internalRegionArgs.getLoaderHelperFactory();
}
else {
this.loaderHelperFactory = this;
}
this.isUsedForPartitionedRegionAdmin = internalRegionArgs
.isUsedForPartitionedRegionAdmin();
this.isUsedForPartitionedRegionBucket = internalRegionArgs
.isUsedForPartitionedRegionBucket();
this.isUsedForIndex = internalRegionArgs.isUsedForIndex();
if(this.isUsedForPartitionedRegionBucket){
partitionedRegionForBucket = internalRegionArgs.getPartitionedRegion();
}
this.isUsedForMetaRegion = internalRegionArgs
.isUsedForMetaRegion();
this.isMetaRegionWithTransactions = internalRegionArgs.isMetaRegionWithTransactions();
this.isUsedForSerialGatewaySenderQueue = internalRegionArgs.isUsedForSerialGatewaySenderQueue();
this.serialGatewaySender = internalRegionArgs.getSerialGatewaySender();
if (!isUsedForMetaRegion && !isUsedForPartitionedRegionAdmin &&
!isUsedForPartitionedRegionBucket) {
this.filterProfile = new FilterProfile(this);
}
// initialize client to server proxy
this.srp = ((this.getPoolName() != null)
|| isBridgeLoader(this.getCacheLoader())
|| isBridgeWriter(this.getCacheWriter()))
? new ServerRegionProxy(this)
: null;
this.imageState =
new UnsharedImageState(this.srp != null,
getDataPolicy().withReplication() || getDataPolicy().isPreloaded(),
getScope().isLocal(),
getDataPolicy().withPersistence(),
this.stopper);
createEventTracker();
// prevent internal regions from participating in a TX, bug 38709
this.supportsTX = !isSecret() && !isUsedForPartitionedRegionAdmin()
&& !isUsedForMetaRegion();
this.isReserved = isSecret() || isUsedForMetaRegion() ||
isUsedForPartitionedRegionAdmin() || isMetaTable(getFullPath());
if (getScope().isLocal()) {
this.uuidAdvisor = null;
this.localUUID = new AtomicLong(0);
this.localShortUUID = new AtomicInteger(0);
}
else {
if (!isUsedForPartitionedRegionBucket()) {
this.uuidAdvisor = createUUIDAdvisor(getSystem(), internalRegionArgs);
}
else {
this.uuidAdvisor = null;
}
this.localUUID = null;
this.localShortUUID = null;
}
this.testCallable = internalRegionArgs.getTestCallable();
}
private HdfsRegionManager initHDFSManager() {
HdfsRegionManager hdfsMgr = null;
if (this.getHDFSStoreName() != null) {
this.hoplogListener = new HoplogListenerForRegion();
HDFSRegionDirector.getInstance().setCache(cache);
hdfsMgr = HDFSRegionDirector.getInstance().manageRegion(this,
this.getHDFSStoreName(), hoplogListener);
}
return hdfsMgr;
}
private RegionMap createRegionMap(InternalRegionArguments internalRegionArgs) {
RegionMap result = null;
if ((internalRegionArgs.isReadWriteHDFSRegion()) && this.diskRegion != null) {
this.diskRegion.setEntriesMapIncompatible(true);
}
if (this.diskRegion != null) {
result = this.diskRegion.useExistingRegionMap(this, internalRegionArgs);
}
if (result == null) {
RegionMap.Attributes ma = new RegionMap.Attributes();
ma.statisticsEnabled = this.statisticsEnabled;
ma.loadFactor = this.loadFactor;
ma.initialCapacity = this.initialCapacity;
ma.concurrencyLevel = this.concurrencyLevel;
result = RegionMapFactory.createVM(this, ma, internalRegionArgs);
}
if (result.getIndexUpdater() == null && internalRegionArgs != null
&& internalRegionArgs.getIndexUpdater() != null) {
result.setIndexUpdater(internalRegionArgs.getIndexUpdater());
}
return result;
}
protected InternalDataView buildDataView() {
return new LocalRegionDataView();
}
/**
* initialize the event tracker. Not all region implementations want or
* need one of these. Regions that require one should reimplement this method
* and create one like so:
*
* this.eventTracker = new EventTracker(this.cache);
* this.eventTracker.start();
*
*/
void createEventTracker() {
// if LocalRegion is changed to have an event tracker, then the initialize()
// method should be changed to set it to "initialized" state when the
// region finishes initialization
}
/**
* Test method for getting the event tracker.
*
* this method is for testing only. Other region classes may track events using
* different mechanisms than EventTrackers
*/
protected EventTracker getEventTracker() {
return this.eventTracker;
}
/** returns the regions version-vector */
public final RegionVersionVector getVersionVector() {
return this.versionVector;
}
/** returns lock used to guard the size() operation during tombstone removal */
public ReentrantLock getSizeGuard() {
if (!this.concurrencyChecksEnabled) {
return null;
}
else {
return this.regionLock;
}
}
/** initializes a new version vector for this region */
protected void createVersionVector() {
this.versionVector = RegionVersionVector.create(getVersionMember());
final RegionVersionVector diskVector;
if (dataPolicy.withPersistence()
&& (diskVector = this.diskRegion.getRegionVersionVector()) != null) {
// copy the versions that we have recovered from disk into
// the version vector.
this.versionVector.recordVersions(diskVector
.getCloneForTransmission(), null);
} else if (!dataPolicy.withStorage()) {
// version vectors are currently only necessary in empty regions for
// tracking canonical member IDs
this.versionVector.turnOffRecordingForEmptyRegion();
}
if (this.srp != null) {
this.versionVector.setIsClientVector();
}
this.cache.getDistributionManager().addMembershipListener(
this.versionVector);
}
@Override
protected void updateEntryExpiryPossible()
{
super.updateEntryExpiryPossible();
if (isEntryExpiryPossible() || isRegionExpiryPossible()) {
if (this.txExpirationLock == null) {
// HACK HACK stopper can be null if we're called
// from the superclass constructor :-(
CancelCriterion hack = this.stopper;
if (hack == null) {
hack = new Stopper();
}
this.txExpirationLock = new StoppableReentrantReadWriteLock(true, hack);
}
}
else {
this.txExpirationLock = null;
// since expiration is no longer possible cleanup the tasks
cancelAllEntryExpiryTasks();
}
}
public final IndexUpdater getIndexUpdater() {
return this.entries != null ? this.entries.getIndexUpdater() : null;
}
public final CustomEntryConcurrentHashMap
getLockWaiters() {
return this.lockWaiters;
}
/**
* Returns null if expiration is not possible; otherwise returns a read lock
* that will prevent entry expiration while it is held.
*/
public StoppableReentrantReadWriteLock.StoppableReadLock
getTxEntryExpirationReadLock() {
final StoppableReentrantReadWriteLock lk = this.txExpirationLock;
if (lk != null) {
StoppableReentrantReadWriteLock.StoppableReadLock result = lk.readLock();
result.lock();
return result;
}
else {
return null;
}
}
final boolean isCacheClosing()
{
return this.cache.isClosed();
}
public final RegionEntry getRegionEntry(Object key) {
return this.entries.getEntry(key);
}
/**
* Test hook - returns the version stamp for an entry in the form of a
* version tag
* @param key
* @return the entry version information
*/
public VersionTag getVersionTag(Object key) {
try{
operationStart();
Region.Entry entry = getEntry(key, discoverJTA(), true);
VersionTag tag = null;
if (entry != null && entry instanceof EntrySnapshot) {
tag = ((EntrySnapshot)entry).getVersionTag();
} else if (entry != null && entry instanceof NonTXEntry) {
tag = ((NonTXEntry)entry).getRegionEntry().getVersionStamp().asVersionTag();
}
return tag;
} finally {
operationCompleted();
}
}
/** removes any destroyed entries from the region and clear the destroyedKeys
* assert: Caller must be holding writeLock on is
*/
private void destroyEntriesAndClearDestroyedKeysSet() {
ImageState is = getImageState();
Iterator iter = is.getDestroyedEntries();
while (iter.hasNext()) {
Object key = iter.next();
// destroy the entry which has value Token.DESTROYED
// If it is Token.DESTROYED then only destroy it.
this.entries.removeIfDestroyed(key); // fixes bug 41957
}
}
/**
* @since 5.7
*/
protected final ServerRegionProxy srp;
private final InternalDataView sharedDataView;
public final ServerRegionProxy getServerProxy() {
return this.srp;
}
public final boolean hasServerProxy() {
return this.srp != null;
}
/** Returns true if the ExpiryTask is currently allowed to expire. */
protected boolean isExpirationAllowed(ExpiryTask expiry)
{
return true;
}
public final void processPendingExpires()
{
while (true) {
synchronized (this.pendingExpires) {
if (this.pendingExpires.isEmpty()) {
return;
}
}
final StoppableReentrantReadWriteLock rwl = this.txExpirationLock;
if (rwl != null) {
StoppableWriteLock writeLock = rwl.writeLock();
boolean lockAcquired = false;
try {
if (writeLock.tryLock()) {
lockAcquired = true;
basicProcessPendingExpires();
} else {
break;
}
} finally {
if (lockAcquired) {
writeLock.unlock();
}
}
} else {
basicProcessPendingExpires();
}
}
}
private final void basicProcessPendingExpires()
{
ExpiryTask[] tasks;
while (true) {
// note we just keep looping until no more pendingExpires exist
synchronized (this.pendingExpires) {
if (this.pendingExpires.isEmpty()) {
return;
}
tasks = new ExpiryTask[this.pendingExpires.size()];
this.pendingExpires.toArray(tasks);
this.pendingExpires.clear();
}
try {
if (isCacheClosing() || isClosed() || this.isDestroyed) {
return;
}
final LogWriterI18n logger = getCache().getLoggerI18n();
for (int i = 0; i < tasks.length; i++) {
try {
if (logger.fineEnabled()) {
logger.fine(tasks[i].toString() + " pending expire fired at "
+ this.cacheTimeMillis());
}
tasks[i].basicPerformTimeout(false);
if (isCacheClosing() || isClosed() || isDestroyed()) {
return;
}
}
catch (EntryNotFoundException ignore) {
// ignore and try the next expiry task
}
}
}
catch (RegionDestroyedException re) {
// Ignore - our job is done
}
catch (CancelException ex) {
// ignore
}
catch (VirtualMachineError err) {
SystemFailure.initiateFailure(err);
// If this ever returns, rethrow the error. We're poisoned
// now, so don't let this thread continue.
throw err;
}
catch (Throwable ex) {
// Whenever you catch Error or Throwable, you must also
// check for fatal JVM error (see above). However, there is
// _still_ a possibility that you are dealing with a cascading
// error condition, so you also need to check to see if the JVM
// is still usable:
SystemFailure.checkFailure();
getCache().getLoggerI18n().severe(LocalizedStrings.LocalRegion_EXCEPTION_IN_EXPIRATION_TASK, ex);
}
}
}
/**
* If set then an expiration can cause a tx commit to fail with a conflict.
* The advantage of setting it is that expiration can be done by multiple
* threads. Set -Dgemfire.EXPIRY_THREADS=x if you want multiple threads to
* expire entries.
*/
private final static boolean EXPIRATIONS_CAUSE_CONFLICTS = Boolean
.getBoolean("gemfire.EXPIRATIONS_CAUSE_CONFLICTS");
void performExpiryTimeout(ExpiryTask p_task) throws CacheException
{
if (EXPIRATIONS_CAUSE_CONFLICTS) {
if (p_task != null) {
p_task.basicPerformTimeout(false);
}
return;
}
ExpiryTask task = p_task;
synchronized (this.pendingExpires) {
if (!this.pendingExpires.isEmpty()) {
// we already have pending expires so just add this one to the list
this.pendingExpires.add(task);
task = null;
}
}
attemptPendingDrain(task);
}
protected final void attemptPendingDrain(ExpiryTask task) throws CacheException
{
final StoppableReentrantReadWriteLock lk = this.txExpirationLock;
if (lk != null) {
StoppableWriteLock sync = lk.writeLock();
//try {
if (sync.tryLock()) {
try {
basicProcessPendingExpires();
if (task != null) {
task.basicPerformTimeout(false);
}
}
finally {
sync.unlock();
}
{
boolean moreToDo = false;
synchronized (this.pendingExpires) {
if (!this.pendingExpires.isEmpty()) {
moreToDo = true;
}
}
if (moreToDo) {
attemptPendingDrain(null);
}
}
}
else if (task != null) {
// We could not get the write lock so a transaction must be
// in progress. Add a pendingExpire for the last transaction
// to process.
synchronized (this.pendingExpires) {
this.pendingExpires.add(task);
}
attemptPendingDrain(null);
}
}
else {
// expiration must have been disabled on this region
basicProcessPendingExpires();
if (task != null) {
task.basicPerformTimeout(false);
}
}
}
private void initRoot() {
this.destroyLock = new Semaphore(1);
}
public void handleMarker() {
//LogWriterI18n logger = getCache().getLoggerI18n();
RegionEventImpl event = new RegionEventImpl(this,
Operation.MARKER, null, false, getMyId(),
false /* generate EventID */);
dispatchListenerEvent(EnumListenerEvent.AFTER_REGION_LIVE, event);
}
public AttributesMutator getAttributesMutator()
{
checkReadiness();
return this;
}
public Region createSubregion(String subregionName,
RegionAttributes regionAttributes) throws RegionExistsException,
TimeoutException
{
try {
return createSubregion(subregionName, regionAttributes,
new InternalRegionArguments().setDestroyLockFlag(true)
.setRecreateFlag(false));
}
catch (IOException e) {
// only happens when loading a snapshot, not here
InternalGemFireError assErr = new InternalGemFireError(LocalizedStrings.LocalRegion_UNEXPECTED_EXCEPTION.toLocalizedString());
assErr.initCause(e);
throw assErr;
}
catch (ClassNotFoundException e) {
// only happens when loading a snapshot, not here
InternalGemFireError assErr = new InternalGemFireError(LocalizedStrings.LocalRegion_UNEXPECTED_EXCEPTION.toLocalizedString());
assErr.initCause(e);
throw assErr;
}
}
/**
* Returns the member id of my distributed system
*
* @since 5.0
*/
@Override
protected final InternalDistributedMember getMyId() {
return this.cache.getMyId();
}
/**
* Get the cluster-wide unique ID for the region. Currently used by
* persistence layer to determine if a region recovered is same as this one.
*
* Currently only used by GemFireXD (#48335).
*/
public final long getRegionUUID() {
return this.regionUUID;
}
/**
* Get a cluster-wide unique ID string for the region that combines the path
* with {@link #getRegionUUID()}.
*
* Currently only used by GemFireXD (#48335).
*/
public final String getRegionID() {
return this.regionId;
}
public static String getIDFromPath(String path, long uuid) {
return path + ':' + uuid;
}
public final VersionSource getVersionMember()
{
if(dataPolicy.withPersistence()) {
return getDiskStore().getDiskStoreID();
} else {
return this.cache.getMyId();
}
}
public Region createSubregion(String subregionName,
RegionAttributes attrs,
InternalRegionArguments internalRegionArgs) throws RegionExistsException,
TimeoutException, IOException, ClassNotFoundException {
return createSubregion(subregionName, attrs, internalRegionArgs,
false);
}
public Region createSubregion(String subregionName,
RegionAttributes regionAttributes,
InternalRegionArguments internalRegionArgs, boolean skipInitialization)
throws RegionExistsException, TimeoutException, IOException,
ClassNotFoundException {
checkReadiness();
LocalRegion newRegion = null;
final InputStream snapshotInputStream = internalRegionArgs
.getSnapshotInputStream();
final boolean getDestroyLock = internalRegionArgs.getDestroyLockFlag();
final InternalDistributedMember imageTarget = internalRegionArgs
.getImageTarget();
try {
if (getDestroyLock)
acquireDestroyLock();
LocalRegion existing = null;
try {
if (isDestroyed()) {
if (this.reinitialized_old) {
throw new RegionReinitializedException(toString(), getFullPath());
}
throw new RegionDestroyedException(toString(), getFullPath());
}
validateRegionName(subregionName);
validateSubregionAttributes(regionAttributes);
String regionPath = calcFullPath(subregionName, this);
// lock down the subregionsLock
// to prevent other threads from adding a region to it in toRegion
// but don't wait on initialization while synchronized (distributed
// deadlock)
synchronized (this.subregionsLock) {
existing = this.subregions.get(subregionName);
if (existing == null) {
// create the async queue for HDFS if required.
HDFSIntegrationUtil.createAndAddAsyncQueue(regionPath,
regionAttributes, this.cache);
regionAttributes = cache.setEvictionAttributesForLargeRegion(
regionAttributes);
if (regionAttributes.getScope().isDistributed()
&& internalRegionArgs.isUsedForPartitionedRegionBucket()) {
final PartitionedRegion pr = internalRegionArgs
.getPartitionedRegion();
internalRegionArgs.setIndexUpdater(pr.getIndexUpdater());
internalRegionArgs.setUserAttribute(pr.getUserAttribute());
internalRegionArgs.setKeyRequiresRegionContext(pr
.keyRequiresRegionContext());
if (pr.isShadowPR()) {
if (!pr.isShadowPRForHDFS()) {
newRegion = new BucketRegionQueue(subregionName, regionAttributes,
this, this.cache, internalRegionArgs);
}
else {
newRegion = new HDFSBucketRegionQueue(subregionName, regionAttributes,
this, this.cache, internalRegionArgs);
}
} else {
newRegion = new BucketRegion(subregionName, regionAttributes,
this, this.cache, internalRegionArgs);
}
}
else if (regionAttributes.getPartitionAttributes() != null) {
newRegion = new PartitionedRegion(subregionName,
regionAttributes, this, this.cache, internalRegionArgs);
}
else {
boolean local = regionAttributes.getScope().isLocal();
newRegion = local ? new LocalRegion(subregionName,
regionAttributes, this, this.cache, internalRegionArgs)
: new DistributedRegion(subregionName, regionAttributes,
this, this.cache, internalRegionArgs);
}
Object o = this.subregions.putIfAbsent(subregionName, newRegion);
Assert.assertTrue(o == null);
LogWriterI18n logger = getCache().getLoggerI18n();
Assert.assertTrue(!newRegion.isInitialized());
//
if (logger.fineEnabled()) {
logger.fine("Subregion created: " + newRegion);
}
if (snapshotInputStream != null || imageTarget != null
|| internalRegionArgs.getRecreateFlag()) {
this.cache.regionReinitialized(newRegion); // fix for bug 33534
}
} // endif: existing == null
} // end synchronization
}
finally {
if (getDestroyLock)
releaseDestroyLock();
}
//Fix for bug 42127 - moved to outside of the destroy lock.
if (existing != null) {
// now outside of synchronization we must wait for appropriate
// initialization on existing region before returning a reference to
// it
existing.waitOnInitialization();
// fix for bug 32570
throw new RegionExistsException(existing);
}
boolean success = false;
try {
newRegion.checkReadiness();
this.cache.setRegionByPath(newRegion.getFullPath(), newRegion);
if (skipInitialization) {
success = true;
return newRegion;
}
newRegion.preInitialize(internalRegionArgs);
if (regionAttributes instanceof UserSpecifiedRegionAttributes){
internalRegionArgs.setIndexes((
(UserSpecifiedRegionAttributes)regionAttributes).getIndexes());
}
newRegion.initialize(snapshotInputStream, imageTarget,
internalRegionArgs); // releases initialization Latches
//register the region with resource manager to get memory events
if(!newRegion.isInternalRegion()){
if (!newRegion.isDestroyed) {
cache.getResourceManager().addResourceListener(ResourceType.MEMORY, newRegion);
if (!newRegion.getEnableOffHeapMemory()) {
newRegion.initialCriticalMembers(cache.getResourceManager().getHeapMonitor().getState().isCritical(), cache
.getResourceAdvisor().adviseCriticalMembers());
} else {
newRegion.initialCriticalMembers(cache.getResourceManager().getHeapMonitor().getState().isCritical()
|| cache.getResourceManager().getOffHeapMonitor().getState().isCritical(), cache.getResourceAdvisor()
.adviseCriticalMembers());
}
// synchronization would be done on ManagementAdapter.regionOpLock
// instead of destroyLock in LocalRegion? ManagementAdapter is one
// of the Resource Event listeners
InternalDistributedSystem system = this.cache
.getDistributedSystem();
system.handleResourceEvent(ResourceEvent.REGION_CREATE, newRegion);
}
}
success = true;
} catch (CancelException e) {
// don't print a call stack
throw e;
} catch(RedundancyAlreadyMetException e) {
//don't log this
throw e;
} catch (final Exception validationException) {
this.cache.getLoggerI18n().warning(LocalizedStrings.
LocalRegion_INITIALIZATION_FAILED_FOR_REGION_0,
newRegion.getFullPath(), validationException);
throw validationException;
} catch (Error e) {
this.cache.getLoggerI18n().warning(LocalizedStrings.
LocalRegion_INITIALIZATION_FAILED_FOR_REGION_0,
newRegion.getFullPath(), e);
// don't try cleanup for any of the fatal errors below
// else they themselves can get stuck
success = true;
if (SystemFailure.isJVMFailureError(e)) {
SystemFailure.initiateFailure(e);
// If this ever returns, rethrow the error. We're poisoned
// now, so don't let this thread continue.
throw e;
}
SystemFailure.checkFailure();
// do cleanup for any non-fatal errors
success = false;
stopper.checkCancelInProgress(e);
throw e;
} finally {
if (!success) {
this.cache.setRegionByPath(newRegion.getFullPath(), null);
initializationFailed(newRegion);
cache.getResourceManager(false).removeResourceListener(newRegion);
}
}
newRegion.postCreateRegion();
}
finally {
// make sure region initialization latch is open regardless
// before returning;
// if the latch is not open at this point, then an exception must
// have occurred
if (newRegion != null && !skipInitialization
&& !newRegion.isInitialized()) {
getCache().getLoggerI18n().fine(
"Region initialize latch is closed, Error must have occurred");
}
}
return newRegion;
}
/**
* Explicitly initialize a region that was skipped during
* {@link #createSubregion(String, RegionAttributes, InternalRegionArguments,
* boolean)}. Used by GemFireXD to delay initialization of a region during
* DDL replay till all ALTER TABLE have not completed execution.
*/
public void initialize(LocalRegion subRegion,
InternalRegionArguments internalRegionArgs) throws RegionExistsException,
TimeoutException, IOException, ClassNotFoundException {
boolean success = false;
try {
try {
// releases initialization Latches
subRegion.initialize(internalRegionArgs.getSnapshotInputStream(),
internalRegionArgs.getImageTarget(), internalRegionArgs);
// register the region with resource manager to get heap events
if (!subRegion.isInternalRegion()) {
if (!subRegion.isDestroyed) {
cache.getResourceManager().addResourceListener(ResourceType.MEMORY, subRegion);
InternalDistributedSystem system = this.cache.getDistributedSystem();
system.handleResourceEvent(ResourceEvent.REGION_CREATE, subRegion);
}
}
success = true;
} catch (CancelException e) {
// don't print a call stack
throw e;
} catch (RedundancyAlreadyMetException e) {
// don't log this
throw e;
} catch (final Exception validationException) {
this.cache.getLoggerI18n().warning(
LocalizedStrings.LocalRegion_INITIALIZATION_FAILED_FOR_REGION_0,
subRegion.getFullPath(), validationException);
throw validationException;
} catch (Error e) {
this.cache.getLoggerI18n().warning(
LocalizedStrings.LocalRegion_INITIALIZATION_FAILED_FOR_REGION_0,
subRegion.getFullPath(), e);
// don't try cleanup for any of the fatal errors below
// else they themselves can get stuck
success = true;
if (SystemFailure.isJVMFailureError(e)) {
SystemFailure.initiateFailure(e);
// If this ever returns, rethrow the error. We're poisoned
// now, so don't let this thread continue.
throw e;
}
SystemFailure.checkFailure();
// do cleanup for any non-fatal errors
success = false;
stopper.checkCancelInProgress(e);
throw e;
} finally {
if (!success) {
this.cache.setRegionByPath(subRegion.getFullPath(), null);
initializationFailed(subRegion);
cache.getResourceManager(false).removeResourceListener(subRegion);
}
}
subRegion.postCreateRegion();
} finally {
// make sure region initialization latch is open regardless
// before returning;
// if the latch is not open at this point, then an exception must
// have occurred
if (subRegion != null && !subRegion.isInitialized()) {
getCache().getLoggerI18n().fine(
"Region initialize latch is closed, Error must have occurred");
}
}
}
public final void create(Object key, Object value, Object aCallbackArgument)
throws TimeoutException, EntryExistsException, CacheWriterException {
long startPut = CachePerfStats.getStatTime();
//The OffHeap resource is freed in the validatedCreate method
//The freeing of OffHeapResource is being done in validatedCreate because
//SqlFire invokes validatedCreate directly
try {
operationStart();
EntryEventImpl event = newCreateEntryEvent(key, value, aCallbackArgument);
validatedCreate(event, startPut);
// TODO OFFHEAP: validatedCreate calls freeOffHeapResources
} finally {
operationCompleted();
}
}
public final void validatedCreate(EntryEventImpl event, long startPut)
throws TimeoutException, EntryExistsException, CacheWriterException {
try {
if (event.getEventId() == null && generateEventID()) {
event.setNewEventId(cache.getDistributedSystem());
}
assert event.isFetchFromHDFS() : "validatedPut() should have been called";
// Fix for 42448 - Only make create with null a local invalidate for
// normal regions. Otherwise, it will become a distributed invalidate.
if (getDataPolicy() == DataPolicy.NORMAL) {
event.setLocalInvalid(true);
}
if (!basicPut(event, true, // ifNew
false, // ifOld
null, // expectedOldValue
true // requireOldValue TODO txMerge why is oldValue required for
// create? I think so that the EntryExistsException will have it.
)) {
throw new EntryExistsException(event.getKey().toString(),
event.getOldValue());
} else {
if (!getDataView(event).isDeferredStats()) {
getCachePerfStats().endPut(startPut, false);
}
}
} finally {
event.release();
}
}
// split into a separate newCreateEntryEvent since GemFireXD may need to
// manipulate event before doing the put (e.g. posDup flag)
public final EntryEventImpl newCreateEntryEvent(Object key, Object value,
Object aCallbackArgument) {
validateArguments(key, value, aCallbackArgument);
checkReadiness();
checkForLimitedOrNoAccess();
return EntryEventImpl.create(this, Operation.CREATE, key,
value, aCallbackArgument, false, getMyId())
/* to distinguish genuine create */.setCreate(true);
}
/**
* The default Region implementation will generate EvenTID in the EntryEvent
* object. This method is overridden in special Region objects like HARegion
* or SingleWriteSingleReadRegionQueue.SingleReadWriteMetaRegion to return
* false as the event propagation from those regions do not need EventID
* objects
*
*
author Asif
* @return boolean indicating whether to generate eventID or not
*/
@Override
public boolean generateEventID()
{
return !(isUsedForPartitionedRegionAdmin()
|| isUsedForPartitionedRegionBucket() );
}
public final Object destroy(Object key, Object aCallbackArgument)
throws TimeoutException, EntryNotFoundException, CacheWriterException {
EntryEventImpl event = newDestroyEntryEvent(key, aCallbackArgument);
//The OffHeap resource is freed in the validatedDestroy method
//The freeing of OffHeapResource is being done in validatedDestroy because
//SqlFire invokes validatedDestroy directly
try {
operationStart();
return validatedDestroy(key, event);
// TODO OFFHEAP: validatedDestroy calls freeOffHeapResources
} finally {
operationCompleted();
}
}
/**
* Destroys entry without performing validations. Call this after validating
* key, callback arg, and runtime state.
*/
public Object validatedDestroy(Object key, EntryEventImpl event)
throws TimeoutException, EntryNotFoundException, CacheWriterException
{
try {
if (event.getEventId() == null && generateEventID()) {
event.setNewEventId(cache.getDistributedSystem());
}
basicDestroy(event, true, // cacheWrite
null); // expectedOldValue
if (event.isOldValueOffHeap()) {
return null;
} else {
return handleNotAvailable(event.getOldValue());
}
} finally {
event.release();
}
}
// split into a separate newDestroyEntryEvent since GemFireXD may need to
// manipulate event before doing the put (e.g. posDup flag)
public final EntryEventImpl newDestroyEntryEvent(Object key,
Object aCallbackArgument) {
validateKey(key);
validateCallbackArg(aCallbackArgument);
checkReadiness();
checkForLimitedOrNoAccess();
return EntryEventImpl.create(this, Operation.DESTROY, key,
null/* newValue */, aCallbackArgument, false, getMyId());
}
public void destroyRegion(Object aCallbackArgument)
throws CacheWriterException, TimeoutException {
getDataView().checkSupportsRegionDestroy();
checkForLimitedOrNoAccess();
RegionEventImpl event = new RegionEventImpl(this, Operation.REGION_DESTROY,
aCallbackArgument, false, getMyId(), generateEventID());
basicDestroyRegion(event, true);
}
public final InternalDataView getDataView() {
if (this.supportsTX) {
final TXStateInterface tx = TXManagerImpl.getCurrentTXState();
if (tx != null ) {
// NORMAL/PRELOADED regions are now supported in the new TX model mixed
// with PRs just like replicated regions
/*
if (this.scope.isDistributed()
&& (this.dataPolicy == DataPolicy.NORMAL
|| this.dataPolicy == DataPolicy.PRELOADED)) {
throw new UnsupportedOperationException(LocalizedStrings
.TX_NORMAL_PRELOADED_REGION_NOT_SUPPORTED.toLocalizedString());
}
*/
return tx;
}
}
return this.sharedDataView;
}
public final InternalDataView getDataView(final TXStateInterface tx) {
if (tx == null) {
return this.sharedDataView;
}
// NORMAL/PRELOADED regions are now supported in the new TX model mixed
// with PRs just like replicated regions
/*
if (this.scope.isDistributed()
&& (this.dataPolicy == DataPolicy.NORMAL
|| this.dataPolicy == DataPolicy.PRELOADED)) {
throw new UnsupportedOperationException(LocalizedStrings
.TX_NORMAL_PRELOADED_REGION_NOT_SUPPORTED.toLocalizedString());
}
*/
return tx;
}
public final InternalDataView getDataView(final EntryEventImpl event) {
final TXStateInterface tx = event.getTXState(this);
if (tx == null) {
return this.sharedDataView;
}
return tx;
}
/**
* Fetch the de-serialized value from non-transactional state.
* @param key to which the value is associated
* @param callbackArg any callback argument for the operation
* @param updateStats true if the entry stats should be updated.
* @param disableCopyOnRead if true then disable copy on read
* @param preferCD true if the preferred result form is CachedDeserializable
* @param lockState the TXState that must be used to lock the current entry
* @param clientEvent client's event, if any (for version tag retrieval)
* @param returnTombstones TODO
* @return the value for the given key
*/
public final Object getDeserializedValue(RegionEntry re, final Object key,
final Object callbackArg, final boolean updateStats,
final boolean disableCopyOnRead, final boolean preferCD,
final TXStateInterface lockState, EntryEventImpl clientEvent,
boolean returnTombstones, boolean allowReadFromHDFS) {
if (this.diskRegion != null) {
this.diskRegion.setClearCountReference();
}
try {
if (re == null) {
if (allowReadFromHDFS) {
re = this.entries.getEntry(key);
} else {
re = this.entries.getOperationalEntryInVM(key);
}
}
//skip updating the stats if the value is null
// TODO - We need to clean up the callers of the this class so that we can
// update the statistics here, where it would make more sense.
if (re != null) {
if (lockState != null) {
// for txns, acquire read lock if required
int context = 0;
if (updateStats) {
context |= ReadEntryUnderLock.DESER_UPDATE_STATS;
}
if (disableCopyOnRead) {
context |= ReadEntryUnderLock.DESER_DISABLE_COPY_ON_READ;
}
if (preferCD) {
context |= ReadEntryUnderLock.DESER_PREFER_CD;
}
return lockState.lockEntryForRead(re, key, this, context,
returnTombstones, DESER_VALUE);
}
else {
final Object value;
if (clientEvent != null && re.getVersionStamp() != null) {
// defer the lruUpdateCallback to prevent a deadlock (see bug 51121).
this.entries.disableLruUpdateCallback();
try {
synchronized(re) { // bug #51059 value & version must be obtained atomically
clientEvent.setVersionTag(re.getVersionStamp().asVersionTag());
value = getDeserialized(re, updateStats, disableCopyOnRead, preferCD);
}
} finally {
this.entries.enableLruUpdateCallback();
try {
this.entries.lruUpdateCallback();
}catch( DiskAccessException dae) {
this.handleDiskAccessException(dae, true /* stop bridge servers*/);
throw dae;
}
}
} else {
value = getDeserialized(re, updateStats, disableCopyOnRead, preferCD);
}
if (getLogWriterI18n().finerEnabled() && !(this instanceof HARegion)) {
getLogWriterI18n().finer("getDeserializedValue for " + key
+ " returning version: " + (re.getVersionStamp()==null? "null"
: re.getVersionStamp().asVersionTag()) + " returnTombstones: "
+ returnTombstones + " value: " + value);
}
return value;
}
}
return null;
} finally {
if (this.diskRegion != null) {
this.diskRegion.removeClearCountReference();
}
}
}
/**
*
* @param re
* @param updateStats
* @param disableCopyOnRead if true then do not make a copy on read
* @param preferCD true if the preferred result form is CachedDeserializable
* @return the value found, which can be
*
*
null if the value was removed from the region entry
*
Token.INVALID if the value of the region entry is invalid
*
Token.LOCAL_INVALID if the value of the region entry is local invalid
*
*/
protected final Object getDeserialized(RegionEntry re, boolean updateStats,
boolean disableCopyOnRead, boolean preferCD) {
try {
Object v = null;
try {
v = re.getValue(this); // OFFHEAP: incrc, deserialize, decrc TODO: optimize if preferCD but need to track down when to decrc in that case
} catch(DiskAccessException dae) {
this.handleDiskAccessException(dae, true/* stop bridge servers*/);
throw dae;
}
//skip updating the stats if the value is null
if (v == null) {
return null;
}
if (preferCD) {
if (!disableCopyOnRead && !(v instanceof CachedDeserializable)) {
v = conditionalCopy(v);
}
}
else {
if (v instanceof CachedDeserializable) {
if (isCopyOnRead()) {
if (disableCopyOnRead) {
v = ((CachedDeserializable)v).getDeserializedForReading();
} else {
v = ((CachedDeserializable)v).getDeserializedWritableCopy(this, re);
}
} else {
v = ((CachedDeserializable)v).getDeserializedValue(this, re);
}
}
else if (!disableCopyOnRead) {
v = conditionalCopy(v);
}
}
if (updateStats) {
updateStatsForGet(re, v != null && !Token.isInvalid(v));
}
return v;
} catch(IllegalArgumentException i) {
IllegalArgumentException iae = new IllegalArgumentException(
LocalizedStrings.DONT_RELEASE.toLocalizedString(
"Error while deserializing value for key=" + re.getKeyCopy()));
iae.initCause(i);
throw iae;
}
}
@Override
public final Object get(Object key, Object aCallbackArgument,
boolean generateCallbacks, EntryEventImpl clientEvent)
throws TimeoutException, CacheLoaderException {
Object result = get(key, aCallbackArgument, generateCallbacks, false, false,
null, discoverJTA(), null, clientEvent, false, true/*allowReadFromHDFS*/);
if (Token.isInvalid(result)) {
result = null;
}
return result;
}
/**
* @see BucketRegion#getSerialized(Object, Object, KeyInfo, boolean, boolean,
* TXStateInterface, EntryEventImpl, boolean, boolean)
*/
public Object get(Object key, Object aCallbackArgument,
final boolean generateCallbacks, final boolean disableCopyOnRead,
final boolean preferCD, final ClientProxyMembershipID requestingClient,
final TXStateInterface tx, final TXStateInterface lockState,
EntryEventImpl clientEvent, boolean returnTombstones, boolean allowReadFromHDFS) throws TimeoutException, CacheLoaderException {
validateKey(key);
validateCallbackArg(aCallbackArgument);
checkReadiness();
checkForNoAccess();
final CachePerfStats stats = getCachePerfStats();
final long start = stats.startGet();
boolean isMiss = true;
try {
final InternalDataView view = getDataView(tx);
Object value = view.getDeserializedValue(key, aCallbackArgument, this,
true, disableCopyOnRead, preferCD, lockState, clientEvent,
returnTombstones, allowReadFromHDFS);
final boolean isCreate = (value == null);
isMiss = isCreate || Token.isInvalid(value)
|| (!returnTombstones && value == Token.TOMBSTONE);
// Note: if the value was Token.DESTROYED then getDeserialized
// returns null so we don't need the following in the above expression:
// || (isRegInterestInProgress() && Token.isDestroyed(value))
// because (value == null) will be true in this case.
if (isMiss) {
// if scope is local and there is no loader, then
// don't go further to try and get value
if ((getScope().isDistributed() && !isHDFSRegion())
|| hasServerProxy()
|| basicGetLoader() != null) {
// serialize search/load threads if not in txn
value = view.findObject(getKeyInfo(key, aCallbackArgument), this,
isCreate, generateCallbacks, value, disableCopyOnRead, preferCD,
requestingClient, clientEvent, returnTombstones, false/*allowReadFromHDFS*/);
if (!returnTombstones && value == Token.TOMBSTONE) {
value = null;
}
}
else { // local scope with no loader, still might need to update stats
if (isCreate) {
recordMiss(tx, null, key);
}
value = null;
}
}
return value;
}
finally {
stats.endGet(start, isMiss);
}
}
/**
* Update region and potentially entry stats for the miss case
* @param re optional region entry, fetched if null
* @param key the key used to fetch the region entry
*/
final public void recordMiss(final TXStateInterface tx, final RegionEntry re,
Object key) {
final RegionEntry e;
if (re == null && tx == null && !isHDFSRegion()) {
e = basicGetEntry(key);
} else {
e = re;
}
if (e != ProxyRegionMap.markerEntry) {
updateStatsForGet(e, false);
}
}
/**
* @return true if this region has been configured for HDFS persistence
*/
public boolean isHDFSRegion() {
return false;
}
/**
* @return true if this region is configured to read and write data from HDFS
*/
public boolean isHDFSReadWriteRegion() {
return false;
}
/**
* @return true if this region is configured to only write to HDFS
*/
protected boolean isHDFSWriteOnly() {
return false;
}
/**
* FOR TESTING ONLY
*/
public HoplogListenerForRegion getHoplogListener() {
return hoplogListener;
}
/**
* FOR TESTING ONLY
*/
public HdfsRegionManager getHdfsRegionManager() {
return hdfsManager;
}
/**
* optimized to only allow one thread to do a search/load, other threads wait
* on a future
*
* @param keyInfo
* @param p_isCreate
* true if call found no entry; false if updating an existing
* entry
* @param generateCallbacks
* @param p_localValue
* the value retrieved from the region for this object.
* @param disableCopyOnRead if true then do not make a copy
* @param preferCD true if the preferred result form is CachedDeserializable
* @param clientEvent the client event, if any
* @param returnTombstones whether to return tombstones
*/
@Retained
protected Object nonTxnFindObject(KeyInfo keyInfo, boolean p_isCreate,
boolean generateCallbacks, Object p_localValue, boolean disableCopyOnRead,
boolean preferCD, EntryEventImpl clientEvent, boolean returnTombstones, boolean allowReadFromHDFS)
throws TimeoutException, CacheLoaderException {
final Object key = keyInfo.getKey();
Object localValue = p_localValue;
boolean isCreate = p_isCreate;
Object[] valueAndVersion = null;
@Retained Object result = null;
FutureResult thisFuture = new FutureResult(this.stopper);
Future otherFuture = this.getFutures.putIfAbsent(key, thisFuture);
// only one thread can get their future into the map for this key at a time
if (otherFuture != null) {
try {
valueAndVersion = (Object[])otherFuture.get();
if (valueAndVersion != null) {
result = valueAndVersion[0];
if (clientEvent != null) {
clientEvent.setVersionTag((VersionTag)valueAndVersion[1]);
}
if (!preferCD && result instanceof CachedDeserializable) {
CachedDeserializable cd = (CachedDeserializable)result;
// fix for bug 43023
if (!disableCopyOnRead && isCopyOnRead()) {
result = cd.getDeserializedWritableCopy(null, null);
} else {
result = cd.getDeserializedForReading();
}
} else if (!disableCopyOnRead) {
result = conditionalCopy(result);
}
//For gfxd since the deserialized value is nothing but chunk
// before returning the found value increase its use count
if(GemFireCacheImpl.gfxdSystem() && result instanceof Chunk) {
if(!((Chunk)result).retain()) {
return null;
}
}
// what was a miss is now a hit
RegionEntry re = null;
if (isCreate) {
re = basicGetEntry(key);
updateStatsForGet(re, true);
}
return result;
}
// if value == null, try our own search/load
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
// TODO check a CancelCriterion here?
return null;
}
catch (ExecutionException e) {
// unexpected since there is no background thread
InternalGemFireError err = new InternalGemFireError(LocalizedStrings.LocalRegion_UNEXPECTED_EXCEPTION.toLocalizedString());
err.initCause(err);
throw err;
}
}
// didn't find a future, do one more getDeserialized to catch race
// condition where the future was just removed by another get thread
try {
localValue = getDeserializedValue(null, key, keyInfo.getCallbackArg(),
isCreate, disableCopyOnRead, preferCD, null, clientEvent, false, false/*allowReadFromHDFS*/);
// TODO verify that this method is not used for PR or BR and hence allowReadFromHDFS does not matter
// stats have now been updated
if (localValue != null && !Token.isInvalid(localValue)) {
result = localValue;
return result;
}
isCreate = localValue == null;
result = findObjectInSystem(keyInfo, isCreate, null, generateCallbacks,
localValue, disableCopyOnRead, preferCD, null, clientEvent, returnTombstones, false/*allowReadFromHDFS*/);
if (result == null && localValue != null) {
if (localValue != Token.TOMBSTONE || returnTombstones) {
result = localValue;
}
}
// findObjectInSystem does not call conditionalCopy
}
finally {
VersionTag tag = (clientEvent==null)? null : clientEvent.getVersionTag();
thisFuture.set(new Object[]{result, tag});
this.getFutures.remove(key);
}
if (!disableCopyOnRead) {
result = conditionalCopy(result);
}
return result;
}
/**
* Returns true if get should give a copy; false if a reference.
*
* @since 4.0
*/
protected boolean isCopyOnRead()
{
return this.compressor == null
&& this.cache.isCopyOnRead()
&& ! this.isUsedForPartitionedRegionAdmin
&& ! this.isUsedForMetaRegion
&& ! getEnableOffHeapMemory()
&& ! isSecret();
}
/**
* Makes a copy, if copy-on-get is enabled, of the specified object.
*
* @since 4.0
*/
protected final Object conditionalCopy(Object o) {
if (isCopyOnRead()) {
return makeCopy(o);
}
else {
return o;
}
}
/**
* Makes a copy, if copy-on-get is enabled, of the specified object.
*
* @since 4.0
*/
protected final Object makeCopy(Object o) {
if (!Token.isInvalid(o)) {
return CopyHelper.copy(o);
}
return o;
}
private final String fullPath;
private final ReentrantLock regionLock;
public final String getFullPath() {
return this.fullPath;
}
@Override
public int hashCode() {
return this.fullPath.hashCode();
}
@Override
protected StringBuilder getStringBuilder() {
return super.getStringBuilder().append("; indexUpdater=").append(
getIndexUpdater());
}
// public String getFullPath() {
// // work way up to root region, prepending
// // the region names to a buffer
// StringBuffer buf = new StringBuffer(SEPARATOR);
// Assert.assertTrue(this.regionName != null);
// buf.append(this.regionName);
// LocalRegion r = this;
// while ((r = r.parentRegion) != null) {
// buf.insert(0, r.regionName);
// buf.insert(0, SEPARATOR_CHAR);
// }
// return buf.toString();
// }
public Region getParentRegion()
{
//checkReadiness();
return this.parentRegion;
}
public Region getSubregion(String path)
{
checkReadiness();
return getSubregion(path, false, false);
}
public void invalidateRegion(Object aCallbackArgument)
throws TimeoutException {
getDataView().checkSupportsRegionInvalidate();
validateCallbackArg(aCallbackArgument);
checkReadiness();
checkForLimitedOrNoAccess();
RegionEventImpl event = new RegionEventImpl(this, Operation.REGION_INVALIDATE,
aCallbackArgument, false, getMyId(), generateEventID());
basicInvalidateRegion(event);
}
public Object put(Object key, Object value, Object aCallbackArgument)
throws TimeoutException, CacheWriterException {
long startPut = CachePerfStats.getStatTime();
EntryEventImpl event = newUpdateEntryEvent(key, value, aCallbackArgument);
//Since Gemfirexd directly calls validatedPut, the freeing is done in
// validatedPut
return validatedPut(event, startPut);
// TODO OFFHEAP: validatedPut calls freeOffHeapResources
}
public final Object validatedPut(EntryEventImpl event, long startPut)
throws TimeoutException, CacheWriterException {
try {
operationStart();
if (event.getEventId() == null && generateEventID()) {
event.setNewEventId(cache.getDistributedSystem());
}
Object oldValue = null;
// Gfxd changes begin
// see #40294.
// Rahul: this has to be an update.
// so executing it as an update.
boolean forceUpdateForDelta = event.hasDelta() && !isInternalColumnTable();
// Gfxd Changes end.
if (basicPut(event, false, // ifNew
forceUpdateForDelta, // ifOld
null, // expectedOldValue
false // requireOldValue
)) {
if (!event.isOldValueOffHeap()) {
// don't copy it to heap just to return from put.
// TODO: come up with a better way to do this.
oldValue = event.getOldValue();
}
if (!getDataView(event).isDeferredStats()) {
getCachePerfStats().endPut(startPut, false);
}
}
return handleNotAvailable(oldValue);
} finally {
operationCompleted();
event.release();
}
}
// split into a separate newUpdateEntryEvent since GemFireXD may need to
// manipulate event before doing the put (e.g. posDup flag)
public final EntryEventImpl newUpdateEntryEvent(Object key, Object value,
Object aCallbackArgument) {
validateArguments(key, value, aCallbackArgument);
if (value == null) {
throw new NullPointerException(LocalizedStrings
.LocalRegion_VALUE_MUST_NOT_BE_NULL.toLocalizedString());
}
checkReadiness();
checkForLimitedOrNoAccess();
// This used to call the constructor which took the old value. It
// was modified to call the other EntryEventImpl constructor so that
// an id will be generated by default. Null was passed in anyway.
// generate EventID
final EntryEventImpl event = EntryEventImpl.create(
this, Operation.UPDATE, key,
value, aCallbackArgument, false, getMyId());
boolean eventReturned = false;
try {
extractDeltaIntoEvent(value, event);
eventReturned = true;
return event;
} finally {
if (!eventReturned) event.release();
}
}
/**
* Creates an EntryEventImpl that is optimized to not fetch data from HDFS.
* This is meant to be used by PUT dml from GemFireXD.
*/
public final EntryEventImpl newPutEntryEvent(Object key, Object value,
Object aCallbackArgument) {
EntryEventImpl ev = newUpdateEntryEvent(key, value, aCallbackArgument);
ev.setFetchFromHDFS(false);
ev.setPutDML(true);
return ev;
}
/**
* Get a new unique long UUID that is guaranteed to be unique in the
* distributed system for this region.
*
* @param throwOnOverflow
* if true then throw {@link IllegalStateException} when the UUIDs
* have been exhausted in the distributed system and the system can
* no longer guarantee that the UUID is unique even across VMs that
* may be currently offline
*
* @throws IllegalStateException
* thrown when the UUIDs have been exhausted in the distributed
* system; note that it is not necessary that all possible long
* values would have been used by someone (e.g. a VM goes down
* without using its "block" of IDs)
*/
public final long newUUID(final boolean throwOnOverflow)
throws IllegalStateException {
if (this.uuidAdvisor != null) {
return this.uuidAdvisor.newUUID(throwOnOverflow);
}
// advisor is null for LocalRegions or BucketRegions but currently no UUIDs
// for latter should be requested
if (getScope().isLocal()) {
return this.localUUID.incrementAndGet();
}
else {
throw new InternalGemFireError("unexpected call to newUUID for "
+ toString());
}
}
/**
* Reset the UUID to given start value. It will return a value starting from
* the value provided to this method and the next call to
* {@link #newUUID(boolean)} will return a value greater than it.
*
* @throws IllegalArgumentException
* if the given start value is negative
* @throws IllegalStateException
* if no UUID beyond the given start value can be generated in the
* distributed system
*/
public final long resetUUID(final long startValue)
throws IllegalArgumentException, IllegalStateException {
if (this.uuidAdvisor != null) {
return this.uuidAdvisor.resetUUID(startValue);
}
// advisor is null for LocalRegions or BucketRegions but currently no UUIDs
// for latter should be requested
if (getScope().isLocal()) {
this.localUUID.set(startValue);
return startValue;
}
else {
throw new InternalGemFireError("unexpected call to resetUUID for "
+ toString());
}
}
/**
* Get a new unique integer UUID that is unique in the distributed system for
* this region as long as it does not overflow.
*
* @throws IllegalStateException
* thrown when UUIDs have been exhausted in the distributed system;
* note that it is not necessary that all possible integer values
* would have been used by someone (e.g. a VM goes down without
* using its "block" of IDs)
*/
public final int newShortUUID() throws IllegalStateException {
if (this.uuidAdvisor != null) {
return this.uuidAdvisor.newShortUUID();
}
// advisor is null for LocalRegions or BucketRegions but currently no UUIDs
// for latter should be requested
if (getScope().isLocal()) {
return this.localShortUUID.incrementAndGet();
}
else {
throw new InternalGemFireError("unexpected call to newShortUUID for "
+ toString());
}
}
/**
* Reset the short UUID to given start value. It will return a value starting
* from the value provided to this method and the next call to
* {@link #newShortUUID()} will return a value greater than it.
*
* @throws IllegalArgumentException
* if the given start value is negative
* @throws IllegalStateException
* if no UUID beyond the given start value can be generated in the
* distributed system
*/
public final int resetShortUUID(final int startValue)
throws IllegalArgumentException, IllegalStateException {
if (this.uuidAdvisor != null) {
return this.uuidAdvisor.resetShortUUID(startValue);
}
// advisor is null for LocalRegions or BucketRegions but currently no UUIDs
// for latter should be requested
if (getScope().isLocal()) {
this.localShortUUID.set(startValue);
return startValue;
}
else {
throw new InternalGemFireError("unexpected call to resetShortUUID for "
+ toString());
}
}
private void extractDeltaIntoEvent(Object value, EntryEventImpl event) {
// 1. Check for DS-level delta property.
// 2. Default value for operation type is UPDATE, so no need to check that here.
// 3. Check if it has server region proxy.
// We do not have a handle to event in PutOpImpl to check if we have
// delta bytes calculated already. So no need to calculate it here.
// 4. Check if value is instanceof com.gemstone.gemfire.Delta
// 5. Check if Region in PR with redundantCopies > 0. Set extractDelta.
// 6. Check if Region has peers. Set extractDelta.
// 7. Check if it has any delta proxies attached to it. Set extractDelta.
// 8. If extractDelta is set, check if it has delta.
// 9. If delta is found, extract it and set it into the event.
// 10. If any exception is caught while invoking the delta callbacks, throw it back.
// 11. Wrap any checked exception in InternalGemFireException before throwing it.
try {
boolean extractDelta = false;
// How costly is this if check?
if (this.getSystem().getConfig().getDeltaPropagation()
&& value instanceof com.gemstone.gemfire.Delta) {
if (!this.hasServerProxy()) {
if ((this instanceof PartitionedRegion)) {
if (((PartitionedRegion)this).getRedundantCopies() > 0) {
extractDelta = true;
} else {
InternalDistributedMember ids = (InternalDistributedMember)PartitionRegionHelper
.getPrimaryMemberForKey(this, event.getKey());
if (ids != null) {
extractDelta = !this.getSystem().getMemberId().equals(
ids.getId());
} else {
extractDelta = true;
}
}
} else if ((this instanceof DistributedRegion)
&& !((DistributedRegion)this).scope.isDistributedNoAck()
&& ((DistributedRegion)this).getCacheDistributionAdvisor()
.adviseCacheOp().size() > 0) {
extractDelta = true;
}
if (!extractDelta && ClientHealthMonitor.getInstance() != null) {
extractDelta = ClientHealthMonitor.getInstance().hasDeltaClients();
}
} else if (HandShake.isDeltaEnabledOnServer()) {
// This is a client region
extractDelta = true;
}
final com.gemstone.gemfire.Delta delta = (com.gemstone.gemfire.Delta)value;
if (extractDelta && delta.hasDelta()) {
HeapDataOutputStream hdos = new HeapDataOutputStream(Version.CURRENT);
long start = DistributionStats.getStatTime();
try {
delta.toDelta(hdos);
} catch (RuntimeException re) {
throw re;
} catch (Exception e) {
throw new DeltaSerializationException(
LocalizedStrings.DistributionManager_CAUGHT_EXCEPTION_WHILE_SENDING_DELTA
.toLocalizedString(), e);
}
event.setDeltaBytes(hdos.toByteArray());
this.getCachePerfStats().endDeltaPrepared(start);
}
}
} catch (RuntimeException re) {
throw re;
} catch (Exception e) {
throw new InternalGemFireException(e);
}
}
public final Region.Entry getEntry(Object key) {
try {
operationStart();
return getEntry(key, discoverJTA());
} finally {
operationCompleted();
}
}
public Region.Entry getEntry(Object key, final TXStateInterface tx) {
validateKey(key);
checkReadiness();
checkForNoAccess();
return getDataView(tx).getEntry(key, null, this, false);
}
/** internally we often need to get an entry whether it is a tombstone or not */
public final Region.Entry getEntry(Object key, boolean allowTombstones) {
return getEntry(key, discoverJTA(), allowTombstones);
}
/** internally we often need to get an entry whether it is a tombstone or not */
public Region.Entry getEntry(Object key, final TXStateInterface tx,
boolean allowTombstones) {
try {
operationStart();
return getDataView(tx).getEntry(key, null, this, allowTombstones);
} finally {
operationCompleted();
}
}
public final Region.Entry accessEntry(final Object key,
boolean updateStats) {
return accessEntry(key, getTXState(), updateStats);
}
/**
* Just like getEntry but also updates the stats that get would have depending
* on a flag. See bug 42410. Also skips discovering JTA
*
* @param key
* @return the entry if it exists; otherwise null.
*/
public Region.Entry accessEntry(final Object key,
final TXStateInterface tx, boolean updateStats) {
validateKey(key);
checkReadiness();
checkForNoAccess();
if(updateStats) {
return getDataView(tx).accessEntry(key, null, this);
} else {
return getDataView(tx).getEntry(key, null, this, false);
}
}
/**
* @param keyInfo
* @param access
* true if caller wants last accessed time updated
* @return TODO
*/
protected Region.Entry txGetEntry(KeyInfo keyInfo, boolean access,
final TXStateInterface tx, boolean allowTombstones) {
final Object key = keyInfo.getKey();
final RegionEntry re = this.entries.getEntry(key);
return txGetEntry(re, key, access, tx, allowTombstones);
}
private final Region.Entry txGetEntry(final RegionEntry re,
final Object key, boolean access, final TXStateInterface lockState,
boolean allowTombstones) {
final boolean miss;
Object val = null;
if (re != null) {
// for txns, acquire read lock if required
if (lockState != null) {
val = lockState.lockEntryForRead(re, key, this, 0,
allowTombstones, READ_VALUE);
if (Token.isRemoved(val)) {
val = null;
}
miss = (val == null);
}
else {
miss = re.isDestroyedOrRemoved();
}
}
else {
miss = true;
}
if (access) {
updateStatsForGet(re, !miss);
}
if (re == null) {
return null;
}
if (re.isTombstone()) {
if (!allowTombstones) {
return null;
} // else return an entry (client GII / putAll results)
} else if (miss) {
return null;
}
Region.Entry ren = new NonTXEntry(re, val);
//long start=0, end=0;
//start = System.currentTimeMillis();
//end = System.currentTimeMillis();
//System.out.println("getEntry: " + (end-start));
return ren;
}
protected Region.Entry txGetEntryForIterator(KeyInfo keyInfo,
boolean access, final TXStateInterface tx, boolean allowTombstones) {
final RegionEntry re = (RegionEntry)keyInfo.getKey();
return txGetEntry(re, re.getKey(), access, tx, allowTombstones);
}
/**
* Get the best iterator for iterating over the contents of this
* region. This method will return either an iterator that uses hash
* ordering from the entry map, or, in the case of an overflow
* region, an iterator that iterates over the entries in disk order (except if
* the region is an internal one which will always return hash iterator)
*/
public Iterator getBestLocalIterator(boolean includeValues) {
return getBestLocalIterator(includeValues, 1.0, false);
}
final long getDiskIteratorCacheSize(double reduceCacheFactor) {
if (includeHDFSResults()) {
return -1;
}
if (getDiskRegion() != null && isOverflowEnabled() &&
!isUsedForMetaRegion() && !isUsedForPartitionedRegionAdmin()) {
//Wait for the disk region to recover values first.
// Commenting it as it was causing a distributed deadlock if there is
// a GII happpening from remote node in case of gemfireXD
// the value recovery waits for index recovery to happen which in turn
// waits for DDL replay to complete. So, if two different nodes have
// latest DISK STORES for two regions then it can cause a distributed deadlock.
// Bug 52317
//dr.waitForAsyncRecovery();
long cacheSize = DistributedRegion.MAX_PENDING_ENTRIES;
if (reduceCacheFactor > 0.0 && reduceCacheFactor != 1.0) {
cacheSize = (long)(cacheSize / reduceCacheFactor);
}
return cacheSize;
}
return -1;
}
protected boolean includeHDFSResults() {
return isUsedForPartitionedRegionBucket()
&& isHDFSReadWriteRegion()
&& getPartitionedRegion().includeHDFSResults();
}
static long adjustDiskIterCacheSize(long cacheSize, long numEntries) {
return Math.max(Math.min(cacheSize, numEntries + 256), 8192L);
}
/**
* Get the best iterator for iterating over the contents of this local region.
* This method will return either an iterator that uses hash ordering from the
* entry map, or, in the case of an overflow region, an iterator that iterates
* over the entries in disk order (except if the region is an internal one
* which will always return a hash map iterator).
*/
public Iterator getBestLocalIterator(boolean includeValues,
double reduceCacheFactor, boolean keepDiskMap) {
if (includeValues && DiskBlockSortManager.DISK_PAGE_SIZE > 0) {
final long cacheSize = getDiskIteratorCacheSize(reduceCacheFactor);
if (cacheSize >= 0) {
// if total region size is smaller then reduce the cache size
return new DiskSavyIterator(this, adjustDiskIterCacheSize(
cacheSize, getEstimatedLocalSize()), keepDiskMap);
}
}
return this.entries.regionEntries().iterator();
}
/**
* Get the best iterator for iterating over the contents of this local region.
* This method will return either an iterator that uses hash ordering from the
* entry map, or, in the case of an overflow region, an iterator that iterates
* over the entries in disk order (except if the region is an internal one
* which will always return a hash map iterator).
*/
public Iterator getBestLocalIterator(
final long cacheSize, boolean keepDiskMap) {
if (DiskBlockSortManager.DISK_PAGE_SIZE > 0
&& getDiskIteratorCacheSize(1.0) >= 0) {
// if total region size is smaller then reduce the cache size
return new DiskSavyIterator(this, cacheSize, keepDiskMap);
}
return this.entries.regionEntries().iterator();
}
/** a fast estimate of total number of entries locally in the region */
public long getEstimatedLocalSize() {
RegionMap rm;
if (!this.isDestroyed) {
long size;
if (isHDFSReadWriteRegion() && this.initialized) {
// this size is not used by HDFS region iterators
// fixes bug 49239
return 0;
}
// if region has not been initialized yet, then get the estimate from
// disk region's recovery map if available
if (!this.initialized && this.diskRegion != null
&& (rm = this.diskRegion.getRecoveredEntryMap()) != null
&& (size = rm.size()) > 0) {
return size;
}
if ((rm = getRegionMap()) != null) {
return rm.size();
}
}
return 0;
}
/**
* @param key
* @param callbackArg
* @param access
* true if caller wants last accessed time updated
* @param allowTombstones whether an entry with a TOMBSTONE value can be returned
* @return TODO
*/
protected Region.Entry nonTXGetEntry(final Object key,
final Object callbackArg, final boolean access, boolean allowTombstones) {
final RegionEntry re = this.entries.getEntry(key);
boolean miss = (re == null || re.isDestroyedOrRemoved());
if (access) {
updateStatsForGet(re, !miss);
}
if (re == null) {
return null;
}
if (re.isTombstone()) {
if (!allowTombstones) {
return null;
} // else return an entry (client GII / putAll results)
} else if (miss) {
return null;
}
Region.Entry ren = new NonTXEntry(re);
//long start=0, end=0;
//start = System.currentTimeMillis();
//end = System.currentTimeMillis();
//System.out.println("getEntry: " + (end-start));
return ren;
}
/**
* @return boolean
*/
protected final boolean isClosed()
{
return this.cache.isClosed();
}
/**
* Returns true if this region is or has been closed or destroyed.
* Note that unlike {@link #isDestroyed()} this method will not
* return true if the cache is closing but has not yet started closing
* this region.
*/
public boolean isThisRegionBeingClosedOrDestroyed() {
return this.isDestroyed;
}
/** returns true if this region has been destroyed */
public boolean isDestroyed() {
if (!this.isDestroyed && !isClosed()) {
return false;
}
LogWriterI18n log = getCache().getLoggerI18n();
if (log.finestEnabled()) {
log.finest("isDestroyed: true, this.isDestroyed: " + getFullPath());
}
return true;
/*
if (isClosed()) {
return true; // for bug 42328
}
LogWriterI18n log = getCache().getLoggerI18n();
boolean finestEnabled = log.finestEnabled();
// boolean result = false;
if (this.isDestroyed) {
if (finestEnabled) {
log.finest("isDestroyed: true, this.isDestroyed: " + getFullPath());
}
return true;
}
// if (!isInitialized()) { // don't return true if still initializing
// if (finestEnabled) {
// log.finest("isDestroyed: false, not initialized: " + getFullPath());
// }
// return false;
// }
// @todo we could check parents here if we want this to be more accurate,
// and the isDestroyed field could be made volatile as well.
// if (this.parentRegion != null) return this.parentRegion.isDestroyed();
if (finestEnabled) {
log.finest("isDestroyed: false : " + getFullPath());
}
return false;
*/
}
/** a variant of subregions() that does not perform a readiness check */
protected Set basicSubregions(boolean recursive) {
return new SubregionsSet(recursive);
}
public Set subregions(boolean recursive) {
checkReadiness();
return new SubregionsSet(recursive);
}
public Set entries(boolean recursive) {
checkReadiness();
checkForNoAccess();
return basicEntries(recursive);
}
/** Returns set of entries without performing validation checks. */
public Set basicEntries(boolean recursive) {
return new EntriesSet(this, recursive, IteratorType.ENTRIES, false);
}
/**
* Flavor of keys that will not do repeatable read
* @since 5.5
*/
public Set testHookKeys()
{
checkReadiness();
checkForNoAccess();
return new EntriesSet(this, false, IteratorType.KEYS,
false /* allowTombstones */);
}
public Set keys()
{
checkReadiness();
checkForNoAccess();
return new EntriesSet(this, false, IteratorType.KEYS, false);
}
/**
* return a set of the keys in this region
* @param allowTombstones whether destroyed entries should be included
* @return the keys
*/
public Set keySet(boolean allowTombstones) {
checkReadiness();
checkForNoAccess();
return new EntriesSet(this, false, IteratorType.KEYS, allowTombstones);
}
public Collection values()
{
checkReadiness();
checkForNoAccess();
return new EntriesSet(this, false, IteratorType.VALUES, false);
}
public Object getUserAttribute()
{
return this.regionUserAttribute;
}
public void setUserAttribute(Object value)
{
checkReadiness();
this.regionUserAttribute = value;
}
public final boolean containsKey(Object key) {
try {
operationStart();
return containsKey(key, null);
} finally {
operationCompleted();
}
}
public boolean containsKey(Object key, Object callbackArg) {
checkReadiness();
checkForNoAccess();
return getDataView().containsKey(key, callbackArg, this);
}
public boolean containsTombstone(Object key)
{
checkReadiness();
checkForNoAccess();
if (!this.concurrencyChecksEnabled) {
return false;
} else {
try {
Entry entry = getDataView().getEntry(key, null, this, true);
if (entry == null) {
return false;
} else {
return (entry.getValue() == Token.TOMBSTONE);
}
} catch (EntryDestroyedException e) {
return true;
}
}
}
/**
* Check key present in region while acquiring a read lock on entry for
* transaction. Used by non-transactional containsKey, TXState's containsKey,
* and also by GemFireXD for transactional foreign key checks.
*/
public boolean txContainsKey(final Object key, final Object callbackArg,
final TXStateInterface tx, final boolean explicitReadOnlyLock) {
checkReadiness();
checkForNoAccess();
if (explicitReadOnlyLock) {
return getDataView(tx).containsKeyWithReadLock(key, callbackArg, this);
}
else {
// fix for bug #40871 - concurrent RI causes containsKey for destroyed
// entry to return true
// [sumedh] code below also works fine for !imageState.isClient()
// (is identical to that in RegionMap#containsKey())
final RegionEntry re = this.entries.getEntry(key);
if (re != null) {
// for txns, acquire read lock if required
if (tx != null) {
Object val = tx.lockEntryForRead(re, key, this, 0, false, READ_TOKEN);
return !Token.isRemoved(val);
}
else {
return !re.isDestroyedOrRemoved();
}
}
else {
return false;
}
}
}
public boolean containsValueForKey(Object key) {
try {
operationStart();
final TXStateInterface tx = discoverJTA();
return getDataView(tx).containsValueForKey(key, null, this);
} finally {
operationCompleted();
}
}
/**
* @param key
* @return TODO
*/
protected boolean txContainsValueForKey(final Object key,
final Object callbackArg, final TXStateInterface lockState) {
checkReadiness();
checkForNoAccess();
if (this.diskRegion != null) {
this.diskRegion.setClearCountReference();
}
try {
final RegionEntry entry = this.entries.getEntry(key);
if (entry != null) {
@Retained Object val;
if (lockState != null) {
// for txns, acquire read lock if required
val = lockState.lockEntryForRead(entry, key, this, 0, false,
READ_VALUE_RETAIN);
return containsValueInternal(val);
}
else {
// no need to decompress since we only want to know
// if we have an existing value
SimpleMemoryAllocatorImpl.skipRefCountTracking();
val = entry._getValueRetain(this, false);
boolean result = containsValueInternal(val);
SimpleMemoryAllocatorImpl.unskipRefCountTracking();
return result;
}
}
return false;
}
finally {
if (this.diskRegion != null) {
this.diskRegion.removeClearCountReference();
}
}
}
protected final boolean containsValueInternal(@Released Object val) {
// updates received via CacheClientUpdater stores a CacheDeserializable
// even for null values, hence do this check
if (val instanceof StoredObject) {
OffHeapHelper.release(val);
return true;
}
// this works because INVALID and LOCAL_INVALID will never be faulted out of mem
// If val is NOT_AVAILABLE that means we have a valid value on disk.
return !Token.isInvalidOrRemoved(val);
}
/**
* attributes for HDFS regions that hide eviction attributes.
*/
private RegionAttributes largeRegionAttrs = null;
public RegionAttributes getAttributes() {
// to fix bug 35134 allow attribute access on closed regions
//checkReadiness();
return this;
}
public final String getName() {
return this.regionName;
}
/**
* Convenience method to get region name for logging/exception messages.
* if this region is an instanceof bucket region, it returns the
* bucket region name
* @return name of the region or the owning partitioned region
*/
public String getDisplayName() {
if (this.isUsedForPartitionedRegionBucket()) {
return this.getPartitionedRegion().getName();
}
return this.regionName;
}
/**
* Returns the number of entries in this region. Note that because of the
* concurrency properties of the {@link RegionMap}, the number of entries is
* only an approximate. That is, other threads may change the number of
* entries in this region while this method is being invoked.
*
* @see RegionMap#size
*
* author David Whitlock
*/
public final int entryCount() {
return entryCount(getTXState());
}
/**
* Returns the number of entries in this region. Note that because of the
* concurrency properties of the {@link RegionMap}, the number of entries is
* only an approximate. That is, other threads may change the number of
* entries in this region while this method is being invoked.
*
* @see RegionMap#size
*
* author David Whitlock
*/
public final int entryCount(final TXStateInterface tx) {
return entryCount(tx, null);
}
public int entryCount(final TXStateInterface tx, Set buckets) {
return entryCount(tx, buckets, false);
}
protected int entryCount(final TXStateInterface tx, Set buckets, boolean estimate) {
assert buckets == null: "unexpected buckets " + buckets + " for region "
+ toString();
return getDataView(tx).entryCount(this);
}
public int entryCountEstimate(final TXStateInterface tx, Set buckets, boolean entryCountEstimate) {
return entryCount(tx, buckets, entryCountEstimate);
}
/**
* @return size after considering imageState and TX uncommitted entries
*/
public int getRegionSize() {
int result;
final boolean includeHDFSResults = includeHDFSResults();
final ReentrantLock regionLock = getSizeGuard();
if (regionLock == null) {
result = getRegionSizeNoLock(includeHDFSResults);
}
else {
regionLock.lock();
try {
result = getRegionSizeNoLock(includeHDFSResults);
} finally {
regionLock.unlock();
}
}
// decrement the uncommitted entries that have been created for TX locking
// in case of HDFS, size operation the iterator doesn't consider
// tx created entries anyway
if (!includeHDFSResults) {
result -= this.txLockCreateCount.get();
}
if (result > 0) {
return result;
}
else {
return 0;
}
}
private int getRegionSizeNoLock(boolean includeHDFSResults) {
int result = getRegionMap().size();
// if this is a client with no tombstones then we subtract the number
// of entries being affected by register-interest refresh
if (this.imageState.isClient() && !this.concurrencyChecksEnabled) {
result -= this.imageState.getDestroyedEntriesCount();
}
if (includeHDFSResults) {
return result;
}
else {
return result - this.tombstoneCount.get();
}
}
/**
* Returns the DiskRegion that this region uses to access data
* on disk.
*
* @return null if disk regions are not being used
*
* @since 3.2
*/
public final DiskRegion getDiskRegion() {
return this.diskRegion;
}
public DiskRegionView getDiskRegionView() {
return getDiskRegion();
}
public boolean isBackup() {
return getDiskRegion().isBackup();
}
@Override
public void updateMemoryStats(Object oldValue, Object newValue) {
// only used by BucketRegion as of now
}
/**
* Lets the customer do an explicit evict of a value to disk and removes the value
* from memory. This was added for customer.
*/
public void evictValue(Object key) {
if (getDiskRegion() != null) {
this.entries.evictValue(key);
}
}
/**
*
* Initially called by EvictorThread.run
*
* @since 3.5.1
*/
public void checkLRU()
{
if (this.entriesInitialized) {
try {
this.entries.lruUpdateCallback();
}catch( DiskAccessException dae) {
this.handleDiskAccessException(dae, true /* stop bridge servers*/);
throw dae;
}
}
}
public boolean isOverflowEnabled() {
EvictionAttributes ea = getAttributes().getEvictionAttributes();
return ea != null && ea.getAction().isOverflowToDisk();
}
public void writeToDisk()
{
if (this.diskRegion == null) {
DataPolicy dp = getDataPolicy();
if (dp == DataPolicy.EMPTY) {
throw new IllegalStateException(LocalizedStrings.LocalRegion_CANNOT_WRITE_A_REGION_WITH_DATAPOLICY_0_TO_DISK.toLocalizedString(dp));
}
else if (!dp.withPersistence() && !isOverflowEnabled()) {
throw new IllegalStateException(LocalizedStrings.LocalRegion_CANNOT_WRITE_A_REGION_THAT_IS_NOT_CONFIGURED_TO_ACCESS_DISKS.toLocalizedString());
}
}
else {
this.diskRegion.asynchForceFlush();
}
}
/**
* Used by tests to force everything out to disk.
*/
public void forceFlush()
{
if (this.diskRegion != null) {
this.diskRegion.flushForTesting();
}
}
/**
* This implementation only checks readiness and scope
*/
public Lock getRegionDistributedLock() throws IllegalStateException
{
checkReadiness();
checkForLimitedOrNoAccess();
Scope theScope = getAttributes().getScope();
Assert.assertTrue(theScope == Scope.LOCAL);
throw new IllegalStateException(LocalizedStrings.LocalRegion_ONLY_SUPPORTED_FOR_GLOBAL_SCOPE_NOT_LOCAL.toLocalizedString());
}
/**
* This implementation only checks readiness and scope
*/
public Lock getDistributedLock(Object key) throws IllegalStateException
{
checkReadiness();
checkForLimitedOrNoAccess();
Scope theScope = getAttributes().getScope();
Assert.assertTrue(theScope == Scope.LOCAL);
throw new IllegalStateException(LocalizedStrings.LocalRegion_ONLY_SUPPORTED_FOR_GLOBAL_SCOPE_NOT_LOCAL.toLocalizedString());
}
public void invalidate(Object key, Object aCallbackArgument)
throws TimeoutException, EntryNotFoundException
{
try{
operationStart();
checkReadiness();
checkForLimitedOrNoAccess();
validatedInvalidate(key, aCallbackArgument);
} finally {
operationCompleted();
}
}
/**
* Destroys entry without performing validations. Call this after validating
* key, callback arg, and runtime state.
*/
protected void validatedInvalidate(Object key, Object aCallbackArgument)
throws TimeoutException, EntryNotFoundException
{
EntryEventImpl event = EntryEventImpl.create(
this, Operation.INVALIDATE,
key, null, aCallbackArgument, false, getMyId());
try {
if (generateEventID()) {
event.setNewEventId(cache.getDistributedSystem());
}
basicInvalidate(event);
} finally {
event.release();
}
}
public void localDestroy(Object key, Object aCallbackArgument)
throws EntryNotFoundException
{
validateKey(key);
checkReadiness();
checkForNoAccess();
EntryEventImpl event = EntryEventImpl.create(this, Operation.LOCAL_DESTROY,
key, null, aCallbackArgument, false, getMyId());
if (generateEventID()) {
event.setNewEventId(cache.getDistributedSystem());
}
try {
basicDestroy(event,
false,
null); // expectedOldValue
}
catch (CacheWriterException e) {
// cache writer not called
throw new Error(LocalizedStrings.LocalRegion_CACHE_WRITER_SHOULD_NOT_HAVE_BEEN_CALLED_FOR_LOCALDESTROY.toLocalizedString(), e);
}
catch (TimeoutException e) {
// no distributed lock
throw new Error(LocalizedStrings.LocalRegion_NO_DISTRIBUTED_LOCK_SHOULD_HAVE_BEEN_ATTEMPTED_FOR_LOCALDESTROY.toLocalizedString(), e);
} finally {
event.release();
}
}
public void localDestroyRegion(Object aCallbackArgument)
{
getDataView().checkSupportsRegionDestroy();
RegionEventImpl event = new RegionEventImpl(this,
Operation.REGION_LOCAL_DESTROY, aCallbackArgument, false, getMyId(),
generateEventID()/* generate EventID */);
try {
basicDestroyRegion(event, false);
}
catch (CacheWriterException e) {
// not possible with local operation, CacheWriter not called
throw new Error(LocalizedStrings.LocalRegion_CACHEWRITEREXCEPTION_SHOULD_NOT_BE_THROWN_IN_LOCALDESTROYREGION.toLocalizedString(), e);
}
catch (TimeoutException e) {
// not possible with local operation, no distributed locks possible
throw new Error(LocalizedStrings.LocalRegion_TIMEOUTEXCEPTION_SHOULD_NOT_BE_THROWN_IN_LOCALDESTROYREGION.toLocalizedString(), e);
}
}
public final void close() {
RegionEventImpl event = new RegionEventImpl(this, Operation.REGION_CLOSE,
null, false, getMyId(), generateEventID()/* generate EventID */);
close(event);
}
public void close(RegionEventImpl event) {
try {
// NOTE: the 422dynamicRegions branch added the callbackEvents argument
// to basicDestroyRegion and inhibited events on region.close. This
// clashed with the new SystemMemberCacheListener functionality in
// 5.0, causing unit tests to fail
basicDestroyRegion(event, false, true, true);
}
catch (CacheWriterException e) {
// not possible with local operation, CacheWriter not called
throw new Error(LocalizedStrings.LocalRegion_CACHEWRITEREXCEPTION_SHOULD_NOT_BE_THROWN_IN_LOCALDESTROYREGION.toLocalizedString(), e);
}
catch (TimeoutException e) {
// not possible with local operation, no distributed locks possible
throw new Error(LocalizedStrings.LocalRegion_TIMEOUTEXCEPTION_SHOULD_NOT_BE_THROWN_IN_LOCALDESTROYREGION.toLocalizedString(), e);
}
}
public void localInvalidate(Object key, Object callbackArgument)
throws EntryNotFoundException
{
validateKey(key);
checkReadiness();
checkForNoAccess();
EntryEventImpl event = EntryEventImpl.create(
this,
Operation.LOCAL_INVALIDATE, key, null/* newValue */, callbackArgument,
false, getMyId());
try {
operationStart();
if (generateEventID()) {
event.setNewEventId(cache.getDistributedSystem());
}
event.setLocalInvalid(true);
basicInvalidate(event);
} finally {
event.release();
operationCompleted();
}
}
public void localInvalidateRegion(Object aCallbackArgument) {
getDataView().checkSupportsRegionInvalidate();
checkReadiness();
checkForNoAccess();
RegionEventImpl event = new RegionEventImpl(this,
Operation.REGION_LOCAL_INVALIDATE, aCallbackArgument, false, getMyId());
basicInvalidateRegion(event);
}
/**
* Look up the LocalRegion with the specified full path.
*
* @param system
* the distributed system whose cache contains the root of interest
* @return the LocalRegion or null if not found
*/
public static LocalRegion getRegionFromPath(DistributedSystem system,
String path)
{
Cache c = GemFireCacheImpl.getInstance();
if(c==null) {
return null;
} else {
return (LocalRegion)c.getRegion(path);
}
}
// public void dumpEntryMapStats(PrintStream out) {
// ((ConcurrentHashMap)this.entries).dumpStats(out);
// }
public void preInitialize(InternalRegionArguments internalRegionArgs) {
// if we're versioning entries we need a region-level version vector
if (this.concurrencyChecksEnabled && this.versionVector == null) {
createVersionVector();
}
DiskRegion dskRgn = getDiskRegion();
if(dskRgn != null && dskRgn.isRecreated()) {
getLogWriterI18n()
.fine("DistributedRegion.getInitialImageAndRecovery: Starting Recovery");
dskRgn.initializeOwner(this, internalRegionArgs); // do recovery
getLogWriterI18n()
.fine("DistributedRegion.getInitialImageAndRecovery: Finished Recovery");
}
}
////////////////// Protected Methods ////////////////////////////////////////
/**
* Do any extra initialization required. Region is already visible in parent's
* subregion map. This method releases the initialization Latches, so
* subclasses should call this super method last after performing additional
* initialization.
*
* @param imageTarget
* ignored, used by subclass for get initial image
* @param internalRegionArgs
* @see DistributedRegion#initialize(InputStream, InternalDistributedMember, InternalRegionArguments)
*/
protected void initialize(InputStream snapshotInputStream,
InternalDistributedMember imageTarget,
InternalRegionArguments internalRegionArgs) throws TimeoutException,
IOException, ClassNotFoundException {
LogWriterI18n logger = getCache().getLoggerI18n();
if (!isInternalRegion()) {
// Subclasses may have already called this method, but this is
// acceptable because addResourceListener won't add it twice
if (!this.isDestroyed) {
cache.getResourceManager().addResourceListener(ResourceType.MEMORY, this);
}
}
// if not local, then recovery happens in InitialImageOperation
if (this.scope.isLocal() && this.diskRegion != null) {
try {
this.diskRegion.finishInitializeOwner(this, GIIStatus.NO_GII);
{ // This block was added so that early recovery could figure out that
// this data needs to be recovered from disk. Local regions used to
// not bother assigning a memberId but that is what the early recovery
// code uses to figure out that a region needs to be recovered.
PersistentMemberID oldId = this.diskRegion.getMyInitializingID();
if (oldId == null) {
oldId = this.diskRegion.getMyPersistentID();
}
if (oldId == null) {
PersistentMemberID newId = this.diskRegion.generatePersistentID();
this.diskRegion.setInitializing(newId);
this.diskRegion.setInitialized();
}
}
}catch(DiskAccessException dae) {
releaseAfterRegionCreateEventLatch();
this.handleDiskAccessException(dae,
false /* Do stop bridge servers*/, true);
throw dae;
}
}
// make sure latches are released if they haven't been by now already
releaseBeforeGetInitialImageLatch();
if (snapshotInputStream != null && this.scope.isLocal()) {
try {
loadSnapshotDuringInitialization(snapshotInputStream);
}catch(DiskAccessException dae) {
releaseAfterRegionCreateEventLatch();
this.handleDiskAccessException(dae, false /* Do not stop bridge servers*/);
throw dae;
}
}
releaseAfterGetInitialImageLatch();
if (this.uuidAdvisor != null) {
this.uuidAdvisor.postInitialize();
}
if (logger.fineEnabled()) {
logger.fine("Calling addExpiryTasks for " + this);
}
// these calls can throw RegionDestroyedException if this region is
// destroyed
// at this point
try {
addIdleExpiryTask();
addTTLExpiryTask();
if (isEntryExpiryPossible()) {
rescheduleEntryExpiryTasks(); // called after gii to fix bug 35214
}
this.accountRegionOverhead();
initialized();
}
catch (RegionDestroyedException e) {
// whether it is this region or a parent region that is destroyed,
// then so must we be
Assert.assertTrue(isDestroyed());
// just proceed, a destroyed region will be returned to caller
}
}
protected void createOQLIndexes(InternalRegionArguments internalRegionArgs) {
if (internalRegionArgs == null || internalRegionArgs.getIndexes() == null){
return;
}
LogWriterI18n logger = getSystem().getLogWriter().convertToLogWriterI18n();
if (logger.fineEnabled()){
logger.fine("LocalRegion.createOQLIndexes on region " + this.getFullPath());
}
List oqlIndexes = internalRegionArgs.getIndexes();
if (this.indexManager == null) {
this.indexManager = IndexUtils.getIndexManager(this, true);
}
int initLevel = 0;
try {
// Release the initialization latch for index creation.
initLevel = LocalRegion.setThreadInitLevelRequirement(ANY_INIT);
for (Object o : oqlIndexes) {
IndexCreationData icd = (IndexCreationData)o;
try {
if (icd.getPartitionedIndex() != null) {
ExecutionContext externalContext = new ExecutionContext(null, this.cache);
if (internalRegionArgs.getPartitionedRegion() != null) {
externalContext.setBucketRegion(internalRegionArgs.getPartitionedRegion(), (BucketRegion)this);
}
if (logger.fineEnabled()){
logger.fine("IndexManager Index creation process for " + icd.getIndexName());
}
this.indexManager.createIndex(icd.getIndexName(), icd.getIndexType(),
icd.getIndexExpression(), icd.getIndexFromClause(),
icd.getIndexImportString(), externalContext, icd.getPartitionedIndex());
} else {
if (logger.fineEnabled()){
logger.fine("QueryService Index creation process for " + icd.getIndexName());
}
QueryService qs = this.getGemFireCache().getLocalQueryService();
String fromClause = (icd.getIndexType() == IndexType.FUNCTIONAL || icd.getIndexType() == IndexType.HASH)? icd.getIndexFromClause() : this.getFullPath();
qs.createIndex(icd.getIndexName(), icd.getIndexType(), icd.getIndexExpression(), fromClause, icd.getIndexImportString());
}
} catch (Exception ex) {
if (logger.fineEnabled()) {
logger.fine("Failed to create index " + icd.getIndexName() +
" on region " + this.getFullPath() + ex.getMessage());
}
// Check if the region index creation is from cache.xml, in that case throw exception.
// Other case is when bucket regions are created dynamically, in that case ignore the exception.
if (internalRegionArgs.getDeclarativeIndexCreation()) {
InternalGemFireError err = new InternalGemFireError(LocalizedStrings.GemFireCache_INDEX_CREATION_EXCEPTION_1.toLocalizedString(new Object[] {icd.getIndexName(), this.getFullPath()}) );
err.initCause(ex);
throw err;
}
}
}
} finally {
// Reset the initialization lock.
LocalRegion.setThreadInitLevelRequirement(initLevel);
}
}
/**
* The region is now fully initialized, as far as LocalRegion is concerned
*/
public void initialized() {
// does nothing in LocalRegion at this time
}
protected void releaseLatches()
{
releaseBeforeGetInitialImageLatch();
releaseAfterGetInitialImageLatch();
releaseAfterRegionCreateEventLatch();
}
protected void releaseBeforeGetInitialImageLatch()
{
LogWriterI18n logger = getCache().getLoggerI18n();
if (logger.fineEnabled()) {
logger.fine("Releasing Initialization Latch (before initial image) for "
+ getFullPath());
}
releaseLatch(this.initializationLatchBeforeGetInitialImage);
}
protected final void releaseAfterGetInitialImageLatch() {
LogWriterI18n logger = getCache().getLoggerI18n();
if (logger.fineEnabled()) {
logger.fine("Releasing Initialization Latch (after initial image) for "
+ getFullPath());
}
releaseLatch(this.initializationLatchAfterGetInitialImage);
}
protected final void readLockEnqueueDelta() {
deltaLock.readLock().lock();
}
protected final void readUnlockEnqueueDelta() {
deltaLock.readLock().unlock();
}
protected final void writeLockEnqueueDelta() {
deltaLock.writeLock().lock();
}
protected final void writeUnlockEnqueueDelta() {
deltaLock.writeLock().unlock();
}
/**
* Called after we have delivered our REGION_CREATE event.
*
* @since 5.0
*/
private void releaseAfterRegionCreateEventLatch()
{
releaseLatch(this.afterRegionCreateEventLatch);
}
/**
* Used to cause cache listener events to wait until the after region create
* event is delivered.
*
* @since 5.0
*/
private void waitForRegionCreateEvent()
{
StoppableCountDownLatch l = this.afterRegionCreateEventLatch;
if (l != null && l.getCount() == 0) {
return;
}
waitOnInitialization(l);
}
private static void releaseLatch(StoppableCountDownLatch latch)
{
if (latch == null)
return;
latch.countDown();
}
/**
* Removes entries and recursively destroys subregions.
*
* @param eventSet
* collects the events for all destroyed regions if null, then we're
* closing so don't send events to callbacks or destroy the disk
* region
*/
private void recursiveDestroyRegion(Set eventSet, RegionEventImpl p_event,
boolean cacheWrite) throws CacheWriterException, TimeoutException
{
RegionEventImpl event = p_event;
final boolean isClose = event.getOperation().isClose();
// do the cacheWriter beforeRegionDestroy first to fix bug 47736
if (eventSet != null && cacheWrite) {
try {
cacheWriteBeforeRegionDestroy(event);
}
catch (CancelException e) {
// I don't think this should ever happens: bulletproofing for bug 39454
if (!cache.forcedDisconnect()) {
cache.getLoggerI18n().warning(
LocalizedStrings.LocalRegion_RECURSIVEDESTROYREGION_PROBLEM_IN_CACHEWRITEBEFOREREGIONDESTROY, e);
}
}
}
if (this.eventTracker != null) {
this.eventTracker.stop();
}
if (RegionVersionVector.DEBUG && getVersionVector() != null) {
getLogWriterI18n().fine("version vector for " + getName() + " is " + getVersionVector().fullToString());
}
cancelTTLExpiryTask();
cancelIdleExpiryTask();
cancelAllEntryExpiryTasks();
cancelEvictorService();
if (!isInternalRegion()) {
getCachePerfStats().incRegions(-1);
}
cache.getResourceManager(false).removeResourceListener(this);
if (getMembershipAttributes().hasRequiredRoles()) {
if (!isInternalRegion()) {
getCachePerfStats().incReliableRegions(-1);
}
}
// Note we need to do this even if we don't have a listener
// because of the SystemMemberCacheEventProcessor. Once we have
// a way to check for existence of SystemMemberCacheEventProcessor listeners
// then the add only needs to be done if hasListener || hasAdminListener
if (eventSet != null) { // && hasListener())
eventSet.add(event);
}
try {
// call recursiveDestroyRegion on each subregion and remove it
// from this subregion map
Collection values = this.subregions.values();
for (Iterator itr = values.iterator(); itr.hasNext();) {
Object element = itr.next(); // element is a LocalRegion
LocalRegion rgn;
try {
LocalRegion.setThreadInitLevelRequirement(LocalRegion.BEFORE_INITIAL_IMAGE);
try {
rgn = toRegion(element); // converts to a LocalRegion
} finally {
LocalRegion.setThreadInitLevelRequirement(LocalRegion.AFTER_INITIAL_IMAGE);
}
}
catch (CancelException e) {
rgn = (LocalRegion)element; // ignore, keep going through the motions though
}
catch (RegionDestroyedException rde) {
// SharedRegionData was destroyed
continue;
}
// if the region is destroyed, then it is a race condition with
// failed initialization removing it from the parent subregion map
if (rgn.isDestroyed) {
continue;
}
/** ** BEGIN operating on subregion of this region (rgn) *** */
if (eventSet != null) {
event = (RegionEventImpl)event.clone();
event.region = rgn;
}
try {
rgn.recursiveDestroyRegion(eventSet, event, cacheWrite);
if (!rgn.isInternalRegion()) {
InternalDistributedSystem system = rgn.cache.getDistributedSystem();
system.handleResourceEvent(ResourceEvent.REGION_REMOVE, rgn);
}
}
catch (CancelException e) {
// I don't think this should ever happen: bulletproofing for bug 39454
if (!cache.forcedDisconnect()) {
cache.getLoggerI18n().warning(
LocalizedStrings.LocalRegion_RECURSIVEDESTROYREGION_RECURSION_FAILED_DUE_TO_CACHE_CLOSURE_REGION_0,
rgn.getFullPath(), e);
}
}
itr.remove(); // remove from this subregion map;
/** ** END operating on subregion of this region *** */
} // for
try {
if (this.indexManager != null) {
try {
this.indexManager.destroy();
}
catch (QueryException e) {
throw new IndexMaintenanceException(e);
}
}
}
catch (CancelException e) {
// I don't think this should ever happens: bulletproofing for bug 39454
if (!cache.forcedDisconnect()) {
cache.getLoggerI18n().warning(
LocalizedStrings.LocalRegion_BASICDESTROYREGION_INDEX_REMOVAL_FAILED_DUE_TO_CACHE_CLOSURE_REGION_0,
getFullPath(), e);
}
}
}
finally {
// mark this region as destroyed.
if (event.isReinitializing()) {
this.reinitialized_old = true;
}
this.cache.setRegionByPath(getFullPath(), null);
// close the UUID advisor
if (this.uuidAdvisor != null) {
this.uuidAdvisor.close(p_event);
}
if (this.eventTracker != null) {
this.eventTracker.stop();
}
if (this.diskRegion != null) {
this.diskRegion.prepareForClose(this);
}
boolean giiIndexLockAcquired = this.doPreEntryDestructionCleanup(false, event, true);
try {
closeEntries();
} finally {
this.doPostEntryDestructionCleanup(false, event, true, giiIndexLockAcquired);
}
LogWriterI18n logger = getCache().getLoggerI18n();
if (logger.fineEnabled()) {
logger.fine("recursiveDestroyRegion: Region Destroyed: "
+ getFullPath());
}
// if eventSet is null then we need to close the listener as well
// otherwise, the listener will be closed after the destroy event
try {
postDestroyRegion(!isClose, event);
}
catch (CancelException e) {
cache.getLoggerI18n().warning(
LocalizedStrings.LocalRegion_RECURSIVEDESTROYREGION_POSTDESTROYREGION_FAILED_DUE_TO_CACHE_CLOSURE_REGION_0,
getFullPath(), e);
}
// Destroy cqs created aganist this Region in a server cache.
// fix for bug #47061
if (getServerProxy() == null) {
closeCqs();
}
detachPool();
if (eventSet != null) {
closeCallbacksExceptListener();
}
else {
closeAllCallbacks();
}
if (this.concurrencyChecksEnabled && this.dataPolicy.withReplication() && !this.cache.isClosed()) {
this.cache.getTombstoneService().unscheduleTombstones(this);
}
if (this.hasOwnStats) {
this.cachePerfStats.close();
}
}
}
public void closeEntries() {
isOffHeapThreadLocal.set(Boolean.valueOf(this.enableOffHeapMemory));
this.entries.close();
}
public Set clearEntries(RegionVersionVector rvv) {
isOffHeapThreadLocal.set(Boolean.valueOf(this.enableOffHeapMemory));
return this.entries.clear(rvv);
}
@Override
public void checkReadiness()
{
checkRegionDestroyed(true);
}
/**
* This method should be called when the caller cannot locate an entry and that condition
* is unexpected. This will first double check the cache and region state before throwing
* an EntryNotFoundException. EntryNotFoundException should be a last resort exception.
*
* @param entryKey the missing entry's key.
*/
public void checkEntryNotFound(Object entryKey) {
checkReadiness();
// Localized string for partitioned region is generic enough for general use
throw new EntryNotFoundException(LocalizedStrings.PartitionedRegion_ENTRY_NOT_FOUND_FOR_KEY_0.toLocalizedString(entryKey));
}
/**
* Search for the value in a server (if one exists),
* then try a loader.
*
* If we find a value, we put it in the cache.
* @param preferCD return the CacheDeserializable, if that's what the value is.
* @param requestingClient the client making the request, if any
* @param clientEvent the client's event, if any. If not null, we set the version tag
* @param returnTombstones TODO
* @return the deserialized value
* @see DistributedRegion#findObjectInSystem(KeyInfo, boolean,
* TXStateInterface, boolean, Object, boolean, boolean,
* ClientProxyMembershipID, EntryEventImpl, boolean, boolean)
*/
protected Object findObjectInSystem(KeyInfo keyInfo, boolean isCreate,
final TXStateInterface lockState, boolean generateCallbacks,
Object localValue, boolean disableCopyOnRead, boolean preferCD,
ClientProxyMembershipID requestingClient, EntryEventImpl clientEvent,
boolean returnTombstones, boolean allowReadFromHDFS) throws CacheLoaderException, TimeoutException {
return findObjectInLocalSystem(keyInfo.getKey(), keyInfo.getCallbackArg(),
isCreate, lockState, generateCallbacks, localValue, clientEvent);
}
protected final Object findObjectInLocalSystem(final Object key,
final Object aCallbackArgument, boolean isCreate, TXStateInterface tx,
boolean generateCallbacks, Object localValue, EntryEventImpl clientEvent)
throws CacheLoaderException, TimeoutException {
Object value = null;
boolean fromServer = false;
EntryEventImpl holder = null;
/*
* First lets try the server
*/
{
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
holder = EntryEventImpl.createVersionTagHolder();
try {
value = mySRP.get(key, aCallbackArgument, holder);
fromServer = value != null;
} finally {
holder.release();
}
}
}
/*
* If we didn't get anything from the server, try the loader
*/
if (!fromServer) {
// copy into local var to prevent race condition
CacheLoader loader = basicGetLoader();
if (loader != null) {
final LoaderHelper loaderHelper
= loaderHelperFactory.createLoaderHelper(key, aCallbackArgument,
false /* netSearchAllowed */,
true /* netloadAllowed */,
null /* searcher */);
CachePerfStats stats = getCachePerfStats();
long statStart = stats.startLoad();
try {
value = loader.load(loaderHelper);
}
finally {
stats.endLoad(statStart);
}
}
}
/*
* If we got a value back, let's put it in the cache.
*/
RegionEntry re = null;
TXStateProxy txProxy = null;
if (value != null && !isMemoryThresholdReachedForLoad()) {
long startPut = CachePerfStats.getStatTime();
validateKey(key);
Operation op;
if (isCreate) {
op = Operation.LOCAL_LOAD_CREATE;
}
else {
op = Operation.LOCAL_LOAD_UPDATE;
}
EntryEventImpl event
= EntryEventImpl.create(this, op, key, value, aCallbackArgument,
false, getMyId(), generateCallbacks);
try {
// bug #47716 - do not put an invalid entry into the cache if there's
// already one there with the same version
if (fromServer) {
if (alreadyInvalid(key, event)) {
return null;
}
event.setFromServer(fromServer);
event.setVersionTag(holder.getVersionTag());
if (clientEvent != null) {
clientEvent.setVersionTag(holder.getVersionTag());
}
}
//set the event id so that we can progagate
//the value to the server
if (!fromServer) {
event.setNewEventId(cache.getDistributedSystem());
}
if (tx == null) {
tx = getTXState();
}
// if we have to do a put then need to use proxy
if (tx != null) {
txProxy = tx.getProxy();
event.setOriginRemote(!txProxy.isCoordinator());
}
event.setTXState(txProxy);
try {
try {
re = basicPutEntry(event, 0L);
if (!fromServer && clientEvent != null) {
clientEvent.setVersionTag(event.getVersionTag());
clientEvent.isConcurrencyConflict(event.isConcurrencyConflict());
}
if (fromServer && (event.getRawNewValue() == Token.TOMBSTONE)) {
return null; // tombstones are destroyed entries
}
} catch (ConcurrentCacheModificationException e) {
// this means the value attempted to overwrite a newer modification and was rejected
if (getLogWriterI18n().fineEnabled()) {
getLogWriterI18n().fine("caught concurrent modification attempt when applying " + event);
}
notifyBridgeClients(event);
}
if (txProxy == null) {
getCachePerfStats().endPut(startPut, event.isOriginRemote());
}
else {
event.setTXState(tx);
}
}
catch (CacheWriterException cwe) {
getCache().getLoggerI18n().fine("findObjectInSystem: writer exception putting entry "
+ event
+ " : " + cwe);
}
} finally {
event.release();
}
}
if (isCreate) {
recordMiss(txProxy, re, key);
}
return value;
}
protected boolean isMemoryThresholdReachedForLoad() {
return this.memoryThresholdReached.get();
}
/**
* Returns true if the cache already has this key as an invalid entry
* with a version >= the one in the given event. This is used in
* cache-miss processing to avoid overwriting the entry when it is
* not necessary, so that we avoid invoking cache listeners.
*
* @param key
* @param event
* @return whether the entry is already invalid
*/
protected boolean alreadyInvalid(Object key, EntryEventImpl event) {
@Unretained(ENTRY_EVENT_NEW_VALUE)
Object newValue = event.getRawNewValue();
if (newValue == null || Token.isInvalid(newValue)) {
RegionEntry entry = this.entries.getEntry(key);
if (entry != null) {
synchronized(entry) {
if (entry.isInvalid()) {
VersionStamp stamp = entry.getVersionStamp();
if (stamp == null || event.getVersionTag() == null) {
return true;
}
if (stamp.getEntryVersion() >= event.getVersionTag().getEntryVersion()) {
return true;
}
}
}
}
}
return false;
}
/**
* @return true if cacheWrite was performed
* @see DistributedRegion#cacheWriteBeforeDestroy(EntryEventImpl, Object)
*/
boolean cacheWriteBeforeDestroy(EntryEventImpl event, Object expectedOldValue)
throws CacheWriterException, EntryNotFoundException, TimeoutException
{
boolean result = false;
// copy into local var to prevent race condition
CacheWriter writer = basicGetWriter();
if (writer != null && event.getOperation() != Operation.REMOVE &&
!event.inhibitAllNotifications()) {
final long start = getCachePerfStats().startCacheWriterCall();
try {
writer.beforeDestroy(event);
}
finally {
getCachePerfStats().endCacheWriterCall(start);
}
result = true;
}
serverDestroy(event, expectedOldValue);
return result;
}
/** @return true if this was a client region; false if not */
protected boolean bridgeWriteBeforeDestroy(EntryEventImpl event, Object expectedOldValue)
throws CacheWriterException, EntryNotFoundException, TimeoutException
{
if (hasServerProxy()) {
serverDestroy(event, expectedOldValue);
return true;
} else {
return false;
}
}
/**
* @since 5.7
*/
protected void serverRegionDestroy(RegionEventImpl regionEvent) {
if (regionEvent.getOperation().isDistributed()) {
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
EventID eventId = regionEvent.getEventId();
Object callbackArg = regionEvent.getRawCallbackArgument();
mySRP.destroyRegion(eventId, callbackArg);
}
}
}
/**
* @since 5.7
*/
protected void serverRegionClear(RegionEventImpl regionEvent) {
if (regionEvent.getOperation().isDistributed()) {
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
EventID eventId = regionEvent.getEventId();
Object callbackArg = regionEvent.getRawCallbackArgument();
mySRP.clear(eventId, callbackArg);
}
}
}
/**
* @since 5.7
*/
protected void serverRegionInvalidate(RegionEventImpl regionEvent) {
if (regionEvent.getOperation().isDistributed()) {
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
// @todo grid: add a client to server Op message for this
}
}
}
/**
* @since 5.7
*/
protected void serverInvalidate(EntryEventImpl event, boolean invokeCallbacks,
boolean forceNewEntry) {
if (event.getOperation().isDistributed()) {
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
mySRP.invalidate(event);
}
}
}
/**
* @since 5.7
*/
protected void serverPut(EntryEventImpl event,
boolean requireOldValue, Object expectedOldValue) {
if (event.getOperation().isDistributed() && !event.isFromServer()) {
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
Operation op = event.getOperation();
if (op == Operation.PUTALL_CREATE || op == Operation.PUTALL_UPDATE) {
return;
}
// @todo grid: is the newEntry flag needed?
Object key = event.getKey();
Object value = event.getRawNewValue();
// serverPut is called by cacheWriteBeforePut so the new value will not yet be off-heap
// TODO OFFHEAP: verify that the above assertion is true
Object callbackArg = event.getRawCallbackArgument();
boolean isCreate = event.isCreate();
Object result = mySRP.put(key, value, event.getDeltaBytes(), event,
op, requireOldValue, expectedOldValue,
callbackArg, isCreate);
// bug #42296, serverproxy returns null when cache is closing
getCancelCriterion().checkCancelInProgress(null);
// if (getLogWriterI18n().fineEnabled()) {
// getLogWriterI18n().fine("serverPut: op.guaranteesOldValue()=" + op.guaranteesOldValue()
// +"; op=" + op + "; result=" + result);
// }
// if concurrent map operations failed we don't want the region map
// to apply the operation and need to throw an exception
if (op.guaranteesOldValue()) {
if (op != Operation.REPLACE || requireOldValue) {
event.setConcurrentMapOldValue(result);
}
if (op == Operation.PUT_IF_ABSENT) {
if (result != null) {
throw new EntryNotFoundException("entry existed for putIfAbsent"); // customers don't see this exception
}
} else if (op == Operation.REPLACE) {
if (requireOldValue && result == null) {
throw new EntryNotFoundException("entry not found for replace");
} else if (!requireOldValue) {
if ( !((Boolean)result).booleanValue() ) {
throw new EntryNotFoundException("entry found with wrong value"); // customers don't see this exception
}
}
}
}
}
}
}
/**
* Destroy an entry on the server given its event.
* @since 5.7
*/
protected void serverDestroy(EntryEventImpl event, Object expectedOldValue) {
if (event.getOperation().isDistributed()) {
ServerRegionProxy mySRP = getServerProxy();
if (mySRP != null) {
// send to server
Object key = event.getKey();
Object callbackArg = event.getRawCallbackArgument();
Object result = mySRP.destroy(key, expectedOldValue, event.getOperation(), event, callbackArg);
if (result instanceof EntryNotFoundException) {
throw (EntryNotFoundException)result;
}
}
}
}
/**
* @return true if cacheWrite was performed
* @see DistributedRegion#cacheWriteBeforeRegionDestroy(RegionEventImpl)
*/
boolean cacheWriteBeforeRegionDestroy(RegionEventImpl event)
throws CacheWriterException, TimeoutException
{
boolean result = false;
// copy into local var to prevent race condition
CacheWriter writer = basicGetWriter();
if (writer != null) {
final long start = getCachePerfStats().startCacheWriterCall();
try {
writer.beforeRegionDestroy(event);
}
finally {
getCachePerfStats().endCacheWriterCall(start);
}
result = true;
}
serverRegionDestroy(event);
return result;
}
protected boolean cacheWriteBeforeRegionClear(RegionEventImpl event)
throws CacheWriterException, TimeoutException
{
boolean result = false;
// copy into local var to prevent race condition
CacheWriter writer = basicGetWriter();
if (writer != null) {
final long start = getCachePerfStats().startCacheWriterCall();
try {
writer.beforeRegionClear(event);
}
finally {
getCachePerfStats().endCacheWriterCall(start);
}
result = true;
}
serverRegionClear(event);
return result;
}
/**
* @since 5.7
*/
void cacheWriteBeforeInvalidate(EntryEventImpl event, boolean invokeCallbacks, boolean forceNewEntry) {
if (!event.getOperation().isLocal() && !event.isOriginRemote()) {
serverInvalidate(event, invokeCallbacks, forceNewEntry);
}
}
/**
* @see DistributedRegion#cacheWriteBeforePut(EntryEventImpl, Set, CacheWriter, boolean, Object)
* @param event
* @param netWriteRecipients
* @param localWriter
* @param requireOldValue
* @param expectedOldValue
* @throws CacheWriterException
* @throws TimeoutException
*/
void cacheWriteBeforePut(EntryEventImpl event, Set netWriteRecipients,
CacheWriter localWriter,
boolean requireOldValue,
Object expectedOldValue)
throws CacheWriterException, TimeoutException
{
Assert.assertTrue(netWriteRecipients == null);
Operation op = event.getOperation();
if (!(op == Operation.PUT_IF_ABSENT
|| op == Operation.REPLACE) && (localWriter != null) &&
!((EntryEventImpl)event).inhibitAllNotifications()) {
final long start = getCachePerfStats().startCacheWriterCall();
final boolean newEntry = event.getOperation().isCreate();
try {
if (!newEntry) {
localWriter.beforeUpdate(event);
}
else {
localWriter.beforeCreate(event);
}
}
finally {
getCachePerfStats().endCacheWriterCall(start);
}
}
serverPut(event, requireOldValue, expectedOldValue);
}
protected final void validateArguments(Object key, Object value,
Object aCallbackArgument) {
validateKey(key);
validateValue(value);
validateCallbackArg(aCallbackArgument);
}
protected final void validateKey(Object key)
{
if (key == null) {
throw new NullPointerException(LocalizedStrings.LocalRegion_KEY_CANNOT_BE_NULL.toLocalizedString());
}
// check validity of key against keyConstraint
if (this.keyConstraint != null) {
if (!this.keyConstraint.isInstance(key))
throw new ClassCastException(LocalizedStrings.LocalRegion_KEY_0_DOES_NOT_SATISFY_KEYCONSTRAINT_1.toLocalizedString(new Object[] {key.getClass().getName(), this.keyConstraint.getName()}));
}
// We don't need to check that the key is Serializable. Instead,
// we let the lower-level (data) serialization mechanism take care
// of this for us. See bug 32394.
}
/**
* Starting in 3.5, we don't check to see if the callback argument is
* Serializable. We instead rely on the actual serialization
* (which happens in-thread with the put) to tell us if there are any
* problems.
*/
protected final void validateCallbackArg(Object aCallbackArgument)
{
}
/**
* @since 5.0.2
*/
private final boolean DO_EXPENSIVE_VALIDATIONS = Boolean.getBoolean("gemfire.DO_EXPENSIVE_VALIDATIONS");
/**
* the number of tombstone entries in the RegionMap
*/
protected AtomicInteger tombstoneCount = new AtomicInteger();
/** a boolean for issuing a client/server configuration mismatch message */
private boolean concurrencyMessageIssued;
/**
* Starting in 3.5, we don't check to see if the value is
* Serializable. We instead rely on the actual serialization
* (which happens in-thread with the put) to tell us if there are any
* problems.
*/
protected final void validateValue(Object value) {
// check validity of value against valueConstraint
if (this.valueConstraint != null) {
if (value != null) {
if (value instanceof CachedDeserializable) {
if (!DO_EXPENSIVE_VALIDATIONS) {
return;
}
value = ((CachedDeserializable)value)
.getDeserializedValue(null, null);
}
if (!this.valueConstraint.isInstance(value)) {
throw new ClassCastException(LocalizedStrings
.LocalRegion_VALUE_0_DOES_NOT_SATISFY_VALUECONSTRAINT_1
.toLocalizedString(new Object[] { value.getClass().getName(),
this.valueConstraint.getName() }));
}
}
}
}
public CachePerfStats getCachePerfStats() {
// return this.cache.getCachePerfStats();
return this.cachePerfStats;
}
public CachePerfStats getRegionPerfStats() {
return this.cachePerfStats;
}
/** regions track the number of tombstones their map holds for size calculations */
public void incTombstoneCount(int delta) {
// LogWriterI18n log = this.cache.getLoggerI18n();
// log.info(LocalizedStrings.DEBUG, "incTombstoneCount invoked with " + delta, new Exception("Stack Trace"));
this.tombstoneCount.addAndGet(delta);
this.cachePerfStats.incTombstoneCount(delta);
//Fix for 45204 - don't include the tombstones in
//any of our entry count stats.
this.cachePerfStats.incEntryCount(-delta);
if(getDiskRegion() != null) {
getDiskRegion().incNumEntriesInVM(-delta);
}
DiskEntry.Helper.incrementBucketStats(this, -delta/*InVM*/, 0/*OnDisk*/, 0);
}
public int getTombstoneCount() {
return this.tombstoneCount.get();
}
public void scheduleTombstone(RegionEntry entry, VersionTag destroyedVersion) {
Object sync = TombstoneService.DEBUG_TOMBSTONE_COUNT? TombstoneService.debugSync : new Object();
if (destroyedVersion == null) {
throw new NullPointerException("destroyed version tag cannot be null");
}
// lastUnscheduled.set(null);
synchronized(sync) {
LogWriterI18n log = getLogWriterI18n();
incTombstoneCount(1);
// if (entry instanceof AbstractRegionEntry) {
// AbstractRegionEntry are = (AbstractRegionEntry)entry;
// if (are.isTombstoneScheduled()) {
// log.severe(LocalizedStrings.DEBUG, "Scheduling a tombstone for an entry that is already a tombstone: " + entry, new Exception("stack trace"));
// throw new IllegalStateException("Attempt to schedule a tombstone for a destroyed entry that is already scheduled for expiration");
// }
// are.setTombstoneScheduled(true);
// }
if (log.fineEnabled() || TombstoneService.VERBOSE || TombstoneService.DEBUG_TOMBSTONE_COUNT) {
log.info(LocalizedStrings.DEBUG, "scheduling tombstone in " + getName() + " for " + entry.getKeyCopy()
+ " version=" + entry.getVersionStamp().asVersionTag()
+ " entry hash is 0x" + Integer.toHexString(System.identityHashCode(entry))
+ " count is " + this.tombstoneCount.get()
+ " entryMap size is " + this.entries.sizeInVM()/*, new Exception("stack trace")*/);
// this can be useful for debugging tombstone count problems if there aren't a lot of concurrent threads
if (TombstoneService.DEBUG_TOMBSTONE_COUNT && this.entries instanceof AbstractRegionMap) {
((AbstractRegionMap)this.entries).verifyTombstoneCount(tombstoneCount);
}
}
getGemFireCache().getTombstoneService().scheduleTombstone(this, entry,
destroyedVersion);
}
}
// ThreadLocal lastUnscheduled = new ThreadLocal();
// ThreadLocal lastUnscheduledPlace = new ThreadLocal();
public void rescheduleTombstone(RegionEntry entry, VersionTag version) {
LogWriterI18n log = getLogWriterI18n();
if (log.fineEnabled() || TombstoneService.VERBOSE || TombstoneService.DEBUG_TOMBSTONE_COUNT) {
log.info(LocalizedStrings.DEBUG, "rescheduling tombstone in " + getName() + " for " + entry.getKeyCopy());
}
Object sync = TombstoneService.DEBUG_TOMBSTONE_COUNT? TombstoneService.debugSync : new Object();
synchronized(sync) {
unscheduleTombstone(entry, false); // count is off by one, so don't allow validation to take place
scheduleTombstone(entry, version);
}
}
public void unscheduleTombstone(RegionEntry entry) {
unscheduleTombstone(entry, true);
}
public void unscheduleTombstone(RegionEntry entry, boolean validateCount) {
LogWriterI18n log = getLogWriterI18n();
// if (lastUnscheduled.get() == entry) {
// log.severe(LocalizedStrings.DEBUG,"unscheduling tombstone that was just unscheduled", new Exception("Second unschedule"));
// log.severe(LocalizedStrings.DEBUG,"previous unschedule point", lastUnscheduledPlace.get());
// }
// lastUnscheduled.set(entry);
// lastUnscheduledPlace.set(new Exception("first unschedule from thread '" + Thread.currentThread().getName()+"'"));
// if (entry instanceof AbstractRegionEntry) {
// AbstractRegionEntry are = (AbstractRegionEntry)entry;
// if (!are.isTombstoneScheduled()) {
// log.severe(LocalizedStrings.DEBUG, "Unscheduling a tombstone for an entry that is not marked as having been scheduled: " + are, new Exception("stack trace"));
// throw new IllegalStateException("Attempt to unschedule expiration of a destroyed entry that has not been scheduled for expiration");
// }
// are.setTombstoneScheduled(false);
// }
incTombstoneCount(-1);
if (log.fineEnabled() || TombstoneService.VERBOSE) {
log.info(LocalizedStrings.DEBUG,
"unscheduling tombstone in " + getName() + " for " + entry.getKeyCopy()
+ " entry hash is 0x" + Integer.toHexString(System.identityHashCode(entry))
+ " count is " + this.tombstoneCount.get()
+ " entryMap size is " + this.entries.sizeInVM()/*, new Exception("stack trace")*/);
}
getRegionMap().unscheduleTombstone(entry);
if (TombstoneService.DEBUG_TOMBSTONE_COUNT && validateCount) {
if (this.entries instanceof AbstractRegionMap) {
((AbstractRegionMap) this.entries).verifyTombstoneCount(this.tombstoneCount);
}
}
// we don't have to remove the entry from the sweeper since the version has
// changed. It would be costly to iterate over the tombstone list for
// every tombstone exhumed while holding the entry's lock
//this.cache.getTombstoneService().unscheduleTombstone(entry);
}
/** remove any tombstones from the given member that are <= the given version
* @param eventID event identifier for the GC operation
* @param clientRouting routing info (if null a routing is computed)
*/
public void expireTombstones(Map regionGCVersions, EventID eventID, FilterInfo clientRouting) {
Set
