@Before
public void setup() {
assertThat(factorials, is(notNullValue()));
assertThat(factorials.getName(), is(equalTo("Factorials")));
assertThat(
factorials.getFullPath(), is(equalTo(String.format("%1$sFactorials", Region.SEPARATOR))));
assertThat(factorials.getAttributes(), is(notNullValue()));
assertThat(factorials.getAttributes().getDataPolicy(), is(equalTo(DataPolicy.EMPTY)));
assertThat(
factorials.getAttributes().getPoolName(),
is(equalTo(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME)));
}
protected static void assertRegionMetaData(
final Region<?, ?> region,
final String expectedName,
final String expectedFullPath,
final DataPolicy expectedDataPolicy) {
assertNotNull(
String.format("Region (%1$s) was not properly configured and initialized!", expectedName),
region);
assertEquals(expectedName, region.getName());
assertEquals(expectedFullPath, region.getFullPath());
assertNotNull(
String.format("Region (%1$s) must have RegionAttributes defined!", expectedName),
region.getAttributes());
assertEquals(expectedDataPolicy, region.getAttributes().getDataPolicy());
assertFalse(region.getAttributes().getDataPolicy().withPersistence());
}
boolean isUsedInPartitioning() {
boolean ok = false;
// TODO: Asif: Handle this case where region is turning out to be null
// Ideally Bug 39923 workaround should ensure that region is not null. But we are doing
// this check only for Update type statements. For Select queries, it may stll be null,
// hence the check
if (this.tqi == null) {
return ok;
}
Region rgnOwningColumn = this.tqi.getRegion();
assert rgnOwningColumn != null;
RegionAttributes ra = rgnOwningColumn.getAttributes();
// If the region is a Replicated Region or if it is a PR with just
// itself
// as a member then we should go with Derby's Activation Object
DataPolicy policy = ra.getDataPolicy();
if (policy.withPartitioning()) {
PartitionedRegion pr = (PartitionedRegion) rgnOwningColumn;
GfxdPartitionResolver rslvr = (GfxdPartitionResolver) pr.getPartitionResolver();
ok = rslvr != null && rslvr.isUsedInPartitioning(this.actualColumnName);
}
return ok;
}
@Test
public void testGetRegionFactoryWithIsGlobalScope() throws Exception {
serverOptions = JSONFormatter.fromJSON("{ \"scope\": \"GLOBAL\" }");
new ScopeOption(serverOptions).setOptionOnRegionFactory(regionFactory);
Region region = regionFactory.create(getCurrentTestName());
assertThat(region.getAttributes().getScope(), equalTo(Scope.GLOBAL));
}
protected RegionMBeanBridge(Region<K, V> region) {
this.region = region;
this.regAttrs = region.getAttributes();
this.isStatisticsEnabled = regAttrs.getStatisticsEnabled();
this.regionAttributesData = RegionMBeanCompositeDataFactory.getRegionAttributesData(regAttrs);
this.membershipAttributesData =
RegionMBeanCompositeDataFactory.getMembershipAttributesData(regAttrs);
this.evictionAttributesData =
RegionMBeanCompositeDataFactory.getEvictionAttributesData(regAttrs);
this.regionMonitor =
new MBeanStatsMonitor(ManagementStrings.REGION_MONITOR.toLocalizedString());
configureRegionMetrics();
this.persistentEnabled = region.getAttributes().getDataPolicy().withPersistence();
this.regionStats = ((LocalRegion) region).getRegionPerfStats();
if (regionStats != null) {
regionMonitor.addStatisticsToMonitor(regionStats.getStats()); // fixes 46692
}
LocalRegion l = (LocalRegion) region;
if (l.getEvictionController() != null) {
LRUStatistics stats = l.getEvictionController().getLRUHelper().getStats();
if (stats != null) {
regionMonitor.addStatisticsToMonitor(stats.getStats());
EvictionAttributes ea = region.getAttributes().getEvictionAttributes();
if (ea != null && ea.getAlgorithm().isLRUMemory()) {
this.lruMemoryStats = stats;
}
}
}
if (regAttrs.getGatewaySenderIds() != null && regAttrs.getGatewaySenderIds().size() > 0) {
this.isGatewayEnabled = true;
}
this.member = GemFireCacheImpl.getInstance().getDistributedSystem().getMemberId();
}
/**
* Tests the compatibility of creating certain kinds of subregions of a local region.
*
* @see Region#createSubregion
*/
public void testIncompatibleSubregions() throws CacheException {
Region region = createRegion(this.getUniqueName());
assertEquals(Scope.LOCAL, region.getAttributes().getScope());
// A region with Scope.LOCAL can only have subregions with
// Scope.LOCAL.
try {
AttributesFactory factory = new AttributesFactory(region.getAttributes());
factory.setScope(Scope.DISTRIBUTED_NO_ACK);
RegionAttributes attrs = factory.create();
region.createSubregion(this.getUniqueName(), attrs);
fail("Should have thrown an IllegalStateException");
} catch (IllegalStateException ex) {
// pass...
}
try {
AttributesFactory factory = new AttributesFactory(region.getAttributes());
factory.setScope(Scope.DISTRIBUTED_ACK);
RegionAttributes attrs = factory.create();
region.createSubregion(this.getUniqueName(), attrs);
fail("Should have thrown an IllegalStateException");
} catch (IllegalStateException ex) {
// pass...
}
try {
AttributesFactory factory = new AttributesFactory(region.getAttributes());
factory.setScope(Scope.GLOBAL);
RegionAttributes attrs = factory.create();
region.createSubregion(this.getUniqueName(), attrs);
fail("Should have thrown an IllegalStateException");
} catch (IllegalStateException ex) {
// pass...
}
}
static <K, V> Exporter<K, V> createExporter(Region<?, ?> region, SnapshotOptions<K, V> options) {
String pool = region.getAttributes().getPoolName();
if (pool != null) {
return new ClientExporter<K, V>(PoolManager.find(pool));
} else if (InternalDistributedSystem.getAnyInstance().isLoner()
|| region.getAttributes().getDataPolicy().equals(DataPolicy.NORMAL)
|| region.getAttributes().getDataPolicy().equals(DataPolicy.PRELOADED)
|| region instanceof LocalDataSet
|| (((SnapshotOptionsImpl<K, V>) options).isParallelMode()
&& region.getAttributes().getDataPolicy().withPartitioning())) {
// Avoid function execution:
// for loner systems to avoid inlining fn execution
// for NORMAL/PRELOAD since they don't support fn execution
// for LocalDataSet since we're already running a fn
// for parallel ops since we're already running a fn
return new LocalExporter<K, V>();
}
return new WindowedExporter<K, V>();
}
public static void waitForDestroyEvent(Region r, final Object key) {
final CertifiableTestCacheListener ccl =
(CertifiableTestCacheListener) r.getAttributes().getCacheListener();
WaitCriterion ev =
new WaitCriterion() {
public boolean done() {
return ccl.destroys.contains(key);
}
public String description() {
return "waiting for destroy event for " + key;
}
};
DistributedTestCase.waitForCriterion(ev, 10 * 1000, 200, true);
ccl.destroys.remove(key);
}
public Object evaluate(ExecutionContext context) throws RegionNotFoundException {
Region rgn;
Cache cache = context.getCache();
// do PR bucketRegion substitution here for expressions that evaluate to a Region.
PartitionedRegion pr = context.getPartitionedRegion();
if (pr != null && pr.getFullPath().equals(this.regionPath)) {
rgn = context.getBucketRegion();
} else if (pr != null) {
// Asif : This is a very tricky solution to allow equijoin queries on PartitionedRegion
// locally
// We have possibly got a situation of equijoin. it may be across PRs. so use the context's
// bucket region
// to get ID and then retrieve the this region's bucket region
BucketRegion br = context.getBucketRegion();
int bucketID = br.getId();
// Is current region a partitioned region
rgn = cache.getRegion(this.regionPath);
if (rgn.getAttributes().getDataPolicy().withPartitioning()) {
// convert it into bucket region.
PartitionedRegion prLocal = (PartitionedRegion) rgn;
rgn = prLocal.getDataStore().getLocalBucketById(bucketID);
}
} else {
rgn = cache.getRegion(this.regionPath);
}
if (rgn == null) {
// if we couldn't find the region because the cache is closed, throw
// a CacheClosedException
if (cache.isClosed()) {
throw new CacheClosedException();
}
throw new RegionNotFoundException(
LocalizedStrings.CompiledRegion_REGION_NOT_FOUND_0.toLocalizedString(this.regionPath));
}
if (context.isCqQueryContext()) {
return new QRegion(rgn, true, context);
} else {
return new QRegion(rgn, false, context);
}
}
public static RegionMBeanBridge getInstance(Region region) {
if (region.getAttributes().getPartitionAttributes() != null) {
RegionMBeanBridge bridge = new PartitionedRegionBridge(region);
PartitionedRegion parRegion = ((PartitionedRegion) region);
DiskStoreImpl dsi = parRegion.getDiskStore();
if (dsi != null) {
DiskRegionStats stats = parRegion.getDiskRegionStats();
DiskRegionBridge diskRegionBridge = new DiskRegionBridge(stats);
bridge.addDiskRegionBridge(diskRegionBridge);
for (DirectoryHolder dh : dsi.getDirectoryHolders()) {
diskRegionBridge.addDirectoryStats(dh.getDiskDirectoryStats());
}
bridge.addDiskRegionBridge(diskRegionBridge);
}
return bridge;
} else {
RegionMBeanBridge bridge = new RegionMBeanBridge(region);
LocalRegion localRegion = ((LocalRegion) region);
DiskStoreImpl dsi = localRegion.getDiskStore();
if (dsi != null) {
DiskRegionBridge diskRegionBridge =
new DiskRegionBridge(localRegion.getDiskRegion().getStats());
bridge.addDiskRegionBridge(diskRegionBridge);
for (DirectoryHolder dh : dsi.getDirectoryHolders()) {
diskRegionBridge.addDirectoryStats(dh.getDiskDirectoryStats());
}
}
return bridge;
}
}
@SuppressWarnings("rawtypes")
@Test
public void testReplicaWithAttributes() throws Exception {
assertTrue(context.containsBean("replicated-with-attributes"));
Region region = context.getBean("replicated-with-attributes", Region.class);
RegionAttributes attrs = region.getAttributes();
assertEquals(10, attrs.getInitialCapacity());
assertEquals(true, attrs.getIgnoreJTA());
assertEquals(false, attrs.getIndexMaintenanceSynchronous());
assertEquals(String.class, attrs.getKeyConstraint());
assertEquals(String.class, attrs.getValueConstraint());
assertEquals(true, attrs.isDiskSynchronous());
assertEquals(Scope.GLOBAL, attrs.getScope());
// assertEquals(true, attrs.isLockGrantor());
assertEquals(true, attrs.getEnableAsyncConflation());
assertEquals(true, attrs.getEnableSubscriptionConflation());
assertEquals(0.50, attrs.getLoadFactor(), 0.001);
assertEquals(false, attrs.getCloningEnabled());
assertEquals(10, attrs.getConcurrencyLevel());
assertEquals(true, attrs.getMulticastEnabled());
}
/**
* Tests that if a <code>CacheLoader</code> for a local region invokes {@link
* LoaderHelper#netSearch}, a {@link CacheLoaderException} is thrown.
*/
public void testLocalLoaderNetSearch() throws CacheException {
assertEquals(Scope.LOCAL, getRegionAttributes().getScope());
final String name = this.getUniqueName();
final Object key = this.getUniqueName();
TestCacheLoader loader =
new TestCacheLoader() {
public Object load2(LoaderHelper helper) throws CacheLoaderException {
try {
helper.netSearch(true);
} catch (TimeoutException ex) {
fail("Why did I timeout?", ex);
}
return null;
}
};
AttributesFactory factory = new AttributesFactory(getRegionAttributes());
factory.setCacheLoader(loader);
Region region = createRegion(name, factory.create());
assertEquals(Scope.LOCAL, region.getAttributes().getScope());
try {
region.get(key);
fail("Should have thrown a CacheLoaderException");
} catch (CacheLoaderException ex) {
String expected =
com.gemstone.gemfire.internal.cache.LoaderHelperImpl.NET_SEARCH_LOCAL.toLocalizedString();
String message = ex.getMessage();
assertTrue("Unexpected message \"" + message + "\"", message.indexOf(expected) != -1);
}
}
public static void acquireConnectionsAndDestroyEntriesK1andK2() {
try {
Region r1 = cache.getRegion(Region.SEPARATOR + REGION_NAME);
assertNotNull(r1);
String poolName = r1.getAttributes().getPoolName();
assertNotNull(poolName);
PoolImpl pool = (PoolImpl) PoolManager.find(poolName);
assertNotNull(pool);
Connection conn = pool.acquireConnection();
final Connection conn1;
if (conn.getServer().getPort() != PORT2) {
conn1 = pool.acquireConnection(); // Ensure we have a server with the proper port
} else {
conn1 = conn;
}
assertNotNull(conn1);
assertEquals(PORT2, conn1.getServer().getPort());
ServerRegionProxy srp = new ServerRegionProxy(Region.SEPARATOR + REGION_NAME, pool);
srp.destroyOnForTestsOnly(
conn1,
"key1",
null,
Operation.DESTROY,
new EntryEventImpl(new EventID(new byte[] {1}, 100000, 1)),
null);
srp.destroyOnForTestsOnly(
conn1,
"key2",
null,
Operation.DESTROY,
new EntryEventImpl(new EventID(new byte[] {1}, 100000, 2)),
null);
} catch (Exception ex) {
throw new TestException("Failed while setting acquireConnectionsAndDestroyEntry ", ex);
}
}
/**
* Appends to a StringBuffer logging that describes a DiskSTore for the given Region.
*
* @param aRegion The Region possibly containing a DiskStore.
* @param aStr The StringBuffer to append to.
*/
public static void logDiskStore(Region aRegion, StringBuffer aStr) {
if (aRegion.getAttributes().getDiskStoreName() != null) {
aStr.append(" diskStoreName " + aRegion.getAttributes().getDiskStoreName());
}
}
private boolean shouldRunInParallel(SnapshotOptions<K, V> options) {
return ((SnapshotOptionsImpl<K, V>) options).isParallelMode()
&& region.getAttributes().getDataPolicy().withPartitioning()
&& !(region instanceof LocalDataSet);
}
/**
* Initializes without children.
*
* @param region The region from which RegionInfo is extracted.
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private void init(Region region) {
if (region == null) {
return;
}
DistributedMember member =
CacheFactory.getAnyInstance().getDistributedSystem().getDistributedMember();
setName(region.getName());
setFullPath(region.getFullPath());
GemfireRegionAttributeInfo attrInfo = new GemfireRegionAttributeInfo();
RegionAttributes<?, ?> attr = region.getAttributes();
attrInfo.setAttribute(GemfireRegionAttributeInfo.DATA_POLICY, attr.getDataPolicy().toString());
attrInfo.setAttribute(GemfireRegionAttributeInfo.SCOPE, attr.getScope().toString());
if (region instanceof PartitionedRegion) {
PartitionedRegion pr = (PartitionedRegion) region;
PartitionAttributes pattr = pr.getPartitionAttributes();
attrInfo.setAttribute(
GemfireRegionAttributeInfo.LOCAL_MAX_MEMORY, pattr.getLocalMaxMemory() + "");
attrInfo.setAttribute(
GemfireRegionAttributeInfo.REDUNDANT_COPIES, pattr.getRedundantCopies() + "");
attrInfo.setAttribute(
GemfireRegionAttributeInfo.TOTAL_MAX_MEMORY, pattr.getTotalMaxMemory() + "");
attrInfo.setAttribute(
GemfireRegionAttributeInfo.TOTAL_NUM_BUCKETS, pattr.getTotalNumBuckets() + "");
// data store is null if it's a proxy, i.e., LOCAL_MAX_MEMORY=0
if (pr.getDataStore() != null) {
Set<BucketRegion> localtBuketSet = pr.getDataStore().getAllLocalBucketRegions();
List<BucketInfo> primaryList = new ArrayList<BucketInfo>();
List<BucketInfo> redundantList = new ArrayList<BucketInfo>();
this.size = 0;
for (BucketRegion br : localtBuketSet) {
BucketInfo bucketInfo =
new GemfireBucketInfo(
br.getId(), br.getBucketAdvisor().isPrimary(), br.size(), br.getTotalBytes());
// InternalDistributedMember m = pr.getBucketPrimary(br.getId());
// if (m.getId().equals(member.getId())) {
if (bucketInfo.isPrimary()) {
primaryList.add(bucketInfo);
this.size += bucketInfo.getSize();
} else {
redundantList.add(bucketInfo);
}
}
Collections.sort(primaryList);
Collections.sort(redundantList);
setPrimaryBucketInfoList(primaryList);
setRedundantBucketInfoList(redundantList);
}
} else {
this.size = region.size();
}
setAttrInfo(attrInfo);
temporalType = GemfireTemporalManager.getTemporalType(region);
if (region.isDestroyed() == false && region.isEmpty() == false) {
Set<Map.Entry> regionEntrySet = region.entrySet();
for (Map.Entry entry : regionEntrySet) {
Object key = entry.getKey();
Object value = entry.getValue();
keyTypeName = key.getClass().getName();
valueTypeName = value.getClass().getName();
break;
}
}
}
/**
* Return whether the given region has persistence
*
* @param aRegion The Region to check for persistence.
* @return True if the region has persistence, false otherwise.
*/
public static boolean withPersistence(Region aRegion) {
// only GemFire 6.5 (and beyond) has a method for DataPolicy.withPersistence()
return aRegion.getAttributes().getDataPolicy().withPersistence();
}
@SuppressWarnings({"rawtypes", "unchecked"})
private void doRegionTest(final RegionShortcut rs, final String rName, boolean compressed) {
boolean isPersistent =
rs == RegionShortcut.LOCAL_PERSISTENT
|| rs == RegionShortcut.REPLICATE_PERSISTENT
|| rs == RegionShortcut.PARTITION_PERSISTENT;
GemFireCacheImpl gfc = createCache(isPersistent);
Region r = null;
try {
gfc.setCopyOnRead(true);
final MemoryAllocator ma = gfc.getOffHeapStore();
assertNotNull(ma);
assertEquals(0, ma.getUsedMemory());
Compressor compressor = null;
if (compressed) {
compressor = SnappyCompressor.getDefaultInstance();
}
r = gfc.createRegionFactory(rs).setOffHeap(true).setCompressor(compressor).create(rName);
assertEquals(true, r.isEmpty());
assertEquals(0, ma.getUsedMemory());
Object data = new Integer(123456789);
r.put("key1", data);
// System.out.println("After put of Integer value off heap used memory=" +
// ma.getUsedMemory());
assertTrue(ma.getUsedMemory() == 0);
assertEquals(data, r.get("key1"));
r.invalidate("key1");
assertEquals(0, ma.getUsedMemory());
r.put("key1", data);
assertTrue(ma.getUsedMemory() == 0);
long usedBeforeUpdate = ma.getUsedMemory();
r.put("key1", data);
assertEquals(usedBeforeUpdate, ma.getUsedMemory());
assertEquals(data, r.get("key1"));
r.destroy("key1");
assertEquals(0, ma.getUsedMemory());
data = new Long(0x007FFFFFL);
r.put("key1", data);
if (!compressed) {
assertTrue(ma.getUsedMemory() == 0);
}
assertEquals(data, r.get("key1"));
data = new Long(0xFF8000000L);
r.put("key1", data);
if (!compressed) {
assertTrue(ma.getUsedMemory() == 0);
}
assertEquals(data, r.get("key1"));
// now lets set data to something that will be stored offheap
data = new Long(Long.MAX_VALUE);
r.put("key1", data);
assertEquals(data, r.get("key1"));
// System.out.println("After put of Integer value off heap used memory=" +
// ma.getUsedMemory());
assertTrue(ma.getUsedMemory() > 0);
data = new Long(Long.MIN_VALUE);
r.put("key1", data);
assertEquals(data, r.get("key1"));
// System.out.println("After put of Integer value off heap used memory=" +
// ma.getUsedMemory());
assertTrue(ma.getUsedMemory() > 0);
r.invalidate("key1");
assertEquals(0, ma.getUsedMemory());
r.put("key1", data);
assertTrue(ma.getUsedMemory() > 0);
usedBeforeUpdate = ma.getUsedMemory();
r.put("key1", data);
assertEquals(usedBeforeUpdate, ma.getUsedMemory());
assertEquals(data, r.get("key1"));
r.destroy("key1");
assertEquals(0, ma.getUsedMemory());
// confirm that byte[] do use off heap
{
byte[] originalBytes = new byte[1024];
Object oldV = r.put("byteArray", originalBytes);
long startUsedMemory = ma.getUsedMemory();
assertEquals(null, oldV);
byte[] readBytes = (byte[]) r.get("byteArray");
if (originalBytes == readBytes) {
fail("Expected different byte[] identity");
}
if (!Arrays.equals(readBytes, originalBytes)) {
fail("Expected byte array contents to be equal");
}
assertEquals(startUsedMemory, ma.getUsedMemory());
oldV = r.put("byteArray", originalBytes);
if (!compressed) {
assertEquals(null, oldV); // we default to old value being null for offheap
}
assertEquals(startUsedMemory, ma.getUsedMemory());
readBytes = (byte[]) r.putIfAbsent("byteArray", originalBytes);
if (originalBytes == readBytes) {
fail("Expected different byte[] identity");
}
if (!Arrays.equals(readBytes, originalBytes)) {
fail("Expected byte array contents to be equal");
}
assertEquals(startUsedMemory, ma.getUsedMemory());
if (!r.replace("byteArray", readBytes, originalBytes)) {
fail("Expected replace to happen");
}
assertEquals(startUsedMemory, ma.getUsedMemory());
byte[] otherBytes = new byte[1024];
otherBytes[1023] = 1;
if (r.replace("byteArray", otherBytes, originalBytes)) {
fail("Expected replace to not happen");
}
if (r.replace("byteArray", "bogus string", originalBytes)) {
fail("Expected replace to not happen");
}
if (r.remove("byteArray", "bogus string")) {
fail("Expected remove to not happen");
}
assertEquals(startUsedMemory, ma.getUsedMemory());
if (!r.remove("byteArray", originalBytes)) {
fail("Expected remove to happen");
}
assertEquals(0, ma.getUsedMemory());
oldV = r.putIfAbsent("byteArray", "string value");
assertEquals(null, oldV);
assertEquals("string value", r.get("byteArray"));
if (r.replace("byteArray", "string valuE", originalBytes)) {
fail("Expected replace to not happen");
}
if (!r.replace("byteArray", "string value", originalBytes)) {
fail("Expected replace to happen");
}
oldV = r.destroy("byteArray"); // we default to old value being null for offheap
if (!compressed) {
assertEquals(null, oldV);
}
MyCacheListener listener = new MyCacheListener();
r.getAttributesMutator().addCacheListener(listener);
try {
Object valueToReplace = "string value1";
r.put("byteArray", valueToReplace);
assertEquals(null, listener.ohOldValue);
if (!compressed) {
assertEquals("string value1", listener.ohNewValue.getDeserializedForReading());
valueToReplace = listener.ohNewValue;
}
if (!r.replace("byteArray", valueToReplace, "string value2")) {
fail("expected replace to happen");
}
if (!compressed) {
assertEquals("string value2", listener.ohNewValue.getDeserializedForReading());
assertEquals("string value1", listener.ohOldValue.getDeserializedForReading());
}
// make sure that a custom equals/hashCode are not used when comparing values.
} finally {
r.getAttributesMutator().removeCacheListener(listener);
}
}
assertTrue(ma.getUsedMemory() > 0);
{
Object key = "MyValueWithPartialEquals";
MyValueWithPartialEquals v1 = new MyValueWithPartialEquals("s1");
MyValueWithPartialEquals v2 = new MyValueWithPartialEquals("s2");
MyValueWithPartialEquals v3 = new MyValueWithPartialEquals("s1");
r.put(key, v1);
try {
if (r.replace(key, v2, "should not happen")) {
fail("v1 should not be equal to v2 on an offheap region");
}
if (!r.replace(key, v3, "should happen")) {
fail("v1 should be equal to v3 on an offheap region");
}
r.put(key, v1);
if (r.remove(key, v2)) {
fail("v1 should not be equal to v2 on an offheap region");
}
if (!r.remove(key, v3)) {
fail("v1 should be equal to v3 on an offheap region");
}
} finally {
r.remove(key);
}
}
{
Object key = "MyPdxWithPartialEquals";
MyPdxWithPartialEquals v1 = new MyPdxWithPartialEquals("s", "1");
MyPdxWithPartialEquals v2 = new MyPdxWithPartialEquals("s", "2");
MyPdxWithPartialEquals v3 = new MyPdxWithPartialEquals("t", "1");
r.put(key, v1);
try {
if (r.replace(key, v3, "should not happen")) {
fail("v1 should not be equal to v3 on an offheap region");
}
if (!r.replace(key, v2, "should happen")) {
fail("v1 should be equal to v2 on an offheap region");
}
r.put(key, v1);
if (r.remove(key, v3)) {
fail("v1 should not be equal to v3 on an offheap region");
}
if (!r.remove(key, v2)) {
fail("v1 should be equal to v2 on an offheap region");
}
} finally {
r.remove(key);
}
}
byte[] value = new byte[1024];
/*while (value != null) */ {
r.put("byteArray", value);
}
r.remove("byteArray");
assertEquals(0, ma.getUsedMemory());
r.put("key1", data);
assertTrue(ma.getUsedMemory() > 0);
r.invalidateRegion();
assertEquals(0, ma.getUsedMemory());
r.put("key1", data);
assertTrue(ma.getUsedMemory() > 0);
try {
r.clear();
assertEquals(0, ma.getUsedMemory());
} catch (UnsupportedOperationException ok) {
}
r.put("key1", data);
assertTrue(ma.getUsedMemory() > 0);
if (r.getAttributes().getDataPolicy().withPersistence()) {
r.put("key2", Integer.valueOf(1234567890));
r.put("key3", new Long(0x007FFFFFL));
r.put("key4", new Long(0xFF8000000L));
assertEquals(4, r.size());
r.close();
assertEquals(0, ma.getUsedMemory());
// simple test of recovery
r = gfc.createRegionFactory(rs).setOffHeap(true).create(rName);
assertEquals(4, r.size());
assertEquals(data, r.get("key1"));
assertEquals(Integer.valueOf(1234567890), r.get("key2"));
assertEquals(new Long(0x007FFFFFL), r.get("key3"));
assertEquals(new Long(0xFF8000000L), r.get("key4"));
closeCache(gfc, true);
assertEquals(0, ma.getUsedMemory());
gfc = createCache();
if (ma != gfc.getOffHeapStore()) {
fail("identity of offHeapStore changed when cache was recreated");
}
r = gfc.createRegionFactory(rs).setOffHeap(true).create(rName);
assertTrue(ma.getUsedMemory() > 0);
assertEquals(4, r.size());
assertEquals(data, r.get("key1"));
assertEquals(Integer.valueOf(1234567890), r.get("key2"));
assertEquals(new Long(0x007FFFFFL), r.get("key3"));
assertEquals(new Long(0xFF8000000L), r.get("key4"));
}
r.destroyRegion();
assertEquals(0, ma.getUsedMemory());
} finally {
if (r != null && !r.isDestroyed()) {
r.destroyRegion();
}
closeCache(gfc, false);
}
}
public String getRegionType() {
return region.getAttributes().getDataPolicy().toString();
}
public <K, V> Set<Integer> getLocalBucketSet(Region<K, V> region) {
if (!region.getAttributes().getDataPolicy().withPartitioning()) {
return null;
}
return this.localBucketSet;
}
public Index createIndex(
String indexName,
IndexType indexType,
String indexedExpression,
String fromClause,
String imports,
boolean loadEntries,
Region region)
throws IndexNameConflictException, IndexExistsException, RegionNotFoundException {
if (pool != null) {
throw new UnsupportedOperationException(
"Index creation on the server is not supported from the client.");
}
PartitionedIndex parIndex = null;
if (region == null) {
region = getRegionFromPath(imports, fromClause);
}
RegionAttributes ra = region.getAttributes();
// Asif: If the evistion action is Overflow to disk then do not allow index creation
// It is Ok to have index creation if it is persist only mode as data will always
// exist in memory
// if(ra.getEvictionAttributes().getAction().isOverflowToDisk() ) {
// throw new
// UnsupportedOperationException(LocalizedStrings.DefaultQueryService_INDEX_CREATION_IS_NOT_SUPPORTED_FOR_REGIONS_WHICH_OVERFLOW_TO_DISK_THE_REGION_INVOLVED_IS_0.toLocalizedString(regionPath));
// }
// if its a pr the create index on all of the local buckets.
if (((LocalRegion) region).heapThresholdReached.get()
&& !InternalResourceManager.isLowMemoryExceptionDisabled()) {
LocalRegion lr = (LocalRegion) region;
throw new LowMemoryException(
LocalizedStrings.ResourceManager_LOW_MEMORY_FOR_INDEX.toLocalizedString(region.getName()),
lr.getHeapThresholdReachedMembers());
}
if (region instanceof PartitionedRegion) {
try {
parIndex =
(PartitionedIndex)
((PartitionedRegion) region)
.createIndex(
false,
indexType,
indexName,
indexedExpression,
fromClause,
imports,
loadEntries);
} catch (ForceReattemptException ex) {
region
.getCache()
.getLoggerI18n()
.info(
LocalizedStrings
.DefaultQueryService_EXCEPTION_WHILE_CREATING_INDEX_ON_PR_DEFAULT_QUERY_PROCESSOR,
ex);
} catch (IndexCreationException exx) {
region
.getCache()
.getLoggerI18n()
.info(
LocalizedStrings
.DefaultQueryService_EXCEPTION_WHILE_CREATING_INDEX_ON_PR_DEFAULT_QUERY_PROCESSOR,
exx);
}
return parIndex;
} else {
IndexManager indexManager = IndexUtils.getIndexManager(region, true);
Index index =
indexManager.createIndex(
indexName,
indexType,
indexedExpression,
fromClause,
imports,
null,
null,
loadEntries);
return index;
}
}